You are not buying engineers. You are buying an outcome, delivered inside your customer’s world.
The company and people in the scene below are fictional — a composite of the situations founders describe when a big deal depends on making the product work on the customer’s terms, not a real company or a real engagement.
Maya runs Northbeam, a fourteen-person startup that sells route-planning software to logistics companies. Her biggest prospect, a regional carrier with 400 trucks, will sign a $180,000-a-year contract if the product works on their data, inside their network, with their dispatchers trained — in six weeks. The carrier’s data lives in three systems that disagree with each other, their security team will not allow anything to leave their network, and their dispatchers plan routes on whiteboards.
Maya’s three engineers are busy shipping the core product. She can hire a Forward Deployed Engineer — but the last role she posted took four months to fill. She can hire a consultancy — but the last one delivered a slide deck nobody ever opened. Or she can buy forward deployed engineering as a service: a team that shows up, embeds with the carrier, and makes the product work there. She has heard the phrase. She has no idea what it actually buys, how the team is staffed, or how she would know if it worked.
If you are a founder or a hiring manager with a deployment that has to work — a deal that depends on it, a customer whose data will not cooperate, a product that works in your demo and nowhere else — you have already discovered that the job is not “write more code.” The job is to make the product work inside someone else’s world, on their data, under their constraints, with their people able to run it when you leave. That is what a Forward Deployed Engineer does: clarify the real problem, build the smallest thing that solves it, and stay until it works in production.
There are three ways to get that work done: hire in-house, hire consultants, or buy an FDE team as a service. This post covers the third option — what it is, how an engagement runs, how the team is staffed, what the contract should say, where it breaks, and how to judge a provider. If you are leaning toward hiring instead, start with how to hire a Forward Deployed Engineer. If you are still deciding which role fits your problem, read FDE vs Software Engineer vs Solutions Engineer first.
The principle: you are not buying engineers, you are buying an outcome
An engagement is not a number of engineers for a number of weeks. It is a result, delivered inside your customer’s environment: the product deployed, the data flowing, the customer’s team able to run it without you. If a proposal measures success in hours delivered instead of an outcome working, it is not forward deployed engineering. It is staff augmentation under a new name — whatever the brochure calls it.
2. Clarify the ask: what “FDE as a service” actually is
The phrase is a relatively new commercial packaging of embedded engineering work — the underlying practice, engineers working inside a customer’s environment to make a product work there, has existed in different forms for years — and it means different things to different sellers. Forward deployed engineering as a service is a team you engage for a fixed period to make your product work inside a specific customer’s environment — on their data, under their constraints, with their people. The team embeds — working in the customer’s systems, talking to the customer’s operators, shipping inside the customer’s network — and the engagement ends when the deployment works and the customer’s team can operate it.
That definition has four parts. A team, not a person: one engineer can build a prototype, but a deployment needs someone talking to the customer while someone else fixes the pipeline while someone else writes the runbook. Embedded, not remote-advisory: the team works where the problem lives. Fixed period, not open-ended: the engagement has an end date and an exit. And measured by a working deployment, not by effort: the test is whether the customer’s dispatchers plan routes with your product on a Tuesday morning without calling anyone.
It helps to say what it is not — and to judge by the engagement model, not the label, because in practice these models overlap. Staff augmentation typically supplies individual contributors who work under the client’s direction. Those engineers can work closely with customers and take real responsibility for delivery; the difference is the model: augmentation rents you a person, while an FDE engagement brings a team that owns an outcome. Outsourcing moves work you do not want to do to someone cheaper, while an FDE engagement does work you cannot do from the outside — it lives inside the customer’s world, which is exactly where your product has to survive. Traditional consulting often emphasizes assessment, recommendations, or project delivery — and many consultancies do ship production software. The distinction is the model: FDE-as-a-service is positioned around a defined customer deployment, with a team responsible for discovery, engineering delivery, operational readiness, and knowledge transfer. Two providers can carry the same label and sell you different things, so examine the actual contract and responsibilities rather than relying on the name.
A useful test: ask the provider what happens if the deployment is not working in week six. A staff-augmentation firm says the engineer’s hours are yours to direct. A consultancy points to whatever its contract promised — recommendations delivered, or a project delivered. An FDE team says the provider should not declare the agreed deployment complete until the contractual acceptance criteria are met. If dependencies or customer decisions prevent completion, the parties should follow the agreed escalation and change-control process — and that answer belongs in the contract.
3. What you actually buy: the outcome, not the hours
When you buy FDE as a service, you are buying three things, in this order: a working deployment, a customer team that can operate it, and the knowledge of what had to change to get there. The engineers are the means. The deployment is the product.
Make it concrete with Maya’s carrier: what she needs at the end of six weeks is not “two engineers for six weeks.” It is: the carrier’s dispatchers planning routes in Northbeam with their real data; the three disagreeing systems reconciled into one feed the product can trust; the deployment running inside the carrier’s network under their security rules; and one dispatcher — the carrier’s “route lead” — who can restart the pipeline, spot bad data, and explain a wrong route to a driver without calling Northbeam. If all four are true, the engagement worked — if only three are, it did not, however excellent the engineers were.
The shapes you will see are fixed-scope (a defined deployment, a defined customer, a defined exit — the shape that fits most first engagements), retainer or pod subscription (a team available for a number of deployments over a quarter or a year — attach an outcome to each deployment, or it drifts into staff augmentation), and outcome-based pricing (part of the fee tied to the deployment working — which only works when “working” is defined in writing before the engagement starts).
As a rule of thumb — not a fact about the market — if the statement of work lists hours, rates, and a named individual, you are buying staff augmentation. If it lists a deployment, an exit condition, and a named outcome, you are buying forward deployed engineering. Read the statement of work, not the brochure.
Make the outcome measurable
“Dispatchers planning routes in the product, on real data, without calling the provider, for two weeks” is a good definition of done — but it does not establish whether the product is actually delivering value. Dispatchers could use the system while still correcting most routes by hand. The statement of work should name measurable acceptance criteria, agreed before the engagement starts. The table below is an example for Maya’s carrier, not universal FDE benchmarks: customer and provider should agree realistic baselines and targets for each measure first.
| Measure | Example acceptance criterion |
|---|---|
| Data integration | All agreed source systems produce valid records |
| Data quality | Agreed percentage of records pass validation |
| Route planning adoption | Agreed proportion of eligible routes planned in the product |
| Reliability | Agreed availability during the operating window |
| Recovery | Customer team successfully completes a restart exercise |
| Operational independence | Named customer operators complete the two-week solo run |
| Route quality | Results meet agreed business constraints and quality thresholds |
Note what the table does not contain: a single number for every deployment. A carrier with three disagreeing systems will set a different target from a customer with one clean database — and a target nobody believes is a target nobody chases.
The commercial tradeoff, in numbers
“More than she hoped, less than losing the deal” is a feeling, not a calculation. Here is the calculation — with every figure illustrative, invented for this fictional example, not a market fact. The carrier contract is worth $180,000 a year. Suppose the provider quotes $60,000 for six weeks. The comparison is not $60,000 against zero, but against the alternatives: lose the deal and the $180,000, plus the reference customer; or pull three of Northbeam’s own engineers off the core product for six weeks — an illustrative opportunity cost of roughly $70,000 in delayed roadmap work — while the carrier waits for a hire that takes four months. On those illustrative numbers, the fee is a third of the first year’s contract value and less than the cost of doing it late, in-house. The honest version of the calculation also includes the ongoing cost: the support after exit, and the FDE Maya will still need to hire. A fee that looks expensive against nothing can be cheap against a lost deal — and a fee that looks cheap can still be a bad deal if the deployment never works. Run the numbers on your own deal, with your own costs; “expensive” is a comparison, not a feeling.
4. Six-week engagement timeline
Maya’s carrier needs a working deployment in six weeks. Here is what those six weeks look like — and why the schedule is tighter than it appears. The customer’s team must run the deployment alone for two weeks before the engagement is declared complete, so the deployment has to be ready for independent operation by about the end of week four. Weeks five and six are not slack. They are the proof.
- Week 1 — Discover and unblock access. Customer interviews, data assessment, security approvals, scope, and success criteria. The access requests go in this week, not later.
- Week 2 — First working integration. Connect the three systems, demonstrate a basic feed, and validate it with dispatchers. Ugly and real beats polished and late.
- Week 3 — Build and validate. Reconcile the data, improve route planning, and test real operational scenarios with the people who will use them.
- Week 4 — Harden and train. Monitoring, recovery, security checks, runbook, and dispatcher training. By the end of this week the deployment must be ready for the customer to run alone.
- Week 5 — Customer-led operation. The customer runs the deployment independently. The provider observes and supports without taking over: observing means watching the deployment and the customer’s team work, and answering questions; advising means recommending a fix when the customer asks, with the customer making the change; making changes means the provider is hands-on in production — which ends the solo run for that part of the system, and the clock restarts once the fix is in. The provider stays reachable for genuine emergencies; any intervention is documented and reviewed for what it revealed about readiness.
- Week 6 — Exit and acceptance. Review the acceptance criteria, resolve agreed defects, hand over documentation, and close the engagement.
Illustrative schedule, not a guaranteed delivery plan. Customer access and approvals must be available on time.
One rule belongs in the contract before the work starts: customer-caused delays, new requirements, and unavailable dependencies trigger an agreed schedule or scope review — not an automatic assumption that the provider absorbs unlimited work. In practice: if the carrier’s network access takes three weeks instead of one, the six-week commitment may no longer be achievable, and the honest response is a revised plan, not a heroic rush in the final week.
Not every engagement is six weeks: a small, well-prepared deployment can take four weeks; a complex one with slow approvals, four months. Duration depends on scope, access, and customer readiness. The phases below are the same either way, and each exists because skipping it is how engagements fail.
Discover: find the real problem, not the stated one
The engagement starts with the customer’s ask, and the ask is almost never the problem. The carrier says “your product is too slow.” The real problem might be that their data arrives in nightly batches, so the planner recomputes from scratch every morning. The carrier says “we need a custom report.” The real problem might be that dispatchers do not trust the routes, so they re-plan by hand and blame the report. The first week is mostly conversations with the sponsor, the operators, and the data itself. The deliverable is a one-page statement, agreed with the customer: what is broken, for whom, how we will know it is fixed, and what is explicitly out of scope.
Embed: work where the problem lives
Once the problem is clear, the team embeds: access to the customer’s systems, a seat — physical or virtual — with the operators, and a direct line to the sponsor. It also means learning the customer’s constraints firsthand: the firewall rules, the approval process, the “database” that is a spreadsheet one person updates by hand. This phase looks like nothing is being built, which is why buyers underestimate it. But a team that builds from a spec document builds the wrong thing, politely.
Build: the smallest thing that solves the problem
Then, and only then, the team builds — the smallest thing that solves the agreed problem. In Maya’s case, that might be a small adapter that reconciles the three disagreeing systems into one feed, a fix so the planner handles the carrier’s overnight batches, and a one-page printout for drivers. Deliberately unglamorous work. The team ships in small pieces — a good rule of thumb is that the customer should see something running in their environment by the end of the second week, even if it is ugly. Early, ugly, and real beats late, polished, and wrong.
Harden: make it survive Monday morning
A demo that works on Thursday is not a deployment. Hardening is the work that makes the fix survive real operations: the pipeline has to handle the carrier’s bad rows without dying, the deployment has to restart itself, access has to follow the customer’s security rules, and somebody other than the FDE team has to be able to tell when it is broken. This is also where the team writes the runbook: what the system does, what can go wrong, what to do about it. Do not cut this phase: a deployment that works once and breaks on the first bad data file teaches the customer your product cannot be trusted.
Hand over and exit: leave behind operators, not orphans
The last phase is the handover, and it is what separates an FDE engagement from every other kind of outside help. The team trains the customer’s people — the route lead, the dispatcher, whoever will own the system — until they can run it, spot problems, and fix the common ones. Then the team leaves. On purpose. An engagement that never ends is not a success; it is a dependency, and it means the handover failed. A good rule of thumb: the customer’s team runs the deployment alone for at least two weeks — the solo run defined in the timeline above — before it is declared done.
5. Team structure and responsibilities: the pod, not the hero
The unit of FDE as a service is the pod: a small team, usually two to four people, organized around one deployment. A typical pod has an FDE lead — the person who owns the customer relationship and the outcome, runs discovery, keeps the sponsor informed, and says “this is done” or “this is not done yet.” It has one or two engineers, who build the adapters, fix the pipelines, and harden the deployment; they need breadth more than depth: one week might touch an API, a database, a firewall rule, and a spreadsheet. And a specialist, when the deployment needs one — for a misbehaving model or disagreeing systems — who joins for the phase where they are needed and leaves when they are not.
Two things about the pod matter for buyers. First, the pod’s shape changes by phase: discovery is lead-heavy, build is engineer-heavy, handover is lead-heavy again. A provider that staffs the same three people at the same intensity for the whole engagement is either overstaffing the quiet phases or understaffing the loud ones. Second, the pod is not a hero and a helper. One brilliant engineer plus someone to “support” them is not a team; it is a single point of failure with a witness. If the lead goes on holiday in week four and the engagement stalls, you did not buy a pod. You bought a person — so ask, before you sign, who is on the pod and what happens if one of them is unavailable.
6. Production security and deployment constraints
The carrier’s security rule — nothing leaves their network — is not a detail. For an FDE engagement it is one of the most important parts of the story, because the team works inside the customer’s environment, on the customer’s data, with the customer’s systems. The statement of work should answer these questions before the engagement starts.
Deployment location. Where does the integration run: customer-hosted infrastructure, an approved private environment, or another explicitly permitted model? If the carrier does not permit production data to leave its network, the provider cannot simply export the three source databases to its own cloud environment. The integration must run in an approved location, with data access, credentials, logging, and support arrangements explicitly agreed with the carrier.
Identity and access. Named accounts, never shared ones; least privilege — only the systems and data the work requires; MFA where the customer supports it; temporary credentials with an expiry date; access that expires when the engagement ends.
Data handling. What data the team may access, copy, log, and retain — and what it may not. Production data stays where the customer says it stays; test data is agreed separately; logs are checked for what they capture before they are written.
Secrets. Credentials live in an approved secrets manager, never in source code, configuration files, chat messages, or a shared document. Anyone who has seen a password pasted into a ticket knows why this rule exists.
Auditability. Records of administrative changes, deployments, and access — who did what, when — so the customer can answer its own auditors, and so a bad change can be traced rather than guessed at.
Incident response. Who investigates if customer data or systems are exposed, who notifies whom, and how fast. Agree this before anything goes wrong, not during the incident.
Offboarding. When the engagement ends: revoke access, rotate credentials where needed, and confirm data disposition — what was deleted, what was returned, and what, if anything, the provider retains and why.
None of this is the provider’s choice to make alone. The customer’s security team is a stakeholder, not an approver to work around — which is why access starts in week one, and why failure mode 4 in §9 is the most common way engagements fail.
7. Commercial models and contract requirements
“The provider stays responsible until the deployment works” is a good buying principle — and it needs contractual boundaries. A provider that accepts unlimited responsibility for things it does not control is either not reading its own contract or pricing in a disaster. The statement of work should define:
| Contract element | What it should specify |
|---|---|
| Deliverables | Exactly what will be built and deployed |
| Acceptance criteria | Measurable conditions for completion |
| Customer responsibilities | Data, access, sponsor, approvals, and personnel |
| Provider responsibilities | Staffing, delivery, security, testing, and documentation |
| Dependencies | Third-party systems, infrastructure, and product-team support |
| Change control | How new scope and delays are handled |
| IP ownership | Customer-specific work, background IP, and third-party licenses |
| Support after exit | Warranty, defect correction, escalation, and ongoing support |
Where the provider’s responsibility ends
The contract should say who bears the delay or the cost when something outside the provider’s control goes wrong — and what process follows. Consider six cases: the customer does not provide database access; the carrier’s source data is incomplete; the customer changes the routing requirements in week three; the product itself has a defect the provider cannot fix alone; a third-party API becomes unavailable; the customer refuses to approve the production deployment. In each case the answer should be a named owner and an agreed process — a change-control review, a revised schedule, or an escalation to the sponsor — not a silent assumption that the provider absorbs it. And as §2 says, completion is judged against the acceptance criteria: if dependencies or customer decisions prevent completion, the parties follow the agreed escalation and change-control process.
Who owns what
The simple version — “everything the provider builds belongs to the buyer” — is too simple. Contracts should distinguish three things. Customer-specific deliverables — the adapters written for this deployment, the integration code, the runbook, the deployment configuration — should typically be the buyer’s. The provider’s background IP — pre-existing tools, libraries, and reusable components it brought into the engagement — remains the provider’s, licensed for use in the deployment. Third-party software stays under its own licenses. Say so in writing, before the engagement.
8. How to choose between in-house, service, and consulting
Hiring in-house, buying as a service, and hiring consultants are three different answers to the same problem, and the right one depends on your situation. Here is the honest version:
| Hire an FDE in-house | Buy FDE as a service | Traditional consulting | |
|---|---|---|---|
| Speed to start | Slow — months to hire and ramp | Fast — weeks to embed | Fast — weeks to start |
| Cost shape | Salary, always on | Per engagement, ends | Per project, ends |
| Knowledge stays | Yes — it is your employee | Only if the handover works | Only in the report |
| Who owns production | You do | Shared, then handed to you | You do, after they leave |
| Best when | You will need the capability every quarter | One deployment, or a pipeline of deals | You need advice, not a deployment |
A note on the production-ownership row, because “shared, then handed to you” hides the important part. During the engagement, the provider operates the deployment day to day — monitoring it, fixing it, restarting it — under the customer’s authority; the customer’s sponsor remains accountable for production decisions. After acceptance — criteria met and the two-week solo run complete — operational ownership transfers to the customer’s team, and the provider’s role becomes the warranty and support defined in the statement of work.
The decision turns on one question: will you need this capability again and again, or do you need this deployment to work? If the answer is “again and again,” hire in-house, using the hiring guide. If the answer is “this deployment, and maybe the next one” — buy as a service, and start hiring in parallel. If the answer is “we need someone to tell us what to do” — hire consultants, and be honest that you are buying advice, not a working deployment.
One option to weigh seriously: for some buyers, buying as a service is the right answer more often than they first assume — the right choice depends on whether the work recurs. Except when the deployment is the whole business. If your product only works when someone is embedded with every customer, forever, the deployment work is not a service you buy. It is your core capability, and you need to hire for it. Buying it forever is how you end up with a product that only works when someone else is in the room.
9. Five engagement failure modes
Most engagements do not fail because the engineers were not good enough. They fail in the same five ways, and each one is preventable. Every example below is fictional, drawn from the Northbeam scenario above.
Failure 1: No sponsor on the customer’s side
The engagement starts because the customer’s CEO wants the deal — but the CEO never introduces the team to anyone, and nobody inside the customer will approve a production change. The fix: agree a named sponsor before the engagement starts — someone inside the customer with the authority to approve access and changes, who attends the first meeting and the weekly check-in. If the customer cannot name that person, the engagement is not ready.
Failure 2: The scope is a wish list
The statement of work says “integrate the product, clean the data, train the team, and improve reporting.” That is four engagements wearing one contract: the team does a little of each and finishes none. The fix is the one-page statement: one deployment, one definition of done, everything else explicitly out of scope.
Failure 3: The team never leaves
The deployment works, the customer is happy, and the team stays — because the customer’s team never learned to run it and nobody scheduled the handover. Months later the customer still cannot restart its own pipeline without calling the provider. The fix: schedule the exit on day one — handover date, two-week solo run, and condition for done in the contract. An engagement with no exit date is a subscription to a problem you were trying to solve.
Failure 4: Access and security sorted too late
The carrier’s security team needs three weeks to approve network access. The engagement is four weeks long. The team waits three weeks, builds in a rush, and ships something nobody has tested in the real environment. This is the most boring failure on the list and the most common. The fix: start the access process before the engagement starts, in parallel with the negotiation — get the customer’s security team the access list in the first meeting, not the third.
Failure 5: Success was never defined, so nobody can tell if it worked
The engagement ends. The provider says it worked: the deployment is live. Maya says it did not: the dispatchers still plan routes on whiteboards. Both are telling the truth, because “working” was never defined in a checkable way. The fix: define success in the one-page statement — see the measurable criteria in §3 — with numbers the customer agrees to.
10. Deliverables, handover, and exit
An engagement should end with a list you can check off, not a feeling that things went well. Before the provider leaves, the buyer should receive:
Expected FDE-as-a-service deliverables
- ☐ Discovery findings and agreed scope
- ☐ Architecture and deployment diagram
- ☐ Data mapping and integration documentation
- ☐ Tested implementation and deployment instructions
- ☐ Security and access documentation
- ☐ Monitoring and alerting configuration
- ☐ Operational runbook and recovery procedures
- ☐ Customer training and handover sign-off
- ☐ Known limitations and unresolved issues
- ☐ Post-engagement support and escalation agreement
The last two items are the ones providers most often skip, and the ones buyers most often regret not having: an honest list of what is still broken or unfinished, and a written agreement about who to call when something breaks after exit.
What a good engagement leaves behind
The test of an engagement is not what is true on the last day, but what is true a month after the team leaves. A good engagement leaves four things behind: a working deployment, in the customer’s environment — the real system, running on the customer’s data, under the customer’s rules, not a demo or a staging copy. A customer team that can run it — named people who can restart it, spot bad data, and fix the common failures; the two-week solo run is the proof. A runbook and a record — what the system does, what can go wrong, what to do about it, and what was changed and why. And knowledge inside your company — a debrief on what was broken, what the customer needed, and what the next deployment will hit. If the engagement ends and your engineers learned nothing, you paid for a deployment and threw away the lesson.
The exit
The exit is a date, not a mood. Handover date, two-week solo run, acceptance sign-off against the criteria in §3, and the support arrangement from the statement of work. Once the criteria are met and the solo run is complete, operational ownership sits with the customer’s team — and the provider’s job becomes the warranty and support the contract defines. If the solo run exposed gaps, the exit moves; a moved exit is a delay, not a failure, and it is far cheaper than a deployment nobody can run.
11. How to evaluate a provider
You cannot judge a provider by its website. You judge it by how it answers four questions in the first meeting — listen for specifics, not adjectives.
“Show me a deployment like ours, and what happened after you left.”
A good provider describes a real engagement: the customer, the problem, what the team built, and — the part that matters — what the customer’s team could do alone a month later. If the story ends with “the customer was delighted,” ask what the customer could do without them — if there is no answer, it is a sales story.
“Who is on the pod, and what happens if one of them is unavailable?”
You are buying a team, so inspect the team. Names, roles, and the plan for absence. A provider that names the lead and the engineers and explains the cover plan has a real pod. A provider that says “we’ll staff appropriately” is selling you a capacity, not a team.
“How do you define done, and what happens if we are not there on time?”
The answer should be the one-page statement: the deployment, the numbers, the exit. A provider that has thought about overruns will tell you how they handle them: what they absorb, what they escalate, and what they will not pretend is finished.
“What will our engineers learn?”
This is the question that separates a vendor from a partner. A good provider plans the debrief: what was broken, what the customer needed, what your product should change. If the provider has no plan for your team to learn, it is treating your product as a black box — and a black box is exactly what the next deployment will struggle with.
Red flags, in short: a proposal measured in hours, not outcomes. A pod that is really one person. No named customer sponsor. No exit date. A handover that is a document instead of a trained team. Any one of these is a reason to ask hard questions; two together is a reason to walk away.
12. Northbeam: Maya makes the decision
Let’s walk Maya’s decision through the framework — same fictional Northbeam scenario, an illustrative worked example, not a real engagement. First: will Northbeam need this work every quarter? Her pipeline has three more carriers like this one, so yes — the capability is recurring, which points to hiring in-house, eventually. But the first deal needs someone in six weeks, and hiring takes months. So the honest answer is both: buy the first engagement as a service, and start hiring an FDE in parallel, so the knowledge transfers to a person who stays. Second, the provider test: Maya gets names for the pod — a lead, two engineers, a data engineer for the first two weeks — and a one-page statement of done. The contract names a handover date, a two-week solo run, and a debrief for Northbeam’s engineers. The fee — $60,000 against a $180,000-a-year contract, on the illustrative figures worked through in §3 — costs more than she hoped and less than losing the deal. She signs — and posts the FDE role the same day, because the engagement taught her exactly what to hire for.
13. FAQ and buyer checklist
Is this just staff augmentation with a nicer name?
Only if you let it be. The difference is in the contract: staff augmentation sells you a person’s hours; an FDE engagement sells you a deployment that works and a team that can run it. If the statement of work lists hours and a named individual, it is staff augmentation, whatever the brochure says.
Who owns the code and the IP?
Answer it in the contract — before the engagement, not after. Customer-specific deliverables — the adapters, the integration code, the runbook — should typically be yours. The provider’s pre-existing tools and reusable components remain theirs, licensed for use in the deployment, and third-party software stays under its own licenses. The full distinction is in §7.
Do we still need to hire an FDE if we buy this?
Some companies have a one-off deployment and never hire; others find the first deployment is the first of many and hire within a year. If you will need the capability again, yes, eventually. Buying the engagement buys you time and a worked example of what the role actually is. Use both: the time to hire properly, following the hiring guide, and the worked example to write a better job description.
Field check — before you sign
- Write the one-page statement with the customer: what is broken, for whom, how you will know it is fixed, and what is out of scope — and get the customer’s sponsor to agree to it.
- Check the contract measures an outcome, not hours: a deployment, an exit condition, and a named result.
- Confirm the acceptance criteria, the deliverables list, and the security documentation are all in the contract.
- Confirm the pod: names, roles, and the plan if someone is unavailable. One person is not a team.
- Start the access and security approvals now, in parallel with the negotiation — not after the contract is signed.
- Confirm the exit in writing: the handover date, the two-week solo run, and the debrief for your engineers.
- Ask what your team will learn, and get the debrief scheduled before the engagement starts.
- Decide, in writing, whether you will also hire — and if so, post the role while the engagement is running.
The deployment is the job. Whether you hire, buy, or take advice, judge the choice the same way: will the product work inside the customer’s world, on a Tuesday morning, with nobody from your team in the room? If yes, the engagement worked — and the next deployment will be easier, because you will have a team that can run it, a product that has learned from it, and a company that knows what forward deployed engineering actually is.
Comments
Post a Comment