Course contentsShow
← Software Engineering
Lesson 982 of 1,93330. Caching StrategiesFree lesson

Dealing with Stale Data

Strategies for tolerating and detecting staleness, including versioning and validation.

Dealing with Stale Data

You'll learn how to tolerate, detect, and handle outdated cached information without breaking your application.

Even with perfect invalidation strategies, caches eventually serve stale data—information that's changed in the source but hasn't been updated yet. The challenge isn't eliminating staleness entirely (often impossible), but managing it gracefully.

Understanding Staleness Tolerance

First, determine your staleness tolerance: how old can data be before it causes real problems? A product price updated 30 seconds late might be acceptable; a bank balance being wrong for 30 seconds probably isn't. This tolerance shapes your entire caching strategy.

Think of it like a newspaper: yesterday's weather forecast is stale but harmless for the crossword puzzle, but stale for planning today's picnic.

Versioning and Validation

Versioning embeds version numbers or timestamps with cached data. When reading, you can check if the cached version matches expectations:

cached_user = cache.get("user:123")  # returns {id: 123, name: "Alice", version: 47}
current_version = db.get_version("user:123")  # returns 48

if cached_user.version != current_version:
    # Stale detected, fetch fresh data

Validation tokens (like ETags in HTTP) work similarly—store a hash or checksum with the data. Before using cached data for critical operations, validate it against the source's current token.

Strategies for Living with Staleness

Timeboxing: Accept data within a known time window. If TTL is 60 seconds, you know data is at most 60 seconds old.

Critical-path freshness: Cache aggressively for reads, but always read-through for writes or transactions to avoid acting on stale state.

Graceful degradation: Display cached data with indicators ("Updated 2 minutes ago") so users understand potential staleness.

Key Takeaway: Stale data is inevitable in caching—design systems that detect it when it matters, tolerate it when it doesn't, and communicate its limitations clearly to users and dependent systems.