The popular story about device slowdowns goes like this: Apple secretly throttles old iPhones to force upgrades, gets caught, pays a fine, and the scandal fades. Case closed. What the story misses is that the throttling scandal was almost a distraction. The real mechanism for pushing consumers toward new hardware is subtler, more defensible in court, and considerably more effective.
Tech companies do deliberately accelerate the obsolescence of old devices. But the method is rarely a crude speed governor. It is a coordinated pressure system built from software bloat, security deprecation, and ecosystem fragmentation, each element individually justifiable, collectively designed to make keeping your current device feel untenable.
The Software Weight Gain Is Not Accidental
Every major operating system update ships with features optimized for the current generation of hardware. This is, in isolation, a reasonable engineering choice. The problem is that these updates are then pushed to devices that predate the hardware optimizations by several years, with no meaningful option to decline.
Apple’s iOS updates have consistently increased the memory and processing demands placed on older iPhone models. The company’s own benchmarks show newer chip generations delivering substantial performance gains, yet the software layer is designed to consume proportionally more of whatever resources are available. The experience on a two-year-old phone running the latest iOS degrades noticeably, not because the hardware failed, but because the software’s appetite grew to match newer hardware that the user does not yet own.
This is not incompetence. These are companies with some of the most sophisticated performance engineering teams in the world. A team capable of squeezing every millisecond out of a new chip launch is also capable of maintaining a leaner software branch for older hardware. The decision not to do so is a product decision, not a technical limitation.
Security Deprecation Is the Polite Version of a Forced Upgrade
The cleaner version of device obsolescence happens through security support windows. When a manufacturer ends security updates for a device, they are not disabling it. They are simply ensuring that every month that passes makes it incrementally more dangerous to keep using.
This is the mechanism Microsoft is deploying against Windows 10. The operating system will lose security support in October 2025, at which point the hundreds of millions of PCs running it will not stop working. They will simply become progressively less safe to use for anyone serious about security. Microsoft is not hiding what it wants to happen next.
The security argument is not entirely cynical. Real vulnerabilities do accumulate in unsupported software. But the decision about when to end support, and how narrowly to draw the hardware compatibility cutoff, is a business calculation as much as a security one.
Ecosystem Lock-In Amplifies the Pressure
The third layer is the most sophisticated. Even if your hardware runs the latest software acceptably, and even if security updates continue, newer devices interoperate with the rest of the ecosystem in ways older ones cannot.
Apple’s Continuity features, which let you hand off tasks between iPhone, iPad, and Mac, require specific chip generations. AirDrop improvements, precision finding in the Find My network, and various spatial audio capabilities are gated behind hardware that is, by design, unavailable to older devices. The older phone is not broken. It is simply progressively excluded from the network effects that make the ecosystem valuable.
This is the upgrade mechanism that is hardest to legislate against, because it is technically honest. The feature genuinely requires the newer hardware. The fact that the ecosystem was designed to generate exactly this kind of exclusion pressure is not visible in any single product decision.
The Counterargument
The most credible defense of these practices is that software complexity genuinely does grow, and that the alternative, frozen software that never adds features to preserve compatibility with aging hardware, would also harm consumers. There is real substance to this. The computational demands of modern encryption standards, the machine learning models running on-device for photography and voice recognition, the network protocols that make wireless connectivity faster: these legitimately require more capable hardware over time.
The throttling case Apple settled is actually the clearest example of something more defensible than it initially appeared. Apple did slow older iPhones, but the stated reason, managing degraded batteries to prevent unexpected shutdowns, was real. The failure was in transparency, not entirely in motive.
But this defense has limits. It explains incremental performance demands. It does not explain why the software branch for older hardware cannot be maintained with fewer features and lighter weight. It does not explain why security support windows are set where they are, rather than longer. The engineering argument covers the honest part of the practice; it does not cover the parts that are straightforwardly designed to convert user frustration into upgrade revenue.
The Verdict
Planned obsolescence in consumer tech is real, but it operates through systems that are individually defensible and collectively corrosive. No single decision looks like a conspiracy. The software team needed new features. The security team set a support window. The hardware team built capabilities into the new chip. The result, users who feel increasing pressure to upgrade hardware that physically still works, is not accidental.
The honest position is this: the companies building these systems know what they are building. They have the engineering talent and the data to design for longer device lifespans if that were the priority. It is not the priority, because obsolescence by design has straightforward economics. Until regulators treat support-window decisions and ecosystem compatibility gates with the same scrutiny they give price-fixing, the pressure will keep building, one update at a time.
