The “buy a software once and own it forever” model used to be the norm. Microsoft Office on a CD. Photoshop in a box. Games on a cartridge. Then it died, almost completely, in less than a decade.
The common explanations — “subscriptions are better for developers” — are shallow. The truer story is that several forces stacked, and once they stacked, the old model became structurally fragile. Understanding the actual sequence matters because some of those forces are now reversing.
1. Software stopped being a product and became a process
Early software was a product:
- Shipped on floppy disks or CDs
- Ran on a relatively fixed OS
- Lived in a stable environment
- Changed rarely
In that world “buy once” made sense and “forever” was plausible.
Then the environment changed. Operating systems started updating constantly. Browsers shipped new versions monthly. Hardware diversified. File formats evolved. Security threats became continuous.
Even if the tool itself didn’t change, everything around it did. “Own it forever” quietly turned into “own it, but hope it keeps working.”
2. Distribution went to zero, maintenance did not
Physical software had natural friction:
- Manufacturing
- Shipping
- Retail margins
That friction justified high upfront prices ($100–500 for a serious application).
When distribution went digital:
- Marginal cost went to zero
- Price expectations collapsed
- Piracy increased
- Refunds became trivial
But maintenance costs didn’t fall:
- Bug fixes
- OS compatibility
- Support emails
- Documentation
- Security updates
The old model assumed most costs happen before launch. Modern software reality is that most costs happen after launch. That mismatch broke “buy once” economics for most developers.
3. The update expectation changed permanently
Users didn’t just want software to keep working. They wanted:
- New features
- Integrations
- Cloud sync
- Cross-device support
- Collaboration
And they wanted it continuously.
Once that expectation became universal, the transaction stopped being “I bought a thing.” It became “I am funding a stream of work.” Subscriptions weren’t just a business trick — they matched a new expectation loop.
4. SaaS solved real problems (at a cost)
SaaS didn’t win only because of greed. It solved genuine pain:
- No installation
- No version conflicts
- No backup management
- Easy collaboration
- Access from anywhere
For many classes of software, these benefits were real.
But SaaS also quietly introduced account dependency, data lock-in, surveillance, rent extraction, and forced upgrades. The convenience masked the trade-off.
5. Venture capital distorted incentives
Once software companies became VC-backed, growth mattered more than sustainability. Recurring revenue mattered more than sufficiency. Retention mattered more than user autonomy.
“Buy once” doesn’t compound. Subscriptions do. The ecosystem optimized for lifetime value, engagement, and churn reduction — not for finishing software, letting users leave cleanly, or building tools that end.
6. Ownership quietly lost its meaning
With physical goods, ownership is clear and possession is control. With software:
- Licenses replaced ownership
- DRM crept in
- Cloud dependence blurred boundaries
You could “buy” software and still lose access, be forced to upgrade, have features removed, or have data trapped. Even when sold once, it often wasn’t truly owned. Users noticed, and trust eroded.
7. Identity became the control surface
Once accounts became central:
- Ownership shifted from user to provider
- Access became revocable
- Continuity depended on permission
At that point, “buy once, own forever” wasn’t just dead — it was incompatible with how software was structured. You can’t own something that needs permission to exist.
Why this matters now
The original reasons “buy once” died are weakening:
- Tool-building costs are collapsing because of AI
- Many tools no longer need servers (static hosting, client-side WASM databases)
- Distribution is trivial
- Support can be minimal by design
What remains is mostly habit. The rent-seeking structures persist even after the cost structures changed.
What replaces “buy once, own forever”
Not a return to the old model verbatim. Something slightly different:
Build tools that are finished, self-contained, and maker-blind.
You might pay once, or pay optionally, or pay nothing. But after install:
- The tool owes you nothing
- You owe it nothing
That is the underlying idea behind Zapps.
The real takeaway
“Buy once, own forever” didn’t die because it was naive. It died because software stopped being treated like a tool and started being treated like a relationship.
Zapps aren’t nostalgia. They’re a recognition that for many tools, the relationship was never necessary in the first place. When software can end, ownership starts to make sense again.