FDE Times dataFDE jobs open 924▲33 Change in open roles over 7 days, like-for-like: roles from companies we started tracking this week are left outNew in 7 days 80Companies hiring 196Remote-friendly 25%Median US pay $200kTop hirer Databricks 107
中文VI

The newspaper of the Forward Deployed Engineer

Guides

Who gets to send work to an FDE, and when to hand it back

A five-line intake ticket and a clear boundary tell forward deployed engineers when to stop building and pass the work to the product team.

ShareLinkedInFacebookX

In brief

  • Route requests through the person who owns the customer relationship, and name the customer-side person who will approve the result from the start.
  • Every request needs a traceable delivery item that explains why the work belongs to the FDE, reviewed by the Product Owner.
  • When work crosses the boundary or is blocked by something only the product team can fix, stop and hand it over with documentation and an upstream PR.
Decision tree with four questions stacked vertically: is the change atomic, is it independent, does it leave the architecture intact, and is one owning team enough. Four answers of "yes" mean the FDE moves fast. A single "no" means stop and hand the work to the product process, shown in an orange box.
FDEs ship straight to production only items that are atomic, independent, leave the wider architecture unchanged and need no cross-team coordination. Work that crosses these boundaries must stop and go through joint planning. Source: AgileLab's Witboost handbook.

At Ramp, the FDE team takes significant blockers for both existing and prospective customers from account managers.

That detail matches something every FDE has run into: the most expensive part of a request usually comes before the first line of code. Who is asking, what the customer actually needs, and whether the work is yours at all. Answer those three questions too slowly and you can lose a week on work that belonged to the product team.

An intake gate answers them systematically. Without one, the FDE becomes the place every urgent request lands without anyone weighing it. The gate has three stages: who may send work, how the request is written down, and when you hand the work back to the team that owns it.

Requests should come through the relationship owner

At Ramp, the way in is the account manager. PostHog’s FDE handbook shows the same logic from the other end: when an engagement closes, the FDE hands the customer relationship back to the account owner.

If the relationship starts and ends with the account owner, it makes sense for requests to pass through them too. When a customer messages an FDE directly, nobody on your side can judge how that request weighs against the other commitments made to that customer. So the “requester” field in the backlog should be the account owner, even when the idea came from you.

The customer needs a counterpart as well. PostHog writes that FDE work needs a clear owner on the customer side. An engagement closes only when that named person approves the final deliverable, and the customer signs off on each milestone before it starts, whether or not the engagement is paid.

Five lines before any code

AgileLab’s Witboost handbook asks FDEs to record a traceable item describing the problem, the customer value, the expected outcome, a rough size and the reason the work qualifies for an FDE.

The Product Owner reviews each item to confirm its value and its fit with the product’s direction. The lines sound simple, and because they are simple they expose straight away what you have not yet understood.

Take a hypothetical case. The account owner forwards a request from a logistics customer: “let us export event data to our data warehouse, with the warehouse code attached.” Written as a delivery item, it looks like this:

requester: account-owner          # not the customer messaging directly
problem: The customer's late-shipment report requires manually joining warehouse codes from a separate file
customer_value: Removes the customer operations team's manual join every morning
expected_outcome: Every exported event carries a warehouse_id field
rough_size: S — add one field to the existing exporter
why_fde: Small, bounded, done in a few days
customer_owner: customer-side data lead (approves the result)
boundary_check:
  small_and_bounded: yes
  short_credible_effort: yes
  only_product_team_can_fix: no

The five lines from problem to why_fde follow Witboost’s list exactly. The other three fields are not on that list, but they are well worth adding.

The requester field records the rule from the first stage. The customer_owner field names the person who will approve the result, so at acceptance nobody has to ask who has the authority to sign. The boundary_check field leads into the final stage: when the work must go back to the team that owns it.

Which work can an FDE do quickly?

Witboost draws the boundary in one sentence: FDE work must be small and bounded, with a short, credible implementation effort. PostHog adds another: when an engagement is blocked by something only the product team can fix, the FDE hands the work to the owning team.

Question FDE carries on Stop and hand over
Size Small and bounded Grown beyond the agreed boundary
Effort Short, credible estimate Can no longer be estimated
Who can fix it The FDE can do it Only the owning product team can fix it
Product direction Confirmed by the Product Owner Needs a new decision on direction

Back to the example. Halfway through, you discover the event stream has no warehouse_id available, and getting one means changing a shared schema owned by another team.

The “Who can fix it” row has just switched columns. Witboost is explicit about work that crosses the boundary: stop and move it into the standard planning process.

Stopping here is the right engineering decision, and there is nothing failed about it. Update the delivery item, record why the size changed from S to something larger, and tell the account owner before the customer has a chance to ask.

Handing over without losing the lesson

How you hand over depends on the receiving team. PostHog notes that some teams prefer an asynchronous write-up while others want you to join their standup. Asking the schema team which they prefer is faster than guessing.

The thing most easily lost is the lesson from the customer. The Field-to-Product model for FDEs proposes feeding field fixes back into the product as pull requests. Grizen describes FDEs building for one customer, then handing ownership back with documentation and usage guides.

Insight Partners takes the wider view: once a result is proven, ownership moves to the teams that turn it into a product and run it at scale. If you have already shipped a temporary patch on the customer side to hit a deadline, leave a short document explaining why the customer needs the warehouse code, along with a PR or ticket for the owning team.

Common mistakes

The first mistake is accepting requests through a customer’s private messages to look responsive. You win over one person, and the account owner loses the overall picture. The second is leaving the size field blank, then discovering that the “small” job actually reaches into another team’s territory.

The third is harder to spot: carrying on after the work has grown, simply because you already promised the customer. The last is closing an engagement without returning the relationship to the account owner, so the customer keeps messaging you directly and bypasses the intake gate you just built.

Showing this skill on a CV

When reading FDE job postings, look for phrases such as intake, scoping, working with product, or feeding customer feedback into the roadmap. They tell you whether the company already has an intake gate or is waiting for you to build one.

In interviews, a story about stopping half-finished work to hand it to the owning team is usually more convincing than a story about an all-nighter. On a CV, write in verifiable outcomes, such as the number of customer requests you turned into upstream PRs, or the delivery item template you built for the whole team.

This week’s exercise: take the vaguest request you are holding and run it through all five lines and both boundary questions. If there is a line you cannot fill in, the next step is to ask the account owner. Opening the editor can wait.

Was this article useful?

Use with your AI assistantAsk Claude ↗Ask ChatGPT ↗
8 sources
Read next on the roadmap · Stage 4: CustomersWhy every FDE has to explain the same system twiceA director needs one paragraph to make a decision; the client's lead engineer needs enough detail to run the system alone after you leave.