We Have Entered the Era of Disposable Software

For most of my career, custom software was something only large companies could justify. If you wanted a task management system, a CRM, or an inventory application built specifically for your business, you were looking at months of development and a budget that put it out of reach for most small businesses. The alternative was to buy an existing product and adapt your business around the way that software happened to work.

I don’t think that’s true anymore.

Over the last few months, I’ve become convinced that we’ve crossed a line. The economics of software development have changed so dramatically that we’re going to look back on this period as the beginning of an entirely new era. Not because AI is replacing software developers, but because it has fundamentally changed how expensive it is to create software.

Think about products like Hive, Asana, Basecamp, or countless other business applications. Ten years ago, recreating something comparable would have required a team of developers and a long runway. Today, a single person with domain expertise and the right AI tools can build an application with much of that core functionality in a matter of days. A week isn’t an outrageous claim anymore. In some cases, neither is a weekend.

That doesn’t diminish what those companies built. They’ve spent years refining their products, supporting millions of users, and solving edge cases that most businesses will never encounter. Building something that works is one thing. Building something secure, reliable, and maintainable over time is another.

But it does mean the barrier to entry has collapsed.

The feature itself is no longer the valuable part.

A Kanban board isn’t valuable because it’s difficult to program. Neither are recurring tasks, comments, notifications, dashboards, or permissions. Those have become building blocks. The real challenge is deciding which of those blocks your business actually needs, how they should fit together, and how they should behave.

In other words, the scarce resource is no longer code. It’s architecture.

I think that’s going to change the software industry in ways we haven’t fully appreciated yet. Instead of every business asking, “Which software should we buy?” they’ll increasingly ask, “Would it make more sense to build exactly what we need?” For a growing number of companies, the answer will be yes.

Not every business will want to build and maintain its own software, of course. There will always be value in products that handle the security, infrastructure, integrations, and ongoing maintenance. But businesses will have choices that simply weren’t practical before.

That’s why I think we’ve entered the era of disposable software.

I don’t mean disposable in the sense that it’s poorly built or temporary. I mean that software is no longer so expensive to create that every application has to become a product sold to thousands of customers to justify its existence. Businesses will build applications to solve a problem, use them while they provide value, improve them as needed, and eventually replace them when something better comes along. The cost of creating software has dropped low enough that replacing it can become a practical business decision instead of a financial catastrophe.

But there’s an important distinction here. The software may be disposable. The information it manages should not be.

A business’s customer records, operational knowledge, documents, and processes have value that extends well beyond any particular application. If that information is trapped inside the software, replacing the application can still be expensive and disruptive, no matter how quickly a new one can be built.

I suspect this will become an increasingly important consideration. Businesses will need to think less about committing to a particular application forever and more about maintaining control of their data and the knowledge that makes their operations work.

We’ve spent decades treating software like a building that had to last forever because constructing it was so expensive. I think we’re entering an era where software is becoming more like a tool. You build it because it solves a problem. You improve it while it remains useful. And when it no longer serves its purpose, you build the next one.

The tool can change without losing everything you’ve built with it.

That’s a very different way of thinking about software, and I suspect it’s where the industry is headed.