Running a node gets harder over time, and the reason is not the size of the transaction history. It is the state: the current balances, contracts and storage that every node must keep available.
History and state are different burdens
History is the record of what happened, and it can be stored slowly and cheaply because it is read rarely.
State is what is true right now, and every transaction must be checked against it, so it needs to be held where it can be accessed quickly.
A node can discard old history and still validate new blocks. It cannot discard state, because the next transaction may touch any part of it.
State accumulates without a natural release
Every new account, token balance and contract storage slot adds an entry that persists until something explicitly removes it.
Nothing forces removal. Abandoned contracts, dust balances and expired applications remain because no one pays to clear them and no rule deletes them.
Fees are charged when data is written, once, while the cost of holding it is borne by every node forever afterwards. That mismatch is the root of the problem.
Access speed degrades as the tree grows
State is usually kept in a cryptographic tree so a compact commitment can summarise it, and reading or updating a leaf requires touching the path above it.
As the tree grows, those paths lengthen and the data stops fitting in memory, so each access becomes a disk operation instead of a cached lookup.
Block validation then becomes bound by storage performance rather than by computation, which is why node requirements often specify fast solid-state drives rather than fast processors.
The consequence is fewer independent verifiers
When running a node needs expensive hardware, fewer people do it, and more users rely on providers who run nodes on their behalf.
That reliance is a quiet centralising pressure, because the ability to check the chain yourself is what makes the guarantees meaningful rather than trusted.
Keeping verification affordable is therefore treated as a security property, not a convenience, in networks that value broad participation.
Proposed remedies change the cost structure
One direction is expiry, where state untouched for a long period is removed from the active set and can be restored later by supplying a proof.
Another is stateless validation, where blocks carry witnesses proving the state they touch, so a validator can verify without holding everything.
A third is rent, charging for storage over time rather than once at writing. All three are hard to introduce into a live system because they change assumptions that existing contracts were built on.