StackLift
All playbooks

Playbook

The Forward Deployed Engineering Model: A Playbook

How to run the forward deployed engineering model with a partner or in-house: engineers work inside the customer's workflow and systems, ship to production, and feed what they learn back to the product.

Best reader

CTOs, heads of product and operations leaders deploying AI agents or integrations into real systems

Outcome

A working solution in production, a feedback loop to the product, and a clean handover.

Use this sequence

1

Map the customer's real workflow and name the outcome it must change.

2

Agree access, data and security rules before anyone touches a system.

3

Scope the first deployment with a plan, user stories and a stack choice.

4

Build in the customer's stack, on branches, behind review and CI.

5

Evaluate against real cases and fix what the evaluation shows.

6

Release with monitoring and a rollback path, then watch daily use.

7

Feed field findings back to the product team.

8

Hand over code, runbooks and ownership.

Start inside the workflow, not the spec

The model works because engineers see how the work really happens, including the workarounds no requirements document mentions.

Shadow the people who do the work

Name the data and systems the workflow touches

Define success as a change in daily work, not a feature list

Set access and security first

Embedded work needs access to real systems. Agree who grants it, how it is logged and what stays off limits before the first line of code.

Least-privilege accounts, reviewed and time-boxed

No production secrets in engineers' or agents' hands

A named owner on the customer side for every system

Close the loop and hand over

A deployment is not finished at launch. Findings go back to the product, and the customer's team must be able to run what was built.

Weekly findings shared with the product team

Runbooks, tests and monitoring handed over

Clear ownership after the engagement

Start in 60 seconds

Turn this checklist into a scoped plan.

Answer a few questions and get an AI-assisted, architect-reviewed scope, cost range, and timeline for your software project.

Frequently asked questions

What is the forward deployed engineering model?

It is a delivery model in which engineers work directly with a customer, inside the customer's systems and workflows, to build and deploy a solution, and bring what they learn back to the product team.

Can you run the model with a partner?

Yes. A partner can supply senior engineers who work with your team, as long as scope, access, review and handover are agreed up front.

When is it the wrong model?

When the need is generic and a product already fits, or when the customer cannot give access to systems and people. Embedded work depends on both.

The complete guide

The Forward Deployed Engineering Model: A Playbook: the complete guide

Updated November 18, 2026 ยท Published by , Founder, StackLift AI. Written with AI assistance; how we make content.

Short answer

The forward deployed engineering model puts engineers inside the customer's workflow and systems to build a solution and run it in production, then brings what they learn back to the product team. You run it in eight steps: map the workflow, agree access and security, scope the first deployment, build in the customer's stack, evaluate on real cases, release with monitoring, feed back findings, and hand over.

What is the forward deployed engineering model?

In the forward deployed engineering model, a software engineer works directly with a customer, inside the customer's environment, to build and deploy a solution for a real problem. The engineer is accountable for the solution working in daily use, not for a list of tickets.

Palantir popularized the approach, and it is now common among AI companies that deploy models and agents into large organizations. Companies organize it differently: some place these engineers in the product organization, some in engineering, and some in a separate delivery team. What stays constant is the loop between the field and the product.

You can run the model in-house, with your own engineers embedded in a business unit, or with a partner that supplies senior engineers to work alongside your team. This playbook applies to both.

When does the model fit, and when does it not?

The model fits problems that are specific to one organization and that depend on its data, systems and people. AI agents are a typical case: the model is available, and the hard part is connecting it to real systems, setting rules for what it may do, and proving it behaves on real cases.

Fit check
SituationFitWhy
An AI agent must act inside your ERP, CRM or ticketing systemStrongIntegration and permissions decide success
Pilots work in demos but stall before productionStrongThe gap is deployment, not the model
Requirements only become clear next to the usersStrongEngineers learn by working in the workflow
A packaged product already fits with configurationWeakConfigure the product first
The customer cannot grant access to systems or peopleWeakEmbedded work depends on both
The need is the same for every customerWeakBuild it into the product instead

How do you run the model, step by step?

The steps below follow one deployment from first conversation to handover. Each step has an output you can check, so the work stays visible to both sides.

The steps overlap in practice. Access talks start during discovery, and the first evaluation cases are collected on day one. Treat the order as a guide to what must be true before the next step, not as a strict waterfall. Small releases let you learn early and change course without a large rework.

  1. Discover in the workflow: shadow the people who do the work, map the systems and data it touches, and name the outcome that must change.
  2. Agree access and security: accounts, data rules, logging, and what stays off limits, before anyone touches a system.
  3. Scope the first deployment: a plan with user stories, acceptance criteria, a stack choice and a cost and timeline range.
  4. Build in the customer's stack: small changes on branches, behind code review and automated tests.
  5. Evaluate on real cases: run the solution against examples from daily work and fix what the evaluation shows.
  6. Release with monitoring: ship with observability and a rollback path, then watch how people use it.
  7. Feed findings back: share what the field taught you with the product team each week.
  8. Hand over: code, runbooks, monitoring and a named owner on the customer side.

What happens in discovery inside the customer's workflow?

Discovery in this model is observation, not a questionnaire. Engineers sit with the people who do the work, watch where it stalls, and collect the examples that will later become test cases. They read the systems the work touches and find out which data is reliable and which is not.

The output is a short written description of the workflow as it is, the outcome you want, and the constraints. It also names the owner of every system involved. For a checklist of what to cover, use the AI project discovery checklist.

  • Which task or decision the solution changes, and for whom.
  • Where the data lives, who owns it and how clean it is.
  • Which actions are safe to automate and which need a person to approve.
  • What happens today when the workflow fails.

How do you handle access and security?

Embedded work needs real access, so agree the rules early. Use least-privilege accounts, time-boxed and reviewed. Log what engineers and agents do. Keep production secrets out of engineers' and agents' hands, and give each system a named owner on the customer side who can answer questions and approve changes.

Work on branches and merge through review, never straight to the default branch. For a deeper review, see the security review checklist and the AI governance policy checklist.

How do you build and evaluate in the customer's stack?

Build small and ship often. Use the customer's languages, cloud and tools where you can, so the team can maintain the result. Put automated tests and CI/CD in place from the start, because code that runs in a customer's production must survive edge cases and be maintained long after the engagement.

Evaluation uses real examples from the workflow, collected in discovery. For AI agents, define what a correct result is, what the agent may do alone, and where a person approves. The AI agent evaluation checklist and the production readiness checklist cover the details.

Checklist by phase
PhaseCheckOutput
DiscoveryWorkflow mapped, owners namedWritten workflow and outcome
AccessAccounts, data rules, logging agreedAccess and security note
ScopeUser stories and acceptance criteria writtenReviewed scope with stack and range
BuildBranches, review, tests, CI/CD in placeWorking increments
EvaluateReal cases run, failures fixedEvaluation results
ReleaseMonitoring and rollback readyLive solution, watched
FeedbackFindings shared with productWeekly findings note
HandoverRunbooks, tests, owner namedDocumented, owned solution

Who is responsible for what?

Clear roles prevent most of the friction in embedded work. The table uses a simple split: R for responsible (does the work), A for accountable (decides and signs off), C for consulted and I for informed.

Who does what
ActivityForward deployed engineersCustomer business ownerCustomer IT / securityProduct team
Map the workflowRACI
Grant access and set rulesCIA/RI
Scope and acceptance criteriaRACC
Build and reviewR/AICC
Evaluate on real casesRACI
Release and rollbackRACI
Feed findings to productRIIA
Own the solution after handoverCARI

What are the common pitfalls?

  • Starting to build before access is agreed, then waiting weeks for accounts.
  • Skipping a written definition of done, so the pilot never ends.
  • Building custom glue for every customer and never promoting patterns into the product.
  • Letting an agent act on systems without limits or an approval step.
  • Treating launch as the end, with no monitoring, owner or runbook.
  • Putting one person in the middle with no review and no backup.

Most of these are fixed by the same habits: a written scope, review on every change, a way back from every release, and a weekly record of what was learned.

How does field work feed back into the product?

The feedback loop is what separates the model from plain custom delivery. Each week, the engineers write down what they met: a missing capability, a recurring integration problem, a workaround users invented. The product team reads it and sorts each item into a one-off, a pattern or a bug.

Patterns become product work, so the next deployment starts further along. One-offs stay in the customer's code. Without this sorting step, every deployment repeats the same effort, and the product never learns what makes deployment hard.

Sorting field findings
FindingTypeWhere it goes
Same connector requested by several customersPatternProduct roadmap
A rule that only this customer hasOne-offCustomer's code, documented
An agent mistake found in evaluationBug or gapFix, add an evaluation case
A confusing screen users avoidedProduct feedbackDesign review

How do you know the deployment worked?

Judge the work by use, not by delivery. Agree in the scope what a working deployment looks like: which workflow changes, who uses it, and what the people doing the work say. Then check it after release, not only at handover.

  • People in the workflow use the solution in their daily work.
  • Failures are visible in monitoring and are fixed through the normal process.
  • The customer's team can run, change and roll back the solution without the engineers.
  • Findings from the field have reached the product team.

How does StackLift run the model?

StackLift's forward deployed engineers are senior engineers who work with your team, in your systems and workflows, to take AI agents, LLM features and integrations from a scoped plan to production. It starts with the Free AI Project Snapshot and a 3-day AI Scope Sprint, then runs as an AI Software Pod: an engineering team with sprint planning, QA and DevOps, and a weekly delivery report.

Scope is architect-reviewed. Engineers and agents work on feature branches and never push to the default branch or touch production secrets. CI/CD, observability, security review and rollback are planned from sprint one, and you follow live state, approvals, invoices and releases in the client portal. Pricing is by deliverable complexity, not hours, agreed before engineering begins.

Read about the forward deployed engineers service, or price an agent build with the free estimate. If you are comparing roles, see forward deployed engineer vs software engineer.

Questions people ask

What does a forward deployed engineer do?

They work with one customer, inside its systems and workflows, to build and deploy a solution to a real problem, and report what they learn to the product team.

How is the model different from normal outsourcing?

The engineers work inside your workflow and systems, and are accountable for the result working in daily use. Many outsourcing arrangements hand over a spec and receive a deliverable.

Can I run the model with my own engineers?

Yes. Embed engineers in the business unit, give them access, and keep the feedback loop to the product team. The steps are the same.

How long does a first deployment take?

It depends on scope and access. Most first versions of a StackLift build take 6-16 weeks depending on scope, and a 3-day scoping plan comes first.

What access do forward deployed engineers need?

Least-privilege accounts to the systems and data the workflow touches, reviewed and time-boxed. Production secrets stay out of engineers' and agents' hands.

How do I price forward deployed engineering services?

Start with a scoped plan. StackLift prices by deliverable complexity, not hours; the free estimate gives cost, timeline and team for an agent build in about five minutes.