Insights - Open source won the cost war. Most businesses never collected the winnings.

Somewhere in the last decade, the cost of building serious software quietly collapsed. Not by a little. By an order of magnitude. And almost none of the businesses that would have benefited most ever noticed it happen.

The quiet collapse

Twenty years ago, building a custom application meant building almost all of it. The database, the authentication, the queuing, the search, the file handling, the deployment machinery — each was a project in itself, and each had to be paid for. The result was simple and brutal: real custom software was something only large companies could afford, because only large companies could absorb the cost of building the same foundations everyone else was also building.

Open source dismantled that, piece by piece, in the open, for free. The foundations got written once and shared by everyone. The database you would have spent a quarter building is now a download. The auth system, the search engine, the message queue, the entire deployment stack — all of it, mature and battle-tested, sitting there for the taking.

The foundations stopped being something you paid to build. They became something you paid someone to assemble correctly. Those are very different prices.

Why the savings didn't reach the people who needed them

Here's the strange part. The cost of the ingredients fell to nearly zero, but the price most businesses were quoted for custom software barely moved. Why?

Because assembling open-source components correctly is its own skill, and a scarce one. Knowing which database, which framework, which queue — and how to wire them together so the result is secure, maintainable, and actually fits the business — is not free, and not obvious. Plenty of firms learned to charge from-scratch prices for assembly work, pocketing the difference that open source had created.

For a small or mid-sized business, the experience was unchanged. They still got a quote that didn't make sense, so they still did what they'd always done: bought an off-the-shelf tool that almost fit, and lived with the gap.

Collecting the winnings

The savings were real. They just required someone willing to pass them on — a builder whose instinct is to compose what already exists and charge only for the part that's genuinely yours.

That instinct is the whole game. The most expensive line of code is the one written when a proven component would have done the job. Every hour spent rebuilding a solved problem is an hour billed for nothing of value. Run the discipline the other way — reuse aggressively, build narrowly — and a genuinely custom system lands at a fraction of its old price, without dropping to the quality of something off the shelf.

That's not a discount. It's the actual price, finally reaching the people the old price kept out. Open source won the cost war years ago. The work now is making sure the winnings get collected by the businesses they were always meant for.