Subscriptions Definitely Didn’t Fix Software, They Just Hid the Inflated Cost
Subscriptions didn’t arrive because software suddenly became more expensive to build, they arrived because pricing something once requires honesty, and honesty is limiting, you have to decide what the thing is actually worth, you have to finish it, and you have to live with that number instead of renegotiating the relationship every month forever. Sound familiar? When subscriptions became normalized, they were framed as sustainability, as if the old model had somehow failed, as if charging once for a finished tool was naïve or irresponsible, but what really changed wasn’t the cost of development, it was the desire to smooth revenue and remove the ceiling on what a product could extract over time; a way to make people pay the costs of company upkeep.
A subscription doesn’t tell you what something costs, it tells you what it costs to keep it, which is a very different proposition; the total price becomes abstract, spread thin enough that it no longer triggers the same resistance, five dollars a month doesn’t feel like much until you realize you’ve paid sixty dollars a year for something that hasn’t meaningfully improved since you installed it. This abstraction is not accidental, subscriptions work precisely because they decouple value from payment, you stop asking whether the tool is worth the money and start asking whether canceling is worth the effort, and once that shift happens, pricing stops being about fairness and starts being about inertia.
What subscriptions really did was remove the pressure to finish software, because when revenue depends on continuity rather than completion, there’s no incentive for the product to ever settle, features must keep shipping not because they’re needed but because motion itself becomes the justification, and so tools that were once simple inflate into platforms, settings multiply, interfaces grow heavier, and the original problem the software was meant to solve becomes harder to find. This inflation is often framed as progress, but if you look closely, much of it exists to support the subscription itself, account systems, entitlement checks, analytics layers, feature flags, upsell prompts, renewal notices, retention nudges, all of which add weight without adding reliability, and all of which would be unnecessary if the product were allowed to remain finished.
Subscriptions also quietly invert the power relationship between the user and the software, when you own a tool outright, updates are something you choose, when you rent it, updates are something that happen to you, sometimes improving things, sometimes removing features, sometimes changing terms, and often doing all of that without giving you a meaningful choice beyond canceling and losing access entirely. This is why subscription software tends to feel unstable over time, not because engineers are careless, but because the product is constantly being optimized for revenue rather than use, decisions are made to maximize lifetime value, not clarity, and the result is software that never quite settles into a dependable shape.
The most telling sign is how often subscription tools talk to you when you’re not using them, reminder emails, notifications, renewal warnings, feature announcements, surveys, all designed to keep the relationship active, because silence is dangerous when revenue depends on attention, and a tool that quietly works and then disappears offers no leverage. What gets lost in all of this is the idea that some problems do not benefit from ongoing monetization, a calculator does not become more valuable because it updates monthly, a mute button does not improve because it checks in with a server, a barcode scanner does not need a roadmap once it scans reliably and exports clean data, yet these tools are increasingly packaged as services because services can be billed indefinitely.
At M Media Software Lab, we’re skeptical of that framing, not because subscriptions are inherently wrong, but because they are often used to justify inflated cost rather than genuine ongoing value, when a tool is simple, local, and reliable, charging once aligns incentives, you get paid to build it correctly, and the user gets a tool that doesn’t need to negotiate its existence every month.
Choosing not to use subscriptions is not a moral stance, it’s a design constraint, it forces clarity about what the software is and what it is not, it forces restraint, and it forces the uncomfortable question of whether a feature actually improves the tool or just makes it easier to keep charging for it. Look, subscriptions didn’t fix software, they just made the bill harder to see, and once you notice that, it becomes difficult to ignore how many tools are no longer trying to solve problems so much as justify their own continued rent. That’s not the kind of software we want to build, and it’s not the kind we want to depend on.