← Back to Field Notes
Perspective 003 · July 2026

The Forward Deployed Gold Rush

What a forward deployed engineer actually is, why agentic engineering works, and what the right one delivers, with receipts.

There's a surge of communication right now around the Forward Deployed Engineer. Every week another thread, another job posting, another hot take about the FDE as the role of the decade. And underneath most of it is the same excitement: someone stood up a proof of concept in front of a customer, and the room lit up.

I understand the excitement. I just think it's aimed at the wrong thing.

A proof of concept is the easy 20%. The demo works because the demo was built to work: clean inputs, a friendly audience, and nobody asking who's on call when it breaks. What makes the forward deployed model genuinely interesting isn't the POC. It's what becomes possible when the full stack of skills (strategy, implementation, operations, and hands-on engineering) compound in one person who's actually deployed inside the customer's environment. That compound is rare. The title, right now, is not.

This post is an attempt to answer four questions plainly: what is a forward deployed engineer, why does agentic engineering work, what experience does the job actually demand, and if you invest in the right person, what should you expect to see?

Where the Gold Rush Came From

The FDE wave didn't appear out of nowhere. It stems from a gap tech has been quietly living with for a decade: customer success was asked to augment implementation and services, because real services organizations were something software companies didn't want on the books.

The logic was reasonable at the time. Services dollars didn't scale. They dragged down gross margin, muddied the multiple, and made a software company look like a consultancy to investors who were paying for ARR. So implementation got thinned out, handed to CS teams with playbooks, or pushed to partners. "We're a product company" was a compliment precisely because it meant we don't do services.

Flash forward to 2026, and the incentive has inverted. Now everyone wants the services motion, not for the services revenue, but for what riding shotgun on deployment buys: the rights to first deployment. To be the ones trusted with the software that gets built. Because whoever lands that first deployment decides what's underneath it.

And that's the real prize. Embed a frontier lab's model behind the technology at deployment time (Anthropic, OpenAI, whoever) and it disappears from the conversation. Nobody in the customer's building asks which API key is running behind the services. Nobody re-opens the model bake-off. Switching costs now live inside a production system the customer depends on, wrapped in workflows the FDE built.

Services went from margin poison to the distribution channel for the most valuable technology on earth. That's why the title is suddenly everywhere.

The Experience Question, Honestly

Here's the part I'll say carefully, because I don't mean it to be exclusive: I don't believe someone can be a successful forward deployed engineer without a diversified base of experience supporting companies of different sizes, up to and including the enterprise.

The reason is that the two common paths into this work each produce half the skill set, and each half looks complete from the inside.

The consultancy path produces breadth on a compressed clock. Someone who came up through consulting can have fewer years under their belt and still have real exposure to strategy, management, and a dozen different environments in the time a product engineer sees one. That breadth teaches the most valuable diagnostic skill in deployment work: knowing what's standard across every environment and what's genuinely unique to this one, which is exactly the skill that keeps you out of rabbit holes. But that same person, with limited hands-on development work, has usually never supported what they designed in production. They haven't been paged. Strategy without production scars produces beautiful decks and fragile deployments.

The growth-stage path produces the opposite. An engineer who came up inside startups at the growth stage has genuine hands-on deployment experience: they've shipped, broken, and carried systems that real customers depended on. What they usually haven't had is the formal side: the strategy and management reps a consultant collects, the exposure to how procurement, security review, and risk actually move inside a large organization. So every enterprise quirk looks unique, everything becomes a custom build, and every rabbit hole looks like the critical path.

What I've found actually covers the job is the union of both, and a few things neither path teaches on its own: understanding technical product implementation end to end; being able to read engineering risk operationally, the way an enterprise reads it; knowing how enterprises need to move and mitigate risk; and having lived the differences between growth-stage, pre-IPO, and public companies, ideally including a successful exit, because an exit teaches you what "done" means at the level of a whole company.

I'll be honest and, I hope, modest about the next part: I've had those experiences. Fourteen years of professional career, spent roughly two to three years at a time across each of those seats. I'm not claiming that's the only path. I'm claiming the compound is the qualification, and that when you have it, something changes: you can compress timelines because you're doing the delivery and the consulting management as the same person. There's no handoff between the person who scoped it, the person who built it, and the person who reports on it. They're one head.

What That Looks Like in Practice: the Receipts

Numbers, because every claim in this post should have one.

In July, a mid-market client approved a monthly scope: 53 committed story points, frozen after sign-off, with the working assumption that scoping-to-reporting would take the full 31-day cycle. That's a normal assumption. It's how a competent team plans.

Here's what actually happened, from the delivery ledger:

  • Day 19: the committed 53 points closed. Out of a 31-day period, with every item operator-verified before it counted.
  • 68 / 68 achievable points by day 21. Every remaining stretch item shipped: the full board, delivered across nine build days.
  • 65 automated test cases alongside the features. Plus operator QA on every item and three client-style review rounds on the UI work.
  • One person, end to end. Requirements gathering, the scoping brief, the build, the QA orchestration, and the client-facing reporting. The same head.

Put that against the human benchmark. A senior engineer, in traditional terms, does somewhere between two and three story points a day, call it 10 to 15 points a week. Nine build days at 68 points is about 7.6 points a day: 30 to 45+ points a week, roughly triple the senior-engineer pace, while also being the person doing the front-end scoping and the reporting that usually belong to two other salaries. That last part matters as much as the speed: every additional head in the delivery chain is cost that lands back on the customer. The compound removes the heads without removing the functions.

A POC proves the model. Production proves the engineer.

Why Agentic Engineering Works, and Why 3× Is the Modest Number

I want to be clear that the 3× I just claimed is the conservative end of what's being reported by the people building these tools.

Boris Cherny, the creator and head of Claude Code at Anthropic, published a framework this month describing five steps of AI adoption for engineering teams, with each step carrying a rough multiplier: gated (0×), assisted (~1×), parallel (~10×), supervised autonomy (~100×), and AI-native (1,000×+). His own description of how his work changed is the whole thesis in one line: he doesn't prompt the tools anymore; he builds loops that prompt the tools. (Source, worth reading in full.)

The July numbers above came from exactly that: steps three and four, parallel work and supervised autonomy. Autonomous loops over systems I had already validated and tested, with verification gates so the loop earns trust instead of assuming it. That's also why I can say something I wouldn't have said a year ago: my near-term capacity constraints are effectively gone. I watch them (monitoring is the job), but I've already passed what I would have called my capacity ceiling in traditional terms, because the ceiling was never me. It was how much validated system I could safely put in a loop.

(I'm also building an open-source tool to show how these systems get built; a document on it is coming. This post is the proof piece; that one will be the how.)

And this is not a boutique-consultancy quirk. When Cloudflare cut 1,100 roles this spring, the CEO's own framing was that the "measurers" went and the "builders" stayed. And whatever you think of branding laid-off people that way (I think the scarlet-letter discourse around it is fair criticism), the direction underneath it is unmistakable: their engineering headcount grew 45% afterward. Enterprises are reorganizing around people who build and monitor autonomous systems. The forward deployed engineer is that motion, delivered as a service.

The ceiling was never me. It was how much validated system I could safely put in a loop.

What You Should Expect, and an Honest Invitation

If you invest in the right person for this, the expectations are allowed to be specific: scope frozen in writing, delivery measured against it line by line, test coverage and verification evidence on every item, reporting you don't have to chase, and timelines that beat the plan rather than excuse it. That's not heroics. It's what the compound produces when it's real. Ask for the receipts; anyone actually doing this work has them.

Ours are on this site. The rest of the field notes walk through the systems behind them.

And the honest invitation: our 2026 calendar is full, so we run a queue for 2027 engagements. If a full agentic engineering experience (timelines exceeded, costs inside a budget you set) is something you want a conversation about, the queue is free to join, and it's where I start those conversations. No pitch beyond that. The work above speaks at whatever volume it deserves.

The discussion is live on LinkedIn

See the original on LinkedIn and join the discussion →

Who this is for

This is for construction and industrial operators evaluating a forward-deployed build partner instead of another software subscription. If your estimating or field ops team needs production-grade delivery, not a demo, this is the track record to check.

A POC proves the model. Production proves the engineer.

Join the 2027 queue →