Caching

const cache = new Map();

async function getUser(id) {
  if (cache.has(id)) return cache.get(id);
  const user = await db.users.findById(id);
  cache.set(id, user);
  return user;
}

Common follow-ups: What's the risk of caching data that changes frequently, and how do you decide what's safe to cache?;What is cache invalidation, and why is it often called one of the two hardest problems in computer science?

// In-memory: fast, but each of N server instances has its own separate cache
const cache = new Map();

// Distributed: one shared cache across every instance
const redis = require('redis').createClient();
await redis.set(`user:${id}`, JSON.stringify(user), { EX: 3600 });
const cached = await redis.get(`user:${id}`);

Common follow-ups: What's a hybrid caching strategy that uses both layers together, and why might that be worth the added complexity?;How does Redis's own memory limit and eviction policy affect what you can safely rely on it for?

// Cache-aside pattern
async function getProduct(id) {
  let product = await redis.get(`product:${id}`);
  if (!product) {
    product = await db.products.findById(id);
    await redis.set(`product:${id}`, JSON.stringify(product), { EX: 600 });
  }
  return typeof product === 'string' ? JSON.parse(product) : product;
}

// Write-through: update cache and DB together on every write
async function updateProduct(id, data) {
  await db.products.update(id, data);
  await redis.set(`product:${id}`, JSON.stringify(data), { EX: 600 });
}

Common follow-ups: What is the 'thundering herd' problem with TTL-based caching, and how do you mitigate it?;How would you combine cache-aside with an explicit invalidation event to get both simplicity and freshness?

const inFlight = new Map();

async function getWithStampedeProtection(key, fetchFn) {
  if (inFlight.has(key)) return inFlight.get(key); // join the existing in-flight fetch
  const promise = fetchFn().finally(() => inFlight.delete(key));
  inFlight.set(key, promise);
  return promise;
}

Common follow-ups: How does 'stale-while-revalidate' differ from the in-flight deduplication approach, and could they be combined?;What's the risk of the in-flight deduplication approach if the single in-progress fetch itself hangs or fails?

app.get('/api/products', (req, res) => {
  res.set('Cache-Control', 'public, max-age=300');
  res.set('ETag', computeEtag(products));
  if (req.headers['if-none-match'] === computeEtag(products)) {
    return res.status(304).end();
  }
  res.json(products);
});

Common follow-ups: What's the difference between the 'public' and 'private' Cache-Control directives, and when should an API use 'private' or 'no-store' instead?;How does an ETag differ from a Last-Modified header for conditional requests?

const { LRUCache } = require('lru-cache');

const cache = new LRUCache({ max: 1000, ttl: 1000 * 60 * 10 });

cache.set('user:123', userData);
const cached = cache.get('user:123'); // moves this entry to 'most recently used'

Common follow-ups: How does LRU eviction compare to other eviction policies like LFU (Least Frequently Used)?;What's the time complexity of get() and set() operations in a properly implemented LRU cache, and why does that matter at scale?

await redis.set('session:abc123', sessionData, { EX: 3600 });

# redis.conf: only evict keys that have a TTL set, oldest-accessed first
# maxmemory-policy volatile-lru
# maxmemory 2gb

Common follow-ups: What's the difference between 'noeviction' and 'allkeys-lru' policies, and what happens to write operations once Redis hits maxmemory under 'noeviction'?;Why might mixing cache data and durable data in the same Redis instance be considered risky regardless of eviction policy?

function memoize(fn) {
  const cache = new Map();
  return (...args) => {
    const key = JSON.stringify(args);
    if (cache.has(key)) return cache.get(key);
    const result = fn(...args);
    cache.set(key, result);
    return result;
  };
}

Common follow-ups: Why is memoization only safe for pure, deterministic functions with no side effects?;What's the risk of memoizing a function whose input arguments are complex objects, given JSON.stringify-based key generation?

async function getWithSWR(key, fetchFn, ttl = 60000) {
  const cached = swrCache.get(key);
  if (cached) {
    if (Date.now() - cached.timestamp > ttl) {
      fetchFn().then(fresh => swrCache.set(key, { value: fresh, timestamp: Date.now() }));
    }
    return cached.value;
  }
  const fresh = await fetchFn();
  swrCache.set(key, { value: fresh, timestamp: Date.now() });
  return fresh;
}

Common follow-ups: What's the risk of this pattern for data where even brief staleness is unacceptable, like real-time account balances?;How does the HTTP Cache-Control 'stale-while-revalidate' directive implement this same idea at the HTTP layer?

async function updateUser(id, data) {
  await db.users.update(id, data);
  await redis.del(`user:${id}`);
}

async function getUser(id) {
  const cached = await redis.get(`user:${id}`);
  if (cached) return JSON.parse(cached);
  const user = await db.users.findById(id);
  await redis.set(`user:${id}`, JSON.stringify(user), { EX: 3600 });
  return user;
}

Common follow-ups: What happens if a cache invalidation call itself fails after the database write already succeeded?;How do you handle invalidating a cache key derived from multiple underlying records, like a cached list of a user's orders?