Technology

Why software became a subscription, not a purchase

By Leandro Bruzaferro · · 6 min read

There was a period when buying software meant owning a version of it. You paid once, the program worked indefinitely, and upgrading was a decision you made every few years or never. That model has largely gone from consumer and professional software alike, and the reason has less to do with what software does than with how companies prefer to be paid.

How perpetual licences worked

A perpetual licence granted the right to use one version forever. Revenue arrived in a lump at the moment of sale, and the vendor’s problem was what happened next.

Their problem was a repeated one. Each new release had to be desirable enough to persuade people who already owned a working copy to pay again, which meant every cycle carried real risk. A release that landed badly produced a revenue trough that was visible for years. Meanwhile a substantial part of the installed base sat on versions several generations old, receiving no revenue while still generating support cost, and piracy was straightforward because a licence key was a static secret.

The revenue shape was the deeper issue: large peaks at launch, long declines afterwards, and an entire year’s results resting on whether one release was well received. That pattern is difficult to plan around and unattractive to investors, who pay more for predictable income than for lumpy income of the same average size.

What changed in the business model

Subscriptions solve the vendor’s problem comprehensively, and it is worth being precise about how, because the benefits to users are real but incidental.

Revenue becomes recurring and forecastable, which raises the valuation of the same underlying business. Upgrade risk disappears, since there is no purchase decision to lose; there is only a cancellation to avoid, and inertia works in the vendor’s favour. The installed base collapses onto current versions, which cuts the cost of supporting old ones. Piracy becomes harder, because entitlement is checked against a server rather than a key. And the relationship produces continuous data about which features are used, which informs development in a way that boxed software never permitted.

Two external shifts made the transition practical at the same time. Reliable broadband made server-side entitlement checks and continuous delivery feasible. And software increasingly included genuine ongoing costs, storage, sync, collaboration infrastructure, and now inference, which a one-time payment does not sensibly fund.

That last point is the strongest honest argument for the model. A program that runs entirely on your machine has no recurring cost to the vendor beyond support. A program that stores your files, synchronises them across devices and runs computation remotely does, and pretending otherwise produced the awkward era of paid major-version upgrades funding free infrastructure.

Set the two models against each other and the direction of the change becomes obvious:

Perpetual licence Subscription
Revenue shape Large peak at launch, long decline after Recurring and forecastable
Vendor’s main risk Every release must persuade existing owners to buy again Cancellation, which inertia works against
Installed base Fragmented across many old versions Concentrated on the current version
Support cost Old versions supported while producing no revenue Only the current version
Piracy exposure A static key, easily shared Entitlement checked against a server
What the user holds A version, indefinitely Access, while paying
Cost ceiling for the user Fixed at the moment of purchase Set by the vendor, annually
Declining an unwanted change Skip that version Not available

Every row in the middle column describes a problem for the vendor. Every corresponding row in the right column solves it. The bottom two rows are the only ones where the user’s position clearly worsened, and they are the two that generate essentially all of the complaints.

What subscribers gain

The advantages are not imaginary, and dismissing them makes for a weaker analysis.

Improvements arrive continuously rather than being held for a release cycle, and security fixes reach nearly everyone because nearly everyone is current. The entry cost drops sharply, which matters for students, freelancers and small businesses who could not justify a large upfront licence. Cross-device use and collaboration work without licence gymnastics. Short-term use becomes economical: paying for two months to finish one project was impossible under perpetual licensing.

For anyone whose use is occasional or whose cash flow is tight, subscription pricing is straightforwardly better, and it opened professional tools to people previously priced out.

What they lost

The losses are equally concrete, and they concentrate in the users who were best served before.

Ownership, in any durable sense. Stop paying and the software stops working, sometimes leaving files in a format nothing else reads. The relevant question is not whether you can access the program but whether you can access your work, and the answer depends on format portability rather than on licence terms.

Cost control over time. A perpetual licence had a ceiling. A subscription is a permanent line item whose price is set by the vendor annually, and heavy long-term users of stable tools now pay considerably more across a decade than they once did.

Version stability. Being able to keep a known-good version for years was valuable in exactly the places continuous updates are most disruptive: production pipelines, regulated environments, and any workflow depending on a plugin ecosystem that lags the host application.

Working offline without conditions. Most subscriptions tolerate periods offline and then require a check-in, which is fine until it is not.

The ability to decline a change. Under perpetual licensing, a redesign you disliked was a version you skipped. Under a subscription it is Tuesday.

Alternatives that survived

The market did not standardise completely, and the exceptions indicate where the model fits badly.

Some vendors sell a perpetual licence bundled with a fixed period of updates: you own what you have forever, and pay again only if you want newer versions. This suits software that is largely local, and it is the arrangement most users say they wanted when asked.

Open source occupies the space where continuity matters more than polish, and its position strengthened as a direct consequence of subscription fatigue, particularly in creative and technical tooling.

One-time purchases persist in games, in utilities small enough not to need infrastructure, and in professional niches where customers have enough leverage to refuse.

For a buyer, the practical test has shifted. The question is no longer perpetual or subscription in the abstract, but whether your work leaves in an open format when you stop paying, and whether you are renting genuine ongoing service or simply renting access to something that used to be yours. Those two cases look identical on a pricing page and are not remotely the same purchase.

Sources