Build-and-operate beats build-and-leave

Software that nobody operates degrades. Within months of launch, dependencies drift, edge cases pile up, and the people who understood the system have moved on. The single biggest predictor of whether custom software still works in year three is not how it was built — it is whether the team that built it stayed to run it. That is the difference between build-and-operate and build-and-leave, and it decides total cost of ownership more than any technology choice.

Why build-and-leave quietly fails

In the build-and-leave model, an agency delivers code at launch and exits. The incentives are honest but misaligned: the agency is paid to ship, not to keep the system healthy, so it optimises for a clean handoff rather than for the years that follow. The costs surface later and land on someone else.

• Knowledge evaporates: the only people who understood the architecture are gone.
• Reliability is an afterthought, because no one who built it carries the pager.
• Security patches lag, because maintenance was scoped out of the original budget.
• Every change costs more, because the next team must reverse-engineer the first.

What changes when you carry the pager

Teams that operate their own software make systematically different decisions. They choose boring, proven technology over novelty. They invest in observability and tests up front because they are the ones who get woken up. They design simpler systems, because complexity they ship is complexity they have to live with. The result is software that is cheaper to run and easier to extend — not because the team is more talented, but because the feedback loop is closed.

How to evaluate a partner on this

• Ask who operates the software after launch — and what happens at 2am when it breaks.
• Ask what they themselves run in production. Operators have war stories; builders have demos.
• Look at total cost of ownership over three years, not the delivery quote.
• Treat a maintenance plan as part of the build, not an upsell you negotiate later.

Build-and-operate is a quieter promise than 'we can build anything.' It is also the one that determines whether you own an asset or inherit a liability.