The values age, the ratios do not
The exact numbers in any latency table age, as already stale. Disks got faster, storage interfaces changed, and network cards went from one to a hundred gigabits in a decade.
What barely moved are the ratios. Memory has been roughly a thousand times faster than durable storage for as long as most working engineers have been alive, and the network inside a data centre has stayed thousands of times slower than reaching into memory. Learn the ratios and your table updates itself.
Three of them do most of the work. Memory to disk is about a thousand to one, and that gap alone justifies caching, because one cache hit is worth a thousand disk reads. Solid state to spinning disk is about a hundred to one on random access, so databases moved to flash and spinning disks were demoted to backups.
The third is same data centre against another region, about two hundred to one. That gap is why you replicate data close to users instead of fetching it from far away.
The ladder in human time
Scaled to human time, the ratios stick. Let one nanosecond be one second. Your cache hit is now one second. A memory access is close to two minutes. A disk read takes about a day. A seek on a spinning disk takes four months. A round trip to Europe is roughly three years.
That picture matters when a service makes a synchronous cross-region call on the hot path. At human scale it has paused the conversation to sail across an ocean and back.
The payoff is that you can check a design without a reference sheet. If a proposal treats a disk read and a memory read as interchangeable, it is wrong by three zeros whatever this year's benchmarks say. The digits are trivia. The exponents are the engineering.
Worked example
In a design review at a fintech company, Lena's teammate proposes fetching a fraud-scoring feature vector from object storage on every transaction. Lena doesn't argue about vendor specifics. She writes two numbers on the whiteboard: process memory, 100 nanoseconds; a fetch to object storage, around 20 milliseconds with request overhead. That gap is five orders of magnitude, about 200,000 to 1. At their target of 2,000 transactions per second, 20 ms per fetch means 40 seconds of accumulated waiting per wall-clock second, so they'd need dozens of workers doing nothing but blocking on the network. The team moves the vectors into Redis, an in-memory cache, in the same data centre, where a read costs about half a millisecond, and preloads the hottest 20 percent into process memory. Same data, same code path, two rungs up the ladder.