Cache Invalidation: Connect Data Changes to Stale Views

Cache invalidation is the process of marking cached data as outdated when the underlying source data changes, ensuring that views served from the cache reflect the latest information. It connects data changes to the views they make stale by tracking dependencies between cached responses and the data they depend on, then removing or updating those responses when the data changes. This article explains how that connection works, the common strategies, and the trade-offs involved.

Formula

The calculator above estimates cache performance metrics based on three inputs:

• Cache TTL (t) – the time-to-live in seconds, i.e., how long a cached response is considered fresh before it must be revalidated.
• Request rate (r) – the average number of requests per second hitting the cache.
• Cache hit ratio (p) – the fraction of requests served directly from the cache without contacting the origin (0 to 1).

The outputs are:

• Cache hits per second = r × p
• Cache misses per second = r × (1 − p)
• Responses served from cache per day = r × p × 86400

All inputs are pure numbers; the TTL is not used in the formulas because it affects the hit ratio indirectly (a longer TTL usually increases the hit ratio, but the relationship depends on the workload). The calculator simply shows the arithmetic relationship between the rate, hit ratio, and daily cache savings.

Worked Example

Using the default values: request rate = 100 req/s, hit ratio = 0.8, TTL = 300 s.

1. Cache hits per second = 100 × 0.8 = 80 req/s
2. Cache misses per second = 100 × (1 − 0.8) = 20 req/s
3. Responses served from cache per day = 100 × 0.8 × 86400 = 6,912,000 responses

So with an 80% hit ratio, the cache saves about 6.9 million origin requests per day. This illustrates why cache invalidation matters: even a small drop in hit ratio (e.g., from 0.8 to 0.7) reduces daily savings by about 864,000 responses, increasing load on the origin.

Background: Why Cache Invalidation Is Hard

Caches are used everywhere—web browsers, CDNs, database query caches, and in-memory stores like Redis—to reduce latency and server load. The core idea is to store a copy of a computed result and reuse it for subsequent requests. The problem is that the underlying data can change. If the cache is not invalidated, users see stale data. If it is invalidated too aggressively, the cache becomes useless. The challenge is to know exactly which cached entries are affected by a data change and to remove or update them quickly and correctly.

The phrase “cache invalidation is one of the two hard things in computer science” (the other being naming things) reflects the difficulty of tracking dependencies in complex systems. In a simple case, a cache key might be the URL of a page. When the page content changes, you can purge that URL. But real applications have many-to-many relationships: a single database record (e.g., a product price) can appear on many pages (product listing, search results, category pages). A single page can depend on many records (a dashboard with multiple widgets). Without a systematic way to track these dependencies, invalidation becomes error-prone.

How Cache Invalidation Works

There are several mechanisms to connect data changes to stale views:

• Time-based (TTL): Each cached entry has an expiry time. After the TTL, the entry is considered stale and is re-fetched. This is simple but can serve stale data for up to the TTL duration.
• Write-through invalidation: When a data update occurs, the application explicitly deletes or updates all cache entries that depend on that data. This requires a dependency map: for each data item, a list of cache keys that use it.
• Event-driven invalidation: The database or application emits events (e.g., “product updated”) and a listener subscribes to those events and purges relevant cache keys. This is a more decoupled version of write-through.
• Versioning: Cache keys include a version number or timestamp. When data changes, the version is incremented, and new requests use the new version, effectively bypassing old entries.
• Tag-based invalidation: Cache entries are tagged with identifiers (e.g., “product:123”, “category:electronics”). When a product changes, all entries with that tag are invalidated. This is a practical implementation of dependency tracking.

In practice, many systems combine these. For example, a CDN may use TTL for static assets, but an API gateway may use tag-based invalidation for dynamic responses. The key is to know the granularity of invalidation: too coarse (e.g., purge everything) is wasteful; too fine (e.g., each field) is hard to manage.

Common Strategies and How to Choose

Choosing an invalidation strategy depends on the data’s volatility, the cost of serving stale data, and the complexity you can afford.

• High volatility, low staleness tolerance: Use write-through or event-driven invalidation with tags. For example, a stock price ticker must be updated immediately; a TTL of even a few seconds might be unacceptable.
• Low volatility, high staleness tolerance: TTL is sufficient and simplest. For example, a blog post’s metadata (author, title) rarely changes; a 5-minute TTL is fine.
• Medium volatility: A hybrid: use a short TTL (e.g., 60 seconds) plus event-driven invalidation for critical updates. This protects against missed events.

Another consideration is the cost of invalidation itself. If you purge a cache entry that is never requested again, you waste the purge operation. If you fail to purge an entry that is requested, you serve stale data. The goal is to minimize the total cost: (stale data cost × probability of staleness) + (purge cost × number of purges).

Common Problems and Misconceptions

One common misconception is that a shorter TTL always means fresher data. In reality, a short TTL increases the load on the origin and can cause a “thundering herd” when many requests miss the cache simultaneously. A better approach is to use a “stale-while-revalidate” pattern: serve the stale cached response while asynchronously fetching a fresh one. This gives near-instant responses and eventual freshness.

Another problem is the “cache stampede” or “dog-pile” effect: when a popular cache entry expires, many concurrent requests all miss and hit the origin. Solutions include request coalescing (only one request fetches, others wait) and probabilistic early expiration (expire earlier if the request rate is high).

Another issue is that invalidation events can be lost or delayed. If the database update succeeds but the event fails to publish, the cache remains stale. To mitigate, use a “reconciliation” job that periodically compares cached data with the source, or use a “version” that is checked on each read.

Comparisons: TTL vs. Event-Driven vs. Tag-Based

Here’s a quick comparison:

• TTL: Simple, no dependency tracking, but can serve stale data and can cause stampedes. Best for static or slowly changing data.
• Event-driven: Immediate invalidation, but requires reliable event delivery and a subscriber. Best for dynamic data with clear change events.
• Tag-based: Flexible granularity, but requires maintaining a tag index. Best when a single change affects many views (e.g., a product price affects multiple pages).

In practice, tag-based is often implemented on top of event-driven: the event handler knows which tags to invalidate. For example, when a product price changes, the event handler invalidates all cache entries with tag “product:123” and “category:electronics”.

Costs and Trade-offs

Cache invalidation has costs:

• Development complexity: Implementing dependency tracking and event handling takes time and can introduce bugs.
• Infrastructure overhead: Storing tags and indexes consumes memory. Event brokers add a moving part.
• Operational risk: If invalidation fails, stale data persists. Monitoring and reconciliation are needed.

On the other hand, the benefit is reduced origin load and lower latency. The calculator above shows how many requests a cache can absorb; the savings can be substantial. For a high-traffic site, even a 1% increase in hit ratio can save thousands of origin requests per day.

Safety and Best Practices

To avoid common pitfalls:

• Always set a maximum TTL as a safety net, even if you use event-driven invalidation. This guards against missed events.
• Use “stale-while-revalidate” to avoid stampedes and provide fast responses.
• Test invalidation thoroughly: simulate data changes and verify that all affected views are updated.
• Monitor cache hit ratio and staleness. A sudden drop in hit ratio may indicate an invalidation bug.

Frequently Asked Questions

What is the difference between cache invalidation and cache eviction?

Cache invalidation is the act of marking an entry as stale or removing it because the underlying data changed. Cache eviction is removing an entry to free up space, typically using an algorithm like LRU (Least Recently Used). Invalidation is about correctness; eviction is about capacity.

How do I invalidate a cache when I don’t know which views depend on the data?

You can use a broad invalidation (purge all) or a versioned cache key. A simpler approach is to use a short TTL so stale data doesn’t persist long. For a more systematic solution, you need to build a dependency map—either manually or by using tags.

Is it better to invalidate or update the cache in place?

Updating in place can be more efficient if the new value is already computed, but it requires locking to avoid race conditions. Invalidation is simpler: you just delete the entry, and the next request fetches fresh data. Invalidation is generally preferred because it avoids the complexity of atomic updates.

What is “cache stampede” and how do I prevent it?

A cache stampede happens when many requests miss at the same time and all hit the origin. To prevent it, use request coalescing (only one request fetches, others wait), or serve a stale response while revalidating in the background.

Can I use TTL alone for a dynamic website?

Yes, but you risk serving stale data for up to the TTL. For a site where data changes frequently and users expect freshness, TTL alone is usually insufficient. Combine it with event-driven invalidation for critical data.

Related

• RAM for Business Desktops: How Much You Need
• Samsung Washer Leak: Check by Timing & Location
• Why Does Google Track My Location? Real Reasons

in t | Cache TTL (seconds) | s | 300 | 1 | 86400
in r | Request rate (per second) | req/s | 100 | 1 | 1000000
in p | Cache hit ratio | 0-1 | 0.8 | 0 | 1
out hits | Cache hits per second | req/s | r * p | 2
out misses | Cache misses per second | req/s | r * (1 - p) | 2
out savings | Responses served from cache per day | - | r * p * 86400 | 0