The engineering role that lives between software and the real world: part builder, part detective, part diplomat — working where customer problems, messy systems, and production software collide.

Tuesday, 9:14 AM. You're on a video call with a city operations director named Maria. Her team is drowning in 40,000 unresolved service requests. She thinks AI might help. She is not sure what she needs. Her data engineer doesn't trust the source data. Her security lead won't let complaint text leave the building. And the borough manager just wants his Excel exports.

You have six weeks, a messy API, and a deadline that will not move.

Welcome to forward deployed engineering.

What the title actually means

A Forward Deployed Engineer is an engineer who builds and ships close to the customer's world rather than only inside their own company's product roadmap. The word "deployed" is military in origin — it means stationed where the action is. FDEs embed with customers (sometimes literally on-site, sometimes embedded in their Slack and systems) to turn ambiguous, messy, high-stakes business problems into working software.

One week you're integrating a client's 15-year-old system with a modern API. The next you're prototyping an AI feature in the middle of a live sales cycle because the deal depends on it. The next you're debugging a production pipeline during a high-stakes launch — because you often have to understand enough of the whole system to keep the deployment moving instead of waiting for every problem to be handed to another specialist. That's the job.

Put simply: an FDE doesn't just build software for a customer. An FDE discovers what the customer actually needs, makes the solution work in their environment, and helps prove that it improved the customer's workflow.

Palantir popularized the forward-deployed engineering model, and closely related customer-engineering roles have since appeared across AI and enterprise software companies — from frontier AI labs to infrastructure startups.

01 · Discover→02 · Scope→03 · Build→04 · Deploy→05 · Adopt→06 · Learn

The FDE delivery lifecycle. If you remember only one diagram from this chapter, remember this one — you'll see it again in every stage of this guide.

FDE vs. everything else

The role sits at an intersection that confuses people, so let's draw the boundaries:

RoleTypical emphasis
Backend EngineerBuilding and operating the core product
Sales EngineerTechnical evaluation, demos, proofs of concept — helping win the customer
Solutions ArchitectDesigning how the customer's systems and the product fit together
Forward Deployed EngineerHands-on delivery from ambiguous problem through working production deployment and adoption

The boundaries vary by company — at many places, SAs prototype and integrate, and some sales engineers stay deeply involved through deployment. The distinguishing FDE pattern is unusually deep ownership across customer discovery, implementation, production deployment, and adoption.

What "deployed" looks like day to day

"Forward deployed" doesn't always mean sitting permanently in a customer's office. Depending on the company, you might work mostly remotely, spend a few days on-site for discovery and launches, or travel frequently between strategic customers. The important part is that you operate close to the customer's workflows rather than far away from them.

The FDE is the rare role that demands both deep technical craft and genuine customer sense. You're not a pure backend engineer — you talk to humans, read rooms, and write status updates non-technical stakeholders can follow. You're not a sales engineer doing slideware — you ship production code that survives contact with reality.

An illustrative FDE workday

Illustrative schedule, not a universal routine:

  • 9:00 AM — Customer discovery call: understand why the current workflow fails
  • 10:30 AM — Debug a failed API integration with the customer's engineer
  • 1:00 PM — Write and test a data-validation fix
  • 3:00 PM — Review deployment evidence and security constraints
  • 4:30 PM — Explain progress, risks, and next decisions to the customer

You may enjoy FDE work if you like coding but also want to understand why the software matters; if you're comfortable investigating unfamiliar systems; if you can explain tradeoffs to non-engineers; and if you prefer owning a customer outcome over owning only one component. You may prefer a traditional product-engineering role if you want longer periods of focused product development, fewer customer-facing commitments, or less context switching.

Who hires FDEs (and what they call it)

The same skill stack unlocks a family of titles. Learn once, apply everywhere:

Related roles: Forward Deployed Engineer · Solutions Architect · Customer Engineer · Sales Engineer · Applied AI Engineer · Deployment Engineer.

Palantir is closely associated with the Forward Deployed Engineer title. Organizations such as OpenAI, Databricks, and enterprise AI startups also use customer-facing engineering and deployment models, although the titles, responsibilities, and technical expectations vary. At early-stage startups, founders are often doing FDE work themselves before they can hire for it full-time.

Why this role, why now

AI made software cheap to prototype and hard to deploy. AI has made prototypes dramatically easier to build, but enterprise deployment remains difficult — a demo can look impressive while failing on real customer data, permissions, integrations, latency, cost, or operational reliability.

As prototyping becomes faster, integrating, securing, evaluating, and operating software inside real organizations becomes an increasingly important bottleneck. That has increased the value of engineers who can bridge the gap between prototype and production. Every company selling AI to enterprises has the same problem: the demo works, the deployment doesn't — and they need engineers who can close that gap on-site.

What the job is NOT

Myth 1: "It's just consulting with a cooler title."
The difference isn't that consultants never code — many implementation consultants build production systems. It's that FDE roles commonly combine software-engineering depth, close customer engagement, and direct ownership of making a product work in a customer's environment. You don't stop at the recommendation deck — you may write the pipeline, deploy it, monitor it, and help the customer adopt it.

Myth 2: "It's a less technical role for people who like meetings."
The opposite. You need enough technical breadth to investigate problems across systems, enough depth to build reliable solutions, and enough judgment to know when to bring in a specialist. The goal isn't to become an expert in every field — it's to own the outcome without pretending to know everything.

Myth 3: "You just customize the product for each client."
Sometimes. But the best FDEs also do discovery (figuring out what problem to solve), make scope decisions (what to refuse to build), drive adoption (getting people to actually use it), and feed field learnings back into the product so the next deployment is easier.

The skills that actually matter

Strip away the job descriptions and the FDE skill stack looks like this:

Must know

  • Coding fundamentals: writing, debugging, testing code, and Git
  • Integration: APIs, auth, webhooks, and debugging systems you didn't build
  • Data: SQL, cleaning messy data, proving your numbers reconcile
  • Customer discovery and communication: scoping, saying no, explaining tradeoffs
  • Deployment: Docker, CI/CD, monitoring, troubleshooting — a successful demo proves possibility; a production deployment proves the solution can operate under real constraints

Useful later

  • For AI-focused FDE roles: LLM fundamentals, RAG, evaluation, guardrails
  • Specialization: advanced agent architectures, fine-tuning
  • Role-dependent depth: Kubernetes, Terraform, complex networking
  • Frontend polish beyond functional operator UIs

Don't memorize this

  • Any specific vendor's console clicks — they change yearly
  • Algorithm trivia as the whole game — FDE interviews often weight practical coding, debugging, system design, ambiguity, and customer judgment unusually heavily, though coding fundamentals still matter
  • The exact OAuth2 RFC — understand the flows, look up the details

Notice what's at the top of "must know": customer judgment sits alongside technical skills. That's the thesis of this entire site. The engineers who get hired aren't the ones who know the most technologies — they're the ones companies would trust inside their biggest account.

How this site gets you there

The guide follows six learning stages. Throughout the technical stages, you'll build CityOps — a service-request operations platform for a city team — piece by piece, turning each new skill into a working milestone, with the stakeholders above (Maria, Dev, Lisa, Tom) making your life interesting at every step. At the end, two capstone experiences test your judgment: handling real-world production incidents and onboarding a new customer from discovery to measurable outcome.

By the end, you'll have an end-to-end project that demonstrates how you clarify a customer problem, ingest and reconcile messy data, build secure APIs, evaluate AI features, deploy and monitor the system, and explain the business outcome. You'll also practice the customer conversations and technical decisions that make those skills useful in an FDE interview.

The stages:

1. Foundations & Discovery — how the web, networks, and data work, plus the discovery and scoping skills that come before any code.
2. Python & Data — your working language: scripting, SQL, wrangling, testing.
3. APIs & Integration — the core craft: connecting systems, auth, webhooks, legacy translation.
4. Data & LLMs — RAG, tool-using agents, evals, guardrails that survive security review.
5. Deploy Like a Pro — Docker, CI/CD, monitoring, enterprise deployment realities.
6. Get Hired — resume, portfolio, interview loops, negotiation.

Each technical stage ends with a working milestone on the CityOps project. Each milestone is graded on outcomes — technical correctness, sure, but also scope discipline, communication, and whether a customer would actually use what you built.

Frequently asked questions

What is forward deployed engineering?

Forward deployed engineering is the practice of embedding engineers directly with customers to deliver working software against the customer's real problem — not shipping a product and walking away. The "forward deployed" part means the engineer goes forward, to where the problem lives: the customer's data, systems, and stakeholders. It's the last mile of enterprise software, and it has its own skill set: discovery, integration under constraints, and customer judgment.

What do forward deployed engineers do day to day?

A mix of engineering and customer work: discovering what stakeholders actually need, building on top of messy customer data, integrating with systems you don't control, debugging production issues in customer environments, and explaining trade-offs to non-technical people. Much of the job is code; the rest is judgment — deciding what to build, what to cut, and what to tell the customer.

What is the forward deployed engineer role, exactly?

It's a software engineering role defined by ownership of delivery outcomes at customer sites, rather than ownership of a codebase or product area. An FDE is accountable for making the customer's problem go away using the company's platform — writing code, unblocking data access, configuring systems, and managing the relationship. Titles vary: some companies say Forward Deployed Software Engineer; others fold it into Solutions Architect, Customer Engineer, or Applied AI Engineer.

What does "forward deployed engineer as a service" mean?

It's a delivery model where embedded engineering is the product: instead of selling software licenses and leaving integration to you, the company deploys engineers who implement, integrate, and operate the solution inside your organization. Palantir pioneered both the role and this model — the engineers are the delivery mechanism.

Field check

  1. Explain to a non-technical friend what an FDE does in two sentences. If you mention a specific technology, try again.
  2. How do Sales Engineer and FDE responsibilities typically differ? Why does ongoing delivery ownership change the engineering decisions you make?
  3. Maria says, "We need an AI chatbot to solve our backlog problem." You have 20 minutes for discovery. What are the first three questions you ask — and what evidence would tell you a chatbot isn't the right solution?
What a good answer looks like

Don't start with AI. First understand the workflow, the users, the failure points, the current process, the available data, the constraints, and the success metric. AI is one possible implementation — not the problem definition. If you can't describe what "working" looks like without mentioning a technology, you haven't done discovery yet.

For Maria's chatbot request, good opening questions sound like: "Who currently decides which service requests are urgent?" "Where does that information live today?" "How will we know the new workflow is better than the current one?" If the answers show the real problem is triage rules nobody wrote down — not conversation — a chatbot isn't the solution.