Application caches: cache-aside, TTLs and invalidation

What it is

Cache-aside (lazy loading): the application looks up a key in the cache; on a miss it reads the source of truth, stores the value with a time-to-live, and returns it. Writes go to the source and either delete the cache entry (invalidate) or overwrite it (write-through). The cache holds derived data and may be lost at any time.

Why it matters

Caches remove load and latency, but a stale entry served after a write is a correctness bug that is hard to reproduce. The invalidation strategy is a design decision, not an afterthought.

How to apply

• Decide the acceptable staleness per data class and set TTLs accordingly; a short TTL is a simple bound on damage.
• On write, delete the affected keys rather than updating them; deletion is idempotent and avoids races between concurrent writers.
• Include a version or schema tag in the key (user:v3:123) so that deploys that change the value shape do not read old entries.
• Protect against stampedes: on a miss for a hot key, let one request fill the cache while others wait briefly or serve slightly stale data.
• Cache negative results ("not found") with a short TTL if lookups for missing keys are common.
• Measure hit ratio and the source load; a cache that is never hit costs latency on every miss.

Pitfalls

Caching per-user data under a shared key. Invalidation that misses derived keys (lists, counts) when a single object changes. Treating the cache as durable storage. Clock skew between TTL-setting and TTL-checking hosts.

The delete-then-populate race

Delete-on-write is not race-free: a reader can load the old value from the source just before a write commits, and store it in the cache after the writer's delete, leaving stale data until expiry. Bound the damage with short TTLs, or avoid the race by versioning keys (a per-object version that changes on every write and is part of the key), or by deleting again after a short delay.