Frontend System Design · Lesson 17 of 86 · 4 min
Cache Invalidation for Frontend Apps
This topic separates candidates who think about data freshness from those who only think about performance. Your answer shows you understand the trade-offs.
Caching is easy. Knowing when to throw that cached data away is hard. Without a clear invalidation strategy, your app will show stale data, leading to user confusion and bugs. In an interview, you need to articulate the different ways to invalidate a cache and choose the right one for a given scenario.
Choose Your Invalidation Strategy
You have three main strategies for deciding when cached data is no longer good. Each has a different trade-off between data freshness, implementation complexity, and performance.
Time-to-Live (TTL): You decide upfront how long data is "fresh." After the timer expires, the data is invalid. This is the simplest strategy. It's great for data that isn't critical or changes infrequently, like a list of blog posts or product categories. The downside is that you might serve stale data if it changes before the TTL expires.
Write-based Invalidation: The cache is invalidated when the data is changed. When a user updates their profile, you immediately invalidate the cached version of that profile. This provides strong consistency. The cost is that your write logic is now coupled with your cache logic.
Event-driven Invalidation: A backend service publishes an event when data changes. Your frontend subscribes to these events (e.g., via WebSockets) and invalidates its cache in response. This is powerful for real-time applications but requires more infrastructure.
A fourth strategy, manual invalidation, is user-initiated. Think "pull-to-refresh." It's a necessary fallback, but it shouldn't be your only strategy.
Implement Time-To-Live (TTL) on the Client
TTL is the most common strategy you'll implement directly on the client. The logic is straightforward: when you cache an item, you store a timestamp alongside it. On the next read, you check if the current time has passed the expiry timestamp.
This flow is a classic interview diagram.
Here is a minimal, framework-agnostic class for a client-side cache that implements this pattern.
type CacheEntry<T> = {
value: T;
expiry: number; // Unix timestamp
};
class ClientCache {
private cache = new Map<string, CacheEntry<any>>();
set<T>(key: string, value: T, ttlSeconds: number): void {
const expiry = Date.now() + ttlSeconds * 1000;
this.cache.set(key, { value, expiry });
}
get<T>(key: string): T | null {
const entry = this.cache.get(key);
if (!entry) {
return null;
}
// Check if the entry has expired
if (Date.now() > entry.expiry) {
this.cache.delete(key);
return null;
}
return entry.value as T;
}
invalidate(key: string): void {
this.cache.delete(key);
}
}
The trap: Picking the right TTL is a judgment call. Too long, and users see stale data. Too short, and you lose the performance benefit of caching. Your choice should be based on the data's volatility and the business requirements for freshness. For a user's avatar, 24 hours might be fine. For stock prices, it might be 1 second.
Handle Invalidation from the Backend
For data that must be fresh, TTL is not enough. The frontend must react to changes as they happen. This is where write-based and event-driven invalidation come in.
You don't implement these on the client; you respond to them.
After a mutation: When your app sends a POST, PUT, or DELETE request, it should proactively invalidate any related data in the cache. For example, after a user successfully updates their name, you must invalidate the user-profile cache key. Modern data-fetching libraries like TanStack Query or SWR have APIs like invalidateQueries to make this declarative.
Via push events: For real-time updates initiated by other users or the system, the server must push a notification. The client listens for these events over a WebSocket or Server-Sent Events (SSE) connection and calls its invalidation logic.
In an interview, when you design a system with real-time updates (like a chat app, a collaborative editor, or a live dashboard), you must mention a push-based mechanism for invalidation. Simply relying on TTL or user refresh is a red flag. The correct flow is: the backend sends an event, and the client listens and invalidates the specific cache key.
Invalidate a Key, Not the World
A common mistake is to be too aggressive with invalidation. A user updates their name, and you clear the entire application cache. This is lazy, inefficient, and negates much of the benefit of caching.
Your cache invalidation must be granular.
Design your cache keys to be specific. Instead of a single key for all products, use keys that reflect the query, like products?category=shoes&page=1. For entity-specific data, use a normalized key like user:123.
When a mutation occurs, your logic should be smart enough to invalidate only the affected keys. If a user updates their profile, invalidate user:123. If a product's price changes, you might invalidate the specific product key (product:abc) and any list queries that contained it. This requires more thought but results in a much more performant application.
Try it
Modify the ClientCache class to support a "stale-while-revalidate" strategy. When get is called on an expired key, it should return the stale data immediately but also accept a callback function to trigger a background re-fetch of the fresh data. This should take you about 20 minutes.
Next: Learn how these caching patterns fit into the overall architecture in Structuring a Large Single-Page App.
Lock it in — apply this lesson under interview conditions.