Product engineer, forward deployed engineer: how the developer job is evolving with AI
For the past year, two job titles keep showing up in listings and in conversations between developers: product engineer and forward deployed engineer (FDE). Neither is brand new, but AI has turned them from niche roles into a clear trend.
That’s no accident. Both describe what the developer job becomes once writing code is no longer the hard part. In this note: what each role covers, why the shift is happening now, and how to make the transition.
The developer job is changing
For a long time, a developer’s value was measured first by their ability to produce code: knowing the frameworks, moving fast, mastering a stack. The rest — deciding what to build, understanding the client’s business — often belonged to other people (PMs, consultants, pre-sales).
Coding agents are reshuffling that split. I wrote about it in I still write code, but that’s no longer where the value is: the agent types fast and well, and the bottleneck has moved to what it does poorly on its own. Knowing what to build. And making what gets built actually work in the real world.
Product engineer and FDE are the names the market has given those two skills.
What is a product engineer?
A product engineer is a developer who decides what to build, not just how. PostHog, which did a lot to popularise the term, puts it this way: they pick the change worth making, ship it, measure whether it worked, and decide what comes next. They don’t receive a spec and hand back an implementation.
In practice, a product engineer:
- talks to users directly, with no one in between;
- reads the data to know whether a feature helped, not just whether it shipped;
- makes trade-offs: what to do, what to push back, what never to build;
- ships end to end, from frontend to database — increasingly with agents doing much of the typing.
You’ll mostly find them in product startups and small teams, where there isn’t a PM for every developer.
That’s how I work on my own apps — VoiceJournal, Ti Boug, Noan. Nobody writes me tickets. I decide that a screen is one too many or that onboarding loses people at step two, and only then do I write code. On those projects, a good part of my value is the list of things I don’t build.
What is a forward deployed engineer?
A forward deployed engineer is a developer embedded right next to the customer, whose job is to make a technology work in their context: their data, their tools, their processes, their people.
The role comes from Palantir, which still claims to have pioneered it. Instead of selling software and leaving customers to figure it out, the company sent engineers on site to bend the platform to real problems. People mocked it at the time — “a consulting firm wearing a software company’s clothes.” Today OpenAI, Anthropic and plenty of others hire FDEs on the same model.
In practice, an FDE:
- understands the customer’s business as it really runs, not as it’s described in meetings;
- finds the use case where AI delivers a measurable gain;
- wires the model in to data sources, internal APIs, access rights;
- prototypes fast, ships to production, and sticks around long enough for it to hold.
That’s what I do as a freelancer. When a team says “we want AI in our workflow”, the job is rarely writing a brilliant prompt. It’s figuring out where information flows badly, choosing the right split into agents, tracing every call, stopping the model from making things up — and then shipping something a non-technical team will use on Monday morning.
The two roles side by side
| Product engineer | Forward deployed engineer | |
|---|---|---|
| Core question | What should we build? | How does it work here, for this client? |
| For whom | A product’s users | One specific organisation |
| Where you find them | Product startups, small teams | AI labs, B2B vendors, freelancers |
| Rare skill | Product taste and trade-offs | Understanding a business that isn’t yours |
| Trap | Building something nobody wants | Shipping a demo that doesn’t survive reality |
What they share: both are judged on an outcome, not on lines of code.
Why this is happening now
Three reasons, each reinforcing the others.
1. Producing code keeps getting cheaper. When an agent implements a clear ticket in minutes, a profile whose entire value sits between “ticket received” and “PR opened” gets hard to justify. Value moves to what comes before (deciding) and after (getting it adopted).
2. Smaller teams can do more. A developer working with agents covers ground that used to take several people. Middle layers compress, and developers are expected to carry part of the product or the field work too.
3. AI has a last-mile problem. Models are powerful, but a model creates zero value until someone wires it into a company’s data and processes. That’s where most AI projects fail — and it’s exactly the FDE’s territory.
How to make the transition
The good news: neither path asks you to throw away what you know. Code stays your core tool. What changes is what you build around it.
The shared foundation
- Learn to work with agents, properly: clear specs, task breakdown, demanding review. Spec-driven development is a good place to start.
- Think in outcomes. Before each task, ask: how will I know this worked? Not “it’s merged”, but “it changed something for someone”.
- Write. Explaining a decision clearly in writing is the skill that pays off most in both roles.
Moving towards product engineering
- Ship a small product of your own, end to end. An app, a tool, an extension. Nothing trains product judgment like having nobody to sign off for you.
- Add analytics from day one and actually look at them. An unused feature is a lesson, not a failure.
- Talk to users every week, even just three. In your current job, ask to sit in on user interviews.
- Practise cutting. For every idea, ask what happens if you don’t build it.
Moving towards forward deployed work
- Build an agent on real data, not a tutorial: badly scanned PDFs, a hacked-together spreadsheet, a flaky API. That’s where the learning is.
- Learn to measure reliability: test sets, traces, error rates. Clients don’t believe “it works well”; they believe numbers.
- Get curious about a business that isn’t yours. Accounting, logistics, healthcare, legal: an FDE is worth as much as their ability to quickly grasp how a sector works.
- Work on your client posture: listening, rephrasing, saying no to a request that won’t help. It’s a technical skill in its own right.
What I take from it
The developer job isn’t disappearing; it’s moving up a level. From “I write the code I was asked for” to “I’m accountable for it being useful”. The product engineer carries that accountability on the product side, the FDE on the customer side.
Either way, code stays your tool. It just isn’t your whole job description anymore.
And if you’re looking for someone to play the FDE role on your AI project, that’s exactly what I offer.