A consulting recommendation can be completely right and still never happen. The team that wrote the strategy is not the team that builds it. The building team therefore spends months reconstructing context that already lived in someone’s head. By the time anything runs, the expectations have quietly moved. The work was good, it just never shipped.

This gap is what forward deployed engineering is for: it doesn’t stop at the recommendation. An engineer embeds with the client, works in the client’s repository, and ships code that runs in production. It is not a replacement for consulting. It is the part that comes after. The part that has been missing until now.

The loop gets short. When the builder sits inside the team rather than outside it, the time between noticing a problem and fixing it shrinks to hours. No ticket queue, no context lost on the way. The latency between learning something and acting on it is what makes the difference. You see a problem in the morning and the corrected behaviour is implemented in the afternoon, reviewed by someone who really understands it. Over a few weeks this way of doing things compounds into a delivery that moves at a different speed.

Requirements only describe the ideal version of the job. But the real job is messier than that. The exception that comes up once in a while, the habit nobody wrote down, the data that is nothing like in the spec. None of those things show up in a meeting. They only show up when you are present. You can outsource thinking, but not understanding. Understanding your business, your systems, your people comes from being present over weeks.

What is left behind is capability, not a document. Most engagements end with a simple handover. And then the people who built the thing leave and take the real knowledge with them. We run it the other way. We transfer ownership. Early on we lead and the client’s team learns. By the end their engineers lead and we review. The last loop is the one where the client leads and we watch. Whatever gets built is meant to run without us. Leave the capability, not the reliance.

There is a larger shift behind this. Software delivery is changing on the scale of waterfall giving way to agile. And the firms that adopted this way of thinking already look different. The honest question to ask anyone is where on that curve they actually sit, and whether they can show you rather than only tell you. We would rather you watch it happen in your own repository.

None of this is a criticism of consulting. Strategy and design are where good work starts. Forward deployed engineering is the discipline of not stopping there, of making sure something good becomes something that runs, matches how things actually get done, and stays after we go.

Build with, not for.