Software Development Is Now a Commodity

Somewhere this quarter, in a conference room a lot like yours, someone will say "we can't afford custom software" — and the meeting will move on, because for twenty years that sentence was simply true. Nobody checked it. Nobody had to.

It expired. Quietly, recently, and without most budget meetings noticing.

Last time, I made the case that "always buy, never build" stopped being right, and I said one thing almost in passing: cheap printing didn't end the written word — it put words on everything. That was one paragraph. This is the whole economic story. The most expensive part of software is no longer writing it, and that changes everything about what you should buy.

You've watched this happen before

If you run an operations-heavy business, you already understand this shift. You've lived through it once — in metal.

A custom machined part used to mean finding a machinist, dialing in a setup, waiting weeks of lead time, and paying for every hour of it. Custom was the expensive option, the one you chose only when nothing off the shelf would do. Today you send a file and parts come back in hours. And here's the part that actually matters: once custom got cheap, nobody accepted "close enough" parts anymore. The standard rose to meet the new cost.

Software just went through the same shift. Most people haven't noticed, because the last shift they lived through in software ran the other direction — toward buying, toward renting, toward close enough.

What exactly got commoditized

Not just typing code. That's the part everyone fixates on, and it's the least of it.

In my CTO years I designed and built a PCI 4.0 compliant payment system on AWS — the kind of build where the stakes are real: millions of transactions, customer card data, network isolation that has to survive segmentation testing and external penetration tests, not just a code review. Four developers, nine months.

And here's what those nine months were actually made of. Writing code was the small part. The bulk was the loop around the code: a developer builds a piece, I review it, it's wrong — not lazy-wrong, but doesn't-meet-the-standard wrong — and it goes back. Each trip around that loop took weeks. Design it, build it, test it against the compliance requirements, find the gap, do it again. Multiply that loop by every component of the system and you get nine months of four skilled people, most of it spent waiting for the next iteration to come back.

That loop is what collapsed. The same class of build today takes under a month — not because the standards got looser (they didn't; it still has to pass the same segmentation and penetration tests) but because the cycle time went from weeks to minutes. When an iteration costs minutes instead of weeks, "do it again until it's right" stops being the expensive part and becomes the default. The cost didn't fall; it collapsed, across every stage of the work at once.

When a cost drops that far, that fast, it doesn't just make the old thing cheaper. It changes what's worth building at all.

What commoditization always does — two effects, not one

When production gets cheap, two things happen. Every time, in every industry. Software is not exempt from either.

First, the value moves. It leaves the production line and goes to the two ends: knowing what to make, and standing behind what you made. Photography is the cleanest example. When everyone got a camera in their pocket, taking a technically competent photo became free. Professional photographers didn't disappear — but the ones who thrived weren't selling shutter-pressing anymore. They were selling the eye: knowing what to shoot, when, and why, and being accountable for walking away with the picture. The cheap part got cheap. The scarce part became the whole business. In software, the typing got cheap. What's scarce now is judgment — knowing what to build and how a business actually runs — and accountability — being the one who answers when it breaks.

Second, demand explodes. Cheap production never means less of the thing. It means the thing goes places it could never reach before. More photographs are taken every year now than were taken in all of history before the smartphone — because a photo became worth taking of anything. Printing did the same for words. And software is about to do the same for workflows: every process that was never worth building for is suddenly worth building for.

Hold both of those at once and you get the actual future: not less software, but vastly more of it — built by people whose value is judgment and accountability, for businesses that could never justify it before. What's changing isn't whether software gets built. It's how — and for whom.

The uncomfortable part for SaaS

SaaS was a brilliant answer to a specific problem. When writing software was 80% of the cost, the only rational move was to write it once and share the cost across a thousand customers. That's the entire premise. It's why the model won.

But you never just shared the cost. You shared the software — everyone got the same product, built for the statistical average of a thousand businesses, fitting none of them exactly. That was the price of the discount, and for twenty years it was a price worth paying.

When the cost of building collapses, the discount stops justifying the compromise. That's the whole story. And if you want to see a business model straining against math it can't win, look at feature bloat: the thousandth feature bolted on so the pitch can still say "we do everything," sold to a company that needed twelve features and three that don't exist yet. That isn't innovation. That's a cost-sharing model trying to outrun the fact that cost-sharing stopped being the point.

The uncomfortable part for you

Which brings us back to the conference room.

"We can't afford custom" was a fact for twenty years, and beliefs that were true for two decades are the hardest ones to notice you're still carrying. It's now a belief. The question has flipped — from can we afford to build? to can we afford to keep renting what almost fits? Paying every month, forever, for a product shaped to someone else's business, while the work that's actually yours lives in a spreadsheet nobody will admit runs the place.

What to do with this

Not fire your vendors. Plenty of your software should stay bought. This is a call to run an audit — three columns: what you pay for, what you actually use, and what you run around the software to do.

The first two columns will surprise you, but the third one is the point. The spreadsheets. The emailed forms. The checklist in one person's head. The steps everyone knows and nobody wrote down. That column used to be the unavoidable cost of doing business — too specific to buy, too expensive to build, so you routed around it and called it normal.

That third column is the demand explosion, sitting in your own operation. It is now the most buildable software in your company, and almost always the highest return — the work that's uniquely yours, which is exactly why nothing off the shelf ever fit it.

The gap was always there. What changed is that it's now cheap enough to close.