How is Redis used as a cache?

Question

Accepted Answer

**Caching** is Redis's most common use case — storing frequently-accessed data in fast memory so applications avoid slower operations (database queries, API calls, computations). Understanding the basic caching pattern is essential everyday knowledge.

## The cache-aside pattern (most common)

```text
1. App needs data → CHECK Redis first (cache lookup)
2. CACHE HIT (found) → return it immediately (fast!) ✓
3. CACHE MISS (not found) → query the database, store the result in Redis (with TTL),
   then return it. Next time it'll be a hit.
```

```js
async function getUser(id) {
  const cached = await redis.get(`user:${id}`);
  if (cached) return JSON.parse(cached);          // CACHE HIT — fast, skip the DB

const user = await db.users.findById(id);        // CACHE MISS — query the DB
  await redis.set(`user:${id}`, JSON.stringify(user), "EX", 3600);  // cache it (1h TTL)
  return user;
}
```

The app checks Redis first; on a miss, it fetches from the source, caches the result (with a TTL), and returns it. Subsequent requests are fast cache hits.

## Why caching helps

```text
✓ SPEED — Redis (in-memory) is far faster than a database (disk) or external API
✓ REDUCED LOAD — fewer queries hit the database (it handles less, scales better)
✓ Result: faster responses, lower database load, better scalability
→ Caching is one of the most effective ways to improve application performance.
```

## Cache invalidation (the hard part)

```js
// when data changes, the cache must be updated or removed (else it's STALE)
async function updateUser(id, data) {
  await db.users.update(id, data);
  await redis.del(`user:${id}`);    // INVALIDATE the cache (next read re-fetches fresh)
}
```

```text
Stale data is the main caching challenge:
  → Use TTLs (data auto-expires, eventually refreshing)
  → Invalidate (delete/update the cache) when the source data changes
  → "There are only two hard things: cache invalidation and naming things."
```

## Why it matters

Using Redis as a cache is its most common and impactful application, so understanding the basic caching pattern is essential, broadly-applicable knowledge for building performant applications.

The core technique — storing frequently-accessed data in Redis's fast memory so the application avoids slower operations (database queries, API calls, expensive computations) — is one of the most effective ways to improve performance and scalability, used in a vast number of production systems.

Understanding the **cache-aside pattern** (check Redis first; on a hit return immediately; on a miss fetch from the source, cache the result with a TTL, and return it) is the foundational caching technique every developer should know — it's how most caching is implemented.

Understanding **why caching helps** (in-memory Redis is far faster than disk-based databases or external APIs, and caching reduces load on the database so it scales better) explains the dual benefit of speed and reduced backend load.

Critically, understanding **cache invalidation** — the famous "hard problem" of keeping cached data from becoming stale, addressed by TTLs (auto-expiry) and explicit invalidation (deleting/updating the cache when source data changes) — is essential because stale data is the main caching pitfall, and managing it correctly is what separates working caches from subtly buggy ones.

Since caching is the dominant Redis use case and one of the most important performance techniques in software, and since the cache-aside pattern (with proper invalidation) is the fundamental way it's done, understanding how Redis is used as a cache — the pattern, its benefits, and the invalidation challenge — is essential, frequently-applied knowledge for building fast, scalable applications, arguably the single most important practical Redis skill.