Introduction to Caching Strategies

In this tutorial, you will learn about Introduction to Caching Strategies. We cover key concepts, practical examples, and best practices to help you master this topic.

Caching stores frequently accessed data in a fast, temporary storage layer so future requests can be served without recomputing or fetching from the primary data source. This reduces latency, decreases database load, and improves overall system throughput, making it a critical component of scalable backend design.

What You'll Learn

• The core concepts and benefits of caching
• Different caching layers (client, server, CDN, database)
• Trade-offs between consistency, availability, and performance

Why It Matters

A well-designed caching strategy can cut response times from hundreds of milliseconds to under a millisecond. Without caching, every user request hits the database, causing bottlenecks as traffic grows and degrading the experience under load.

Real-World Use

E-commerce platforms cache product catalog pages so thousands of users can browse simultaneously without overwhelming inventory databases. Social media feeds are cached per-user to serve content instantly on scroll. APIs return cached responses for popular endpoints, reducing origin server load by 80% or more.

flowchart LR
    A[Client Request] --> B{Cache Hit?}
    B -->|Yes| C[Return Cached Response]
    B -->|No| D[Origin Server]
    D --> E[Fetch Data]
    E --> F[Store in Cache]
    F --> G[Return Response]
    G --> A

Teacher Mindset

Think of caching like a whiteboard. You jot down frequently used phone numbers instead of looking them up in a directory every time. The whiteboard is fast but has limited space; the directory is authoritative but slow. Your job is deciding what lives on the whiteboard and when to erase outdated entries.

Working with Caching in Code

Simple In-Memory Cache

const cache = new Map();

function getFromCache(key) {
  return cache.get(key);
}

function setCache(key, value, ttlMs = 60000) {
  cache.set(key, { value, expires: Date.now() + ttlMs });
  setTimeout(() => cache.delete(key), ttlMs);
}

Expected output:

Value stored in cache for 60000ms.

Cache-Aside Pattern with Redis

const redis = require('redis');
const client = redis.createClient();

async function getUser(id) {
  const cached = await client.get(`user:${id}`);
  if (cached) return JSON.parse(cached);
  const user = await db.findUser(id);
  await client.setEx(`user:${id}`, 3600, JSON.stringify(user));
  return user;
}

Expected output:

First call: fetches from DB, caches result. Subsequent calls: returns cached data until TTL expires.

Setting Cache Headers in Express

app.get('/api/products', (req, res) => {
  res.set('Cache-Control', 'public, max-age=300');
  res.set('ETag', `"${productVersion}"`);
  res.json(products);
});

Expected output:

Response includes Cache-Control and ETag headers instructing browsers and CDNs to cache for 5 minutes.

Common Mistakes

• Caching dynamic or user-specific data without proper invalidation, serving stale information.
• Using a single cache key strategy that leads to thundering herd problems on expiry.
• Ignoring cache failure modes — when Redis goes down, requests should fall through to the database.
• Setting TTLs too long for frequently changing data, causing data staleness.
• Caching large objects without compression, wasting memory and network bandwidth.

Practice Questions

1. What is the difference between a cache hit and a cache miss?
2. Why is TTL (time-to-live) important in caching?
3. Name three places where caching can occur in a web application stack.
4. How does cache invalidation differ from cache eviction?
5. What is the thundering herd problem in caching?

Challenge

Design a cache strategy for a news website where articles are updated infrequently but comments update in real-time. Describe what you would cache, for how long, and how you would handle invalidation.

FAQ

Mini Project

Build a simple Node.js REST API for a blog with an in-memory cache layer. Implement cache-aside pattern for GET /posts/:id with a 60-second TTL. Add a POST /posts/:id/invalidate endpoint that removes the cached entry. Test by fetching, observing the cache miss on first call, cache hit on second, and cache refresh after invalidation.

What's Next

Now that you understand caching fundamentals, continue to Cache Basics to explore caching layers and policies in detail.