Build the thing that fits

TL;DR

Building software used to be the expensive part, so everyone bought generic and hired an army to bridge the gap. AI collapsed the cost of building. Build the thing that fits, own it, and watch the L1/L2/L3 pyramid shrink. Buy only the true commodities.

For most of software's history, building was the expensive part. Writing it, wiring it together, keeping it alive. All of it took scarce, costly engineering. So most enterprises did not build. They bought something generic and spent years, and fortunes, bending the organisation to fit the tool. Or bending the tool to fit the organisation, through a standing army of integrators, consultants, customisations and support contracts. That arithmetic has changed. AI agents now do the writing, the wiring, and increasingly the maintenance. The thing that used to be prohibitively expensive, software shaped to your exact operation, is within reach. Which forces an old question back into the open.

What was software ever for: to solve a problem, or to sell a relationship you maintain forever?

The bargain nobody actually chose

Because building was expensive, a bargain formed, and everyone accepted it. You bought a platform built for the median company. It did not quite fit. It never could. So you bought the integration project to connect it, the customisation to reshape it, the managed service to run it, and the tiers of support to answer for it when it broke. Layer by layer, the software you licensed to solve a problem became a permanent apparatus you had to feed. The tool became a relationship. The relationship became a budget line that only ever grows.

Silos, and the tax on the seams

The clearest symptom is the silo. Every department bought the best tool for its slice, and now the enterprise runs on dozens of systems that do not speak to each other. Bridged by spreadsheets. By people re-keying data from one screen into another. By integration middleware that is itself another thing to license and maintain. The connective tissue between systems is the part that actually matters, because your business lives in the seams. It was also always the hardest and most expensive thing to build. It is not anymore.

Software that manages itself, or that you can

Here is the part that should reset expectations. The L1, L2, L3 support pyramid is not a law of nature. It exists because software is generic, opaque, and not yours. Generic, so it does things you never needed in ways you cannot change. Opaque, so when it misbehaves nobody on your side can see why. Not yours, so every real fix routes through someone else's queue. Software built for your operation, observable end to end, and increasingly able to diagnose and repair itself, collapses that pyramid. Most tickets stop existing because the software fits. The rest get answered by people who can actually see inside the thing.

Software you built for you, that stays with you. Not software you rent and forever escalate.

The goal was always to solve the problem

Strip away the industry that grew up around software and the original purpose is almost embarrassingly simple. Solve a problem, well enough that it stays solved. Somewhere the incentives drifted, and solved-and-forgotten became a worse business than sold-and-supported. Seats, tiers, professional services, renewals. The machine came to reward software that needs you more over time, not less. Building your own inverts the incentive. When the software is yours, every problem it stops causing is pure profit.

What not to build

This is not a case for building everything. Genuine commodities should still be bought. Email, the ledger, the plumbing every company runs the same way. There is no edge in a bespoke inbox. The discipline is knowing the difference. Build the parts that are yours, the workflows that encode how you actually operate, the connective tissue between your systems, the judgment your people carry that your tools do not. Buy the parts that are truly the same for everyone. And be honest that building is a commitment, even now.

Build, and keep what you build

So, build. Build the thing that fits. The thing that combines your silos, wraps your systems, and feels to your people like one thing instead of forty. Build it observable, so you can watch how it works. Build it on your stack, learning from your real work, so it improves as it runs. And build it to be yours. Software that solves the problem and then stays with you, quietly, instead of joining the queue of things you manage. The cost of building has fallen far enough. The excuse is gone.