Every AI company is hiring Forward Deployed Engineers and every client is asking whether they need one. The role is older than the hype. What changed is how much one engineer embedded in the problem can now ship.
Forward Deployed Engineer has become the most-copied job title in AI. The model labs are hiring them, most AI startups with an enterprise motion are hiring them and this year we started getting asked by clients whether they should create the role internally.
The job descriptions don't help. Half of them read like a sales engineer, a quarter like a solutions architect and the rest like a senior backend engineer who is also expected to run workshops. It's hard to tell from the outside whether this is a real discipline or a rebrand.
Our view, after a year of doing a version of this work on most of our engagements: the role is real, it isn't new and the reason it's suddenly everywhere says something useful about where the value in AI systems actually sits.
The title comes from Palantir, which embedded engineers directly with customers in the 2000s and 2010s. The logic was simple. The platform was powerful and general, the customer's problem was specific and messy and the distance between the two was too large to close with documentation and a support ticket. So you sent an engineer to sit inside the customer's problem until the platform did something useful with it.
Systems integrators and consultancies have done a looser version of this for decades. What made the Palantir model distinct was the feedback loop: what forward deployed engineers learned in the field went back into the product, so each deployment made the next one cheaper.
Frontier models are the most general-purpose software product ever shipped. That's exactly the condition that created the role the first time.
A model can read a contract, triage a ticket or draft a reconciliation report. It can't tell you which of the client's three customer databases is the real one, that the approval chain changes above a certain amount, or that the operations team quietly ignores a field in the ERP because it's been wrong since 2019. That knowledge doesn't exist in any document. It lives in people and you get it by sitting with them.
This is the same gap we wrote about in why most enterprise AI pilots never reach production. The demo works on clean inputs. Production is the last mile: data access, permissions, evals that reflect what the business actually considers correct and integration with systems that predate everyone in the room. That last mile is the product and it's FDE work.
The second change is leverage. Bespoke work used to be expensive because building the client-specific layer took a team. With agentic coding tools, one engineer who understands the problem deeply can build the integration, the eval harness and the internal tooling in the time it used to take to write the spec for someone else. Customisation has become cheap enough that the bottleneck is understanding, not building - and understanding doesn't parallelise.
Stripped of the title, the work breaks into five parts. In our experience the time split looks roughly like this:
┌───────────────────────────────────────────────────────┐
│ client reality │
│ (people, data, legacy, politics) │
└──────────────────────────┬────────────────────────────┘
│
┌────────────▼────────────┐
│ forward deployed eng. │
│ │
│ diagnose ~20% │
│ wire data ~30% │
│ build evals ~20% │
│ ship + own ~20% │
│ feed back ~10% │
└────────────┬────────────┘
│
┌──────────────────────────▼────────────────────────────┐
│ product / platform / reusable patterns │
└───────────────────────────────────────────────────────┘
Diagnosis. Working out what the problem actually is before building anything. Often the answer isn't a model at all - we've written about the systems that didn't need AI. An FDE who can't say "this is a data problem" is just a fast implementer of the wrong thing.
Wiring the data. The least glamorous part and the most time-consuming. Getting read access to the right systems, understanding the schema the documentation doesn't describe and setting up agent identity and scoped permissions so security will sign off.
Building evals with domain experts. Sitting with the person who does the job today and turning their judgement into test cases. This is the part generalist engineers most often skip and the part that decides whether the system survives contact with real users.
Shipping and owning. Not handing over a prototype. Running it in production, watching the traces and being the person who gets the message when it's wrong.
Feeding it back. Writing down what was specific to this client and what was a pattern. Without this step you don't have a forward deployed engineer, you have a custom development shop with extra travel.
It's not usually the strongest pure coder on the team. The engineers we've seen do this well share a different set of traits.
They're comfortable spending a full day with an operations manager watching how work actually gets done, without opening a laptop. They write the eval before the prompt. They can explain a trade-off to a CFO and a race condition to a staff engineer in the same afternoon. They notice when the stated requirement and the real need have drifted apart and they say so early. And they're happy to ship something boring.
The common thread is judgement under ambiguity, which lines up with what we argued in why small senior teams do well in the AI era. Code output got cheap. Knowing what to build didn't.
We've seen three failure modes, some of them from the inside.
The FDE becomes free custom development. If the role is measured by deals closed or customer happiness, every request becomes a yes. Six months later each client has a fork that only one person understands.
No path back to the product. Field learnings stay in the FDE's head or a Slack thread. Every deployment starts from zero, so the role never gets cheaper and the people in it burn out.
Measuring the wrong thing. A shipped pilot isn't the outcome. The outcome is production usage three months later. FDEs measured on go-lives build demos; FDEs measured on retained usage build systems.
Most clients asking us about this don't need a new job title. They need a few things to be true about how their AI work is staffed:
If those are true, the title doesn't matter. If they aren't, hiring someone called an FDE won't fix it.
The forward deployed engineer is back because the main product in AI is general-purpose and the value is in the last mile. The role is old. What's new is that one engineer with good judgement and agentic tooling can now close that last mile alone, at a speed that makes bespoke work economical.
For us this is the most natural shape of the work we already do - a small senior team embedded in the client's problem until the system is running in production. The title is new to us. The job isn't.