Day 3: Backend Performance – Fine-Tuning Caching with HTTP Headers

As we continue exploring ways to improve backend performance, today I want to talk about something that can make a huge difference in how efficiently we handle data: HTTP Cache Headers.

Caching isn’t just about saving space – it’s about making sure we’re delivering the right data to users as quickly as possible. And the Cache-Control header is a powerful tool to help us do this.

?? What Are HTTP Cache Headers?

HTTP Cache headers help you control how and when your resources (like images, API responses, etc.) are cached by the client or any intermediate caches. This means you can avoid unnecessary requests and make your app faster by serving cached data when it’s still valid.

The Cache-Control header is one of the most commonly used headers. It allows you to set rules for how long a resource should be cached, whether it should be revalidated, and much more.

Let’s break it down with an example using NestJS and Node.js!

?? Example: Cache-Control in NestJS

Imagine you’re building an API and want to cache the response for 1 hour. Here’s how you can do it in NestJS:

import { Controller, Get, Response } from '@nestjs/common';
import { Response as ExpressResponse } from 'express';

@Controller('resource')
export class ResourceController {
  @Get()
  getResource(@Response() res: ExpressResponse) {
    const resource = 'This is the resource content';

    // Set Cache-Control header to cache for 1 hour (3600 seconds)
    res.setHeader('Cache-Control', 'public, max-age=3600');

    return res.send(resource);
  }
}        

What’s happening here:

• We’re telling the client, "You can cache this response for 1 hour."
• After that hour, the client will need to check back for an updated version.

This simple step helps reduce the number of requests to your server, speeding up response times for your users!

?? Now, Let’s Look at a Basic Node.js Example:

If you're using Node.js with Express, here’s the same thing:

Simple Node.js Example:

const express = require('express');
const app = express();

app.get('/resource', (req, res) => {
  const resource = 'This is the resource content';

  // Set Cache-Control header to cache for 1 hour
  res.setHeader('Cache-Control', 'public, max-age=3600');

  res.send(resource);
});

app.listen(3000, () => {
  console.log('Server running on https://localhost:3000');
});        

What’s happening here:

• We set the Cache-Control header to max-age=3600 (1 hour). This tells the client: "You can keep this cached for the next hour."
• After that, the client will check if it needs a fresh version.

Why should you care about this?

• Faster Response Times: When data is cached, your app doesn't need to re-fetch the same data over and over again.
• Less Server Load: With fewer requests, your server can focus on handling new requests instead of serving cached data.
• Better User Experience: Faster loading times mean happier users.

So, if you're building APIs or web apps, learning how to use Cache-Control headers can make your backend much more efficient. It’s a small tweak that has a big impact!