facebook pixel
HOW THE FACTORY GETS INSTALLED

Forward deployed engineers, carrying a factory.

Senior Frontend engineers who work inside your team, not beside it.
Every one of them arrives with the delivery system already built.

What a forward deployed engineer actually is

A forward deployed engineer, or FDE, is a senior engineer who works inside your organization rather than beside it. Same repository, same sprint, same Slack, same standup, and the same definition of done as your own team. The model came out of enterprise deployment work and the AI labs have made it the default way serious AI capability gets installed, for one reason: the hard part was never the model or the code, it was the last mile into a real codebase with real constraints and real people.

Ours arrive carrying the Frontend Delivery Factory. They ship production features from the first weeks, and while they ship they install the parts of the system that outlast them: context the coding agents read before they write, skills maintained per repo, guards that decide whether output is mergeable, telemetry on every run.

This is a delivery model, not a fourth service. It is how a factory gets installed when an org wants to start with one engineer instead of a full deployment, which is why every embedded engineer is a soft factory install.

Hiring a Frontend engineer, staff augmentation and a forward deployed engineer, compared across what you buy, ramp, conventions, effect on the org and what remains at the end.
A NEW HIRESTAFF AUGMENTATIONFORWARD DEPLOYED ENGINEER
What you buyA permanent employeeHours against a ticket queueAn outcome, and the system that produces it
Time to first production codeAfter the search, the offer and the rampFast, inside the way you already workFast, and the way you work changes as they go
Who writes the conventionsThey learn yoursThey follow yoursThey commit yours to the repo, as context and guards
Effect on the rest of the orgOne more person in the merge laneOne more person in the merge lanePeople outside the Frontend team start merging
What is left when it endsNot applicableThe code they wroteContext, skills, guards, telemetry, a trained team
HOW A DEPLOYMENT RUNS

Install, operate, teach, hand over.

The same four phases as a full factory deployment, at the scale one engineer can carry. Monthly retainer per engineer, six-month minimum, because the value compounds only if the context does.

  1. 01INSTALL

    Ship first, document as you go

    The engineer takes a real ticket from your backlog in the first week and ships it. What that pass reveals, the undocumented conventions, the review comments that repeat, the places the design system is a suggestion, gets committed to the repo as context rather than written up as a report.

  2. 02OPERATE

    Run the line with your team inside it

    Features keep shipping, and each failure becomes permanent. A review comment that has now been written twice becomes a guard in CI. A task the agents keep getting wrong becomes a maintained skill. Your engineers watch this happen on their own PRs, which is the only version of training that survives contact with a sprint.

  3. 03TEACH

    Hand over the controls, not a manual

    Your team writes the next guard, edits the next skill and reads the next trace, with the engineer in the room rather than at the keyboard. The measure is not whether they understand the system, it is whether they change it without asking.

  4. 04HAND OVER

    The engagement is designed to end

    Everything lives in your repository: context files, skills, CI guards, evals, traces. No Enpitech runtime in the path and no hosted service to keep paying for. We stay when you want us there, not because the line stops without us.

THE BAR

Who we actually deploy.

The role asks for staff-level engineering and customer-facing judgement in one person, which is exactly why the search is hard when you run it yourself.

  • Mid-senior to senior only

    Three years minimum, typically five or more. We do not place juniors, and we do not staff an engagement with one senior fronting a bench of them.

  • Both halves, not either

    AI-native workflow and production-shipping discipline. An engineer fluent with a coding agent who has never carried a feature through review, staging and an incident does not clear the bar, and neither does the reverse.

  • Frontend as the deep specialty

    React and TypeScript in production, design systems, accessibility, performance, the edge cases that only show up in a real product. Fullstack-capable where the work needs it, Frontend-deep where it counts.

  • Your interview loop, not ours

    You interview whoever you want, on whatever loop you already run for your own hires. If someone does not clear your bar that is a signal about the match, not something to negotiate around.

Start with one engineer.
Keep the system.

The assessment looks at where your delivery hours actually go, and tells you whether one embedded engineer or a full deployment is the right size for it.

Get a Factory Assessment
Factory Assessment

Bring one spec from your backlog.

Tell us where delivery is stuck: the queue behind your team, the review load, the AI output nobody can safely merge.

We audit the repo and the workflow, then run one real roadmap item through the pipeline, so you judge the factory on shipped code and not on our slides.

What happens next
  1. 01

    You send the form.

    Your stack, your team size, where delivery jams.

  2. 02

    We reply within a day.

    A short call to see whether the factory fits.

  3. 03

    We scope the assessment.

    Repo, workflow, and the first feature to pilot.

0/2000

Your info stays with us. That's it.

FAQ

Questions, answered.

The ones that come up when a team is deciding between an open req and an embedded engineer: the tradeoff against hiring, how this differs from staff augmentation, what the first month looks like, and what stays in the repo at the end.

  • A.

    Because the req is competing for a candidate profile that barely existed two years ago, and every AI company on the market is bidding for the same people. The role asks for staff-level engineering, customer-facing judgement and startup-speed execution in one person, so the search runs long, the offer runs high, and the ramp starts only after all of that clears. Contracting changes what you are buying. You are not buying a person you then have to make effective, you are buying an engineer who has done the install before, arrives with the tooling already built, and starts writing production code in your repo in the first weeks. Hiring is still the right end state when the work is permanent, and nothing here blocks it. Several of our engagements exist precisely so a team can keep shipping while the req stays open.

  • A.

    Staff augmentation sells you hours against a ticket queue. The contractor takes the tickets your team writes, works the way your team already works, and when the contract ends the only thing left is the code they wrote. A forward deployed engineer owns an outcome instead of a queue, and arrives carrying a system. They install the delivery infrastructure while they ship: context committed to the repo, skills maintained per repo, guards that decide whether agent output is mergeable, telemetry on every run. That is why we call every embedded engineer a soft factory install. The test is what remains after they leave. With staff augmentation it is a pile of merged tickets. With this it is a line that keeps running, and a team that knows how to operate it.

  • A.

    Week one is production code, not discovery theatre. The engineer picks up a real ticket from your backlog, ships it, and uses that pass to see where the friction actually is: which conventions are undocumented, which review comments repeat, where the design system is a suggestion rather than a rule. What they learn becomes committed context, not a report. By the end of the first month you have merged features from them, an AGENTS.md and CLAUDE.md pair your other AI tools read, and usually the first guard in CI that stops a class of review comment from ever being written again. If you want an artifact, ask for the list of guards. It is a better read than a status deck.

  • A.

    Mid-senior to senior only. Three years minimum, typically five or more, and the bar is deliberately two-sided: production-shipping discipline and AI-native workflow. We do not place juniors, and we do not place engineers who are fluent with a coding agent but have never carried a feature through review, staging and an incident. You interview whoever you want, on whatever loop you already run for your own hires. If someone does not clear your bar, that is a signal about the match, not something to negotiate around.

  • A.

    Same engineer, on a monthly retainer with a six-month minimum, because the value compounds only if the person accumulates context in your codebase. Holidays and reserve duty are real and we plan around them rather than pretending otherwise. The structural answer is the same one we give about handover: because the engineer commits context, skills and guards to your repo as they work, the knowledge is not held in one head. That is what makes a cover or a transition survivable, and it is the same property that makes the eventual exit survivable.

  • A.

    It stops being an embedded engineer and becomes a factory deployment. One FDE can install the practices in one team and prove them there. When three teams want the same thing, the constraint moves from the engineer to the system, and the right shape is a phased install with a defined outcome and a fixed price per stage rather than more retainers. That upgrade is the normal path, not an upsell we invented after the fact: the engineer was already installing the same infrastructure, just at the scale one person can carry. The Frontend Delivery Factory page is where that engagement is described end to end.

  • A.

    No, and the engagement is designed to end. Everything the engineer builds lives in your repository under your license: the context files, the skills, the CI guards, the eval harness, the traces. There is no Enpitech runtime in the path, no hosted service you have to keep paying for, and no configuration that only we can read. We use tools your team can keep using, whichever coding agent you already run. The honest version of the pitch is that we are trying to make ourselves unnecessary on a schedule, and the way you check we mean it is to ask, at the end, whether your own engineers can change a guard without calling us.

Didn't find yours?Ask us directly.