Cache Invalidation

The most fundamental invalidation strategy where cached objects are assigned a finite lifespan. Once the TTL expires, the object is considered stale and is either lazily evicted upon the next request or actively purged by a background process.

• Absolute TTL: Expires at a specific wall-clock time (e.g., midnight UTC).
• Sliding TTL: Expires after a period of inactivity, keeping hot data in cache.
• Trade-off: Short TTLs ensure freshness but increase origin load; long TTLs risk serving stale data.

An event-driven approach where an application explicitly sends a command to the caching layer to remove a specific object or set of objects immediately after the source data mutates. This is the most precise method for ensuring strong consistency.

• Single-Key Purge: Removes one specific URL or cache key.
• Surrogate-Key Purge: Tags multiple cached objects with a shared key, allowing a single API call to purge an entire collection (e.g., all pages related to a specific product).
• Banning: Creates a filter rule that prevents stale objects from being served, removing them lazily.

These caching strategies define when the source of truth is updated relative to the cache, directly impacting invalidation logic.

• Write-Through: Data is written to the cache and the origin database synchronously. The cache is always current, eliminating the need for immediate invalidation but increasing write latency.
• Write-Behind (Write-Back): Data is written to the cache first, and asynchronously flushed to the database later. This is fast but risky; if the cache fails before flushing, data is lost. Invalidation is complex because the cache temporarily is the source of truth.

In distributed, multi-node cache clusters, maintaining coherence—ensuring all nodes agree on the state of data—is the hard problem of invalidation. Protocols prevent a user from seeing stale data from one node after a purge on another.

• Invalidation Broadcasting: A purge command is fanned out to all cache nodes immediately.
• Directory-Based Coherence: A central tracker monitors which nodes hold copies of an object, sending targeted invalidations only to those nodes to reduce network chatter.

A pragmatic HTTP caching extension (stale-while-revalidate) that prioritizes availability and latency over strict consistency. When a cached object expires, the cache immediately serves the stale version to the user while asynchronously fetching a fresh copy from the origin in the background.

• Benefit: Eliminates the 'cache miss' latency penalty for the end-user.
• Risk: The user receives a potentially outdated version for that single request. This is acceptable for non-critical assets like images or social media feeds.

A modern, decoupled architecture where database changes (via Change Data Capture or application events) are streamed through a message broker (like Kafka) to a specialized invalidation service. This service translates data mutations into precise cache purge commands.

• Decoupling: The application logic never touches the cache API directly.
• Resilience: If the invalidation service fails, events are stored in the log for replay, ensuring eventual consistency.
• Complexity: Requires robust stream processing infrastructure.

A software architecture pattern where decoupled services communicate by producing and consuming events, enabling asynchronous, real-time content updates. In the context of cache invalidation, a content change event emitted by a CMS can trigger a purge workflow across multiple layers—CDN, application cache, and database query cache—without tight coupling between the content source and the caching infrastructure.