Caching and Redis

Why cache at all

Some answers are slow or costly to make: a database query that joins five tables, a call to another company's API, a page that needs a lot of work to build. If thousands of people ask the same question every minute, doing that work every time wastes time and money.

A cache is a place that keeps a ready copy of an answer for a short time. A cache hit means the answer was found in the cache. A cache miss means it was not, so the app does the slow work and usually saves the answer for next time.

Where caches live

Cache-aside, step by step

1. A request asks for product 42.
2. The app builds a key, like product:42, and looks in the cache.
3. Hit: return the cached copy. Done, and the database was not touched.
4. Miss: read product 42 from the database.
5. Save it in the cache with a TTL, for example 5 minutes.
6. Return it. The next request within 5 minutes will be a hit.
7. When the product changes, delete its cache key so the next read gets fresh data.

async function getProduct(id) {
  const key = 'product:' + id;
  const cached = await redis.get(key);              // look in the cache
  if (cached) return JSON.parse(cached);            // hit
  const product = await db.findProduct(id);         // miss: ask the database
  await redis.set(key, JSON.stringify(product), { EX: 300 }); // keep for 300 seconds
  return product;
}

async function updatePrice(id, price) {
  await db.updatePrice(id, price);
  await redis.del('product:' + id);                 // invalidate the old copy
}

TTL and invalidation

TTL means time to live: how long a cached value may be used before it expires and is thrown away. A short TTL (seconds) keeps data fresh but gives fewer hits. A long TTL (hours) gives many hits but data can be old.

Invalidation means removing or updating a cached value when the real data changes. The simple, reliable way is: write to the database first, then delete the cache key. The next read will load fresh data. There is a famous saying among programmers that cache invalidation is one of the hardest problems, because it is easy to forget one place that changes the data.

Redis in a few lines

Redis is an in-memory key-value store. In-memory means it keeps data in RAM, so reads take well under a millisecond. Key-value means you save a value under a name (the key) and get it back by that name. It also has counters, lists, sets and expiry built in. Valkey is an open-source fork of Redis (a copy that continues as its own project) with the same commands.

127.0.0.1:6379> SET product:42 "Atta 5kg, Rs 260" EX 300
OK
127.0.0.1:6379> GET product:42
"Atta 5kg, Rs 260"
127.0.0.1:6379> TTL product:42
(integer) 297
127.0.0.1:6379> INCR visits:home
(integer) 1
127.0.0.1:6379> DEL product:42
(integer) 1

HTTP caching is the same idea between your server and browsers or CDNs. The Cache-Control response header says who may keep a copy and for how long, for example Cache-Control: public, max-age=86400 for a logo, or Cache-Control: no-store for a bank statement. An ETag header is a version tag: the browser asks "has it changed since this tag?" and the server can answer 304 Not Modified with no body.