What a forward deployed engineer actually does.

A forward deployed engineer is a senior software engineer who builds inside the customer's environment rather than behind a product roadmap. One person scopes the problem with the people who own it, writes production code in the customer's codebase, deploys it on the customer's infrastructure, and stays attached until the system runs and the customer's own engineers can keep it running. Pooya Golchian works this way from Dubai, embedding with B2B engineering teams to put agentic AI into production and handing over systems those teams own afterwards.

  1. Frontend
  2. Backend
  3. Linux
  4. DSA
  5. System design
  6. AI engineering
  7. DevOps
  8. Discovery
  9. Business acumen
  10. Communication

The job under the title

The title spread through job ads faster than any shared definition of it, and the descriptions still contradict each other. Some read like a sales engineer. Some read like a contractor with a plane ticket. The work underneath is older than the label, and it is specific.

Start with the word deployed. A forward deployed engineer does not wait for requirements to arrive as tickets. They go where the problem is, work inside the customer's systems and constraints, and stay attached until something runs in production. The pattern is usually traced to Palantir and became common across the AI labs, for the same reason in both cases. A platform is general, every customer's reality is specific, and the distance between those two closes in code rather than in a deck.

The role fuses two jobs that most companies keep in separate reporting lines. The first is full-stack delivery. An FDE builds the interface, the service behind it, the data path underneath, and the deployment that carries the whole thing, usually alone and usually against a date somebody picked for a commercial reason. The second is field work. Requirements arrive as complaints, a half-drawn diagram, and a spreadsheet one person maintains by hand. Turning that into something buildable belongs to the engineer, not to an analyst upstream who hands over a clean brief.

Agency is the trait every job ad gestures at and none of them name. Nobody grooms your backlog. You choose what gets built first, you choose what gets cut, and you own the silence when a demo lands flat in front of the customer's executive sponsor. That freedom is the appeal and the cost in equal measure.

Then comes the responsibility people underestimate, and it has grown heavier since agents entered the picture. The FDE proves the system holds. Not that it demos well, that it behaves on a bad input at three in the morning when nobody is watching. A customer who has just seen an agent do something impressive wants to know what stops it doing something expensive. Answering that means evals, guardrails, an audit trail and a tested rollback, built into the delivery rather than promised for a later phase.

Not a consultant, not a contractor, not a solutions architect

The three roles this gets confused with are each about half of it.

A consultant
produces judgement. The deliverable is a recommendation, a target operating model, a decision somebody else will implement. Good consulting changes what a company does. It rarely leaves running software behind, and the engagement tends to end at exactly the point where the hard part starts.
A contractor
takes a scope somebody else defined and builds to it. That is a staffing arrangement more than a role. The scope comes down from a product manager or an architect, the contractor executes it well, and the ambiguity was resolved before anyone signed. A forward deployed engineer gets brought in precisely because the ambiguity has not been resolved and nobody internally can resolve it.
A solutions architect
draws the system and hands the drawing on. The work is real, it usually sits alongside a sales cycle, and it is measured on whether the design gets adopted and the deal closes. The architect is rarely in the repository afterwards. An FDE is measured on whether the software runs, which makes being in the repository the job rather than an optional extra.

Put plainly, the forward deployed engineer holds the customer relationship and the commit history at the same time. Almost everything difficult about the role falls out of that one fact.

The roadmap into the role

This is the version I would hand someone asking how to get there. It runs top to bottom, engineering foundation first and field skills second, because that is the order the market filters on. The technical tracks get you through the interview loop. The field tracks decide whether the engagement succeeds once you are sitting inside a customer.

One thing to settle before the tracks. This is not an entry-level role. Almost everyone who steps into it is already a full-stack developer with production scars, and taking the FDE title changes where you sit far more than it changes what you can build.

Loading diagram…
The roadmap runs as one spine with two halves. The engineering half moves from frontend and backend, through Linux, into data structures and algorithms with system design, then AI engineering and DevOps. The field half opens at discovery and scoping, which carries requirements gathering alongside the running trade between scope, speed and quality, then business acumen covering enterprise workflow, return on investment, stakeholder management and the product feedback loop, and closes on communication and technical writing. Each track is written out in full below.

The roadmap tracks in full

Frontend and backend, both to production standard

Full stack is the premise here rather than a bonus line on the profile. You will build an interface for people who will use it in front of you, plus the service, the schema and the jobs behind it, with no second team to hand either half to. Depth beats breadth. One frontend framework you can debug under pressure, one backend language you write correctly when tired, and honest fluency in the database will carry you further than a long list of names you have touched once.

Linux and the machine underneath

Customer environments run on Linux and they are rarely the tidy ones. Move around a shell without thinking. Read logs. Follow a process to the port it is bound to. Understand permissions, systemd and the network path in front of the service. Work out why the container that ran on your laptop refuses to start on their host. This track stays invisible right up to the moment it is the only thing standing between a working demo and a dead afternoon.

DSA and system design, the first gate

Data structures and algorithms are the first gate in FDE interviews, and it is worth saying that without softening it. You never get to show the AI work or the customer judgement if that round goes badly, because the loop is deliberately ordered to filter there. Prepare for it on its own terms instead of treating it as an insult to your experience. System design follows immediately and sits far closer to the real work, since scoping a customer system under a latency budget and a data-residency rule is a design interview that simply never ends.

AI engineering

This is the track that made the role common. Agent design, tool use through MCP servers, retrieval that answers with citations rather than confident prose, evaluation harnesses that turn a subjective sense of improvement into a number, and enough model-serving knowledge to run open weights on hardware the customer owns. The bar is not research. The bar is production behaviour under evaluation, which is a different and much less glamorous skill. Most of what separates a working agent from a demo lives in the eval suite and the guardrails.

DevOps and the cloud

Fluency in at least one major cloud, and the ability to deploy infrastructure as code instead of by clicking. You are frequently the only person who can put the system somewhere real, and the customer's own platform team will read what you wrote and inherit it. Pipelines, secrets handling, observability that answers a question at incident time, and a rollback that has actually been run rather than described in a document.

Discovery and scoping

The first field track, and the one engineers underrate hardest. Requirements gathering has real technique behind it. Ask what happens today rather than what should happen. Watch the work instead of the description of the work. Find the spreadsheet. Find the person everyone quietly routes around. Then sequence what you found so something useful ships early and the riskiest unknown gets attacked first, while it is still cheap to be wrong. Every engagement is a running trade between scope, speed and quality, and the forward deployed engineer makes that trade out loud, with the customer, at the moment it appears. Making it silently at the keyboard is how a project ends with working software nobody asked for.

Business acumen

You are standing inside somebody's enterprise workflow, and the system you build either fits that workflow or gets politely abandoned two months after launch. Learn how the customer makes money and where the cost actually sits. Be able to state the return on what you are building in their terms, because a sponsor renews what they can defend upward to their own boss. Stakeholder management is a first-class task, not an overhead. The person who asked for the work and the person who has to live with it are usually not the same person, and they often disagree without ever having said so to each other. Then close the loop back into the product, carrying what you learned in the field to the team that builds the platform.

Communication and technical writing

Writing pays back more than any other non-technical skill in this role. You will write the scoping note that quietly becomes the contract, the architecture memo a platform team reviews without you in the room, the runbook the customer's on-call engineer opens at two in the morning, and the handover that decides whether your work outlives your departure. Write so a decision still makes sense to a stranger six months later, with the constraint that forced it recorded next to it. That single habit prevents more rework than any process you can install.

Keep learning, because the field moves

The AI half of this role looked different eighteen months ago and will look different again by the time anyone reads this twice. Model capability, tooling and the patterns that survive contact with production all move faster than any curriculum can track. The durable part is the shape of the work, which is why the engineering and field tracks above are worth building deliberately while the specific tool list stays disposable.

What the role asks that a senior engineering job does not

Every requirement above exists somewhere in ordinary senior engineering. What changes is the exposure.

You work without cover

No product manager translates for you, no account manager absorbs the awkward conversation, and no sprint boundary hides a slipped estimate. When the estimate slips you say so to the person paying, in their building, on the day you know.

Adoption judges you, not the merge

A feature that ships and goes unused is a failure in this role even when the code is good, which changes what you build and the order you build it in. That is genuinely uncomfortable for engineers who have measured themselves on craft alone.

You hold context that has no home

Half of what you learn inside a customer will never fit in a ticket. It lives in your head, your notes and the handover you write, so an engineer who cannot write loses most of that value on the last day of the engagement.

You switch environments constantly

Different codebase, different cloud account, different compliance regime, sometimes a different language in the room. Being productive in an unfamiliar repository within a day is a learned skill, and the role assumes you already have it.

You carry the trust personally

The customer is not buying software off a shelf, they are betting on the person in the room. That weighs more than it sounds, and it is why serious loops screen for judgement as hard as they screen for code.

How I work this way

I have worked forward deployed for the last several years, mostly in regulated environments where the data cannot leave the country and every automated decision has to stay defensible to a regulator afterwards.

Across two UAE fintech platforms, one in payments and one in healthcare financing, I sat inside the estate rather than beside it. I built the Buy-Now-Pay-Later platform from nothing, then led the migration off eighteen microservices into a monorepo, and put the fraud, KYC and risk stack into production across ten products. That platform now runs more than $10M a month at 99.99% uptime. None of it arrived as a specification. It arrived as a business problem, a bank partner, a regulator and a date.

Through Technova Solutions I embed with UAE enterprises on their own infrastructure. NVIDIA inference standing on customer premises, Arabic models fine-tuned because an English-first model would have failed the actual users, retrieval pipelines that answer in under three seconds and cite their source so a reviewer can check any claim against the document it came from. Every one of those deployments went to the customer's own team afterwards, which is the part I care about most. You can read the detail in the case studies.

The method is written down rather than improvised. I run agent work behind specs, evals and approval gates through SpecForge, the open-source lifecycle I publish, which builds on AI-DLC. I have taught it to twenty-five engineers inside a live estate, which is a very different exercise from teaching it in a classroom.

Engagements run two to three days a week for four to twelve weeks. If you want that written down as scope, agent harness and deployment covers the build work and the agentic pilot covers a fixed scope at a fixed price.

The role, answered

What the job is, how it differs from the roles it gets confused with, what the interview loop tests, and how to get into it.

  • A forward deployed engineer is a senior software engineer who is placed with a customer and builds inside that customer's environment rather than behind a product roadmap. The role merges work most companies split three ways. The engineer scopes the problem directly with the people who have it, writes production code in the customer's codebase, deploys it on the customer's infrastructure, and stays attached until the system runs and the customer's own team can keep it running. The pattern is usually traced to Palantir and spread through the AI labs for the same reason in both cases, since a general platform meets a specific reality at every customer and somebody has to close that distance in code.

  • A solutions architect designs the system and hands the design to somebody else to build, usually alongside a sales cycle, and is measured on whether that design gets adopted and the deal closes. A forward deployed engineer is measured on whether the software runs in production. The engineer writes the code, merges it into the customer's repository, deploys it, and owns what happens after the launch call. Both roles sit in front of the customer and both need architecture judgement. Only one of them ships the implementation and then supports it.

  • Neither, although the role borrows from both. A consultant produces judgement, and the deliverable is usually a recommendation or a decision somebody else implements. A contractor takes a scope that somebody else defined and builds to it, which is a staffing arrangement rather than a role. A forward deployed engineer defines the scope with the customer and then builds it, holding both ends at once. The distinguishing test is simple. If the engagement ends with a recommendation instead of a running system, it was consulting.

  • Become a full-stack engineer first. Forward deployed engineering is not a beginner role, and most people step into it after several years of shipping frontend and backend code end to end in production. The technical base is full-stack delivery, Linux, data structures and algorithms, system design, cloud fluency with infrastructure as code, and, in the current market, AI engineering covering agents, retrieval and evaluation. The second half is field skill, meaning discovery with a customer, technical scoping and sequencing, stakeholder management, and writing well enough that a decision survives being read months later. Most candidates arrive with the first half. The second half is where the loop cuts them.

  • Two stacks, not one. The engineering stack is frontend and backend to production standard, Linux fluency in environments you did not set up, data structures and algorithms, system design, at least one major cloud with infrastructure as code, and AI engineering covering agent design, tool use, retrieval with citations and evaluation harnesses. The field stack is requirements gathering, technical scoping and sequencing, explicit trade-offs between scope, speed and quality, understanding of the customer's enterprise workflow and where their money is made, stakeholder management, and technical writing. High agency runs underneath both, because nobody grooms the backlog and the engineer decides what gets built first.

  • Usually yes, and it is generally the first gate in the loop. Interviews for the role tend to open with a coding round on data structures and algorithms before anything else gets assessed, which means a candidate never reaches the AI engineering rounds or the customer-facing scenario if that first round goes badly. It is worth preparing for on its own terms rather than assuming production experience will carry it. The rest of a typical loop covers system design, a practical build exercise, and a scenario where an interviewer plays a customer whose requirements do not fit the product.

  • There is no single band, and any figure quoted without a market, a company and a level attached is noise. Compensation for the role generally tracks senior and staff software engineering pay at the same employer rather than sitting on a separate scale, because the technical bar is the same one and the customer-facing work is added on top of it. Two things tend to move it. The role often carries travel or on-site expectations, and it usually sits close to revenue, so equity and variable components appear more often than they do in a purely internal engineering job. Check levels data for the specific company and market instead of a global average.

Bringing a forward deployed engineer in

If your platform is general and your customers keep asking for something specific, that gap is the whole reason this role exists. It closes with an engineer inside the problem, not with another discovery workshop.

Tell me what you are trying to put into production and who has to own it afterwards. You will get a straight answer about whether this is the right shape of help within a day.

Get practical AI and engineering playbooks

Weekly field notes on agentic AI, automation, and high-performance Next.js builds. Each edition is concise, implementation-ready, and tested in production work.

Open full subscription page

Get the latest insights on AI and full-stack development.