A device that felt fast when new often feels sluggish after a few years without any hardware change. The applications changed, and the pattern is consistent enough to be structural.
Features are added, rarely removed
Every release cycle adds capability, because adding is visible and removing annoys whoever used the removed thing.
The accumulated weight shows up as more code loaded at startup, more background activity and more memory held for features a given user never opens.
Nothing in the process pushes back, since no team is measured on making the application smaller than it was last year. Deletion carries risk and produces no visible improvement, so it loses to almost any competing priority.
Development happens on fast machines
Engineers typically work on high-specification hardware with fast networks, where a performance regression is imperceptible.
A delay that is negligible on a development machine can be several times longer on an older device with slower storage and less memory.
Without deliberate testing on representative hardware, regressions accumulate quietly and are only discovered through user complaints months later.
Abstraction layers stack up
Shared frameworks make development faster and more consistent, and each one adds indirection between the application's intent and the hardware executing it.
Cross-platform toolkits multiply this, since the application talks to a compatibility layer that talks to the system, rather than to the system directly.
The cost per layer is small and the total is not, particularly for startup time and memory use where the overhead is paid before any work begins.
Network dependence replaces local work
Functions that once ran locally increasingly involve a server, for synchronisation, personalisation or analytics.
Each of those introduces a wait that depends on connection quality, and an interface that responds instantly on a good connection can stall entirely on a poor one.
Applications that treat the network as optional and fall back to local behaviour remain usable in conditions where others simply stop.
The operating system grows too
System updates add features and security measures that consume memory and processing time, and older devices receive those updates for years.
Additional integrity checking and sandboxing genuinely cost performance, and they are the correct trade even though the user experiences only the slowdown.
Between a growing operating system and growing applications, hardware that was comfortable at purchase ends up serving a considerably heavier load.
Storage plays a part as well, since flash memory slows as it fills and as cells accumulate write cycles, which affects every operation that touches disk.