Street Learner
AuthorLast Updated: a year ago
Imagine your e-commerce API receiving thousands of concurrent requests. Users are browsing products, checking prices, and viewing order history — and every request hits the database. Response times rise, server load spikes, and customers complain about slow performance.
This is one of the most common pain points for backend developers.
Instead of scaling servers endlessly, a smarter solution is multi-layer caching — a high-performance strategy that can cut response times from hundreds of milliseconds down to a single millisecond.
This guide walks you through a production-ready, real-world multi-layer caching architecture in NestJS. You'll learn the concepts, patterns, and code required to implement a high-speed caching system from scratch.
Not all caching systems are equal. There’s a hierarchy of speed every backend engineer should understand:
This difference alone can create a 500x performance improvement.
In a real e-commerce use case, implementing multi-layer caching resulted in:
Caching can massively upgrade performance when implemented correctly. Let’s explore the core caching strategies and how to build them in NestJS.
Caching strategies differ depending on read/write patterns and consistency requirements. Here are the five essential ones used in production systems.
This is the most common and simplest caching strategy.
This works best for read-heavy APIs.
Example:
async getProduct(id) {
const cached = await this.cache.get(`product:${id}`);
if (cached) return cached;
const product = await this.db.findProduct(id);
await this.cache.set(`product:${id}`, product, 60);
return product;
}
Every write goes through both the database and cache.
Steps:
Use this when consistency is critical, such as inventory or finance.
async updateProduct(id, data) {
const updated = await this.db.update(id, data);
await this.cache.set(`product:${id}`, updated, 60);
return updated;
}
The fastest write pattern.
Process:
Great for analytics, click tracking, metrics, or high-write workloads.
async trackView(pageId) {
const views = await this.cache.increment(`views:${pageId}`);
this.queue.add({ pageId, views });
return views;
}
This combines memory + Redis + database in a layered hierarchy:
On a miss, you populate each layer so the next request is faster.
async getProduct(id) {
const key = `product:${id}`;
const memory = await this.memory.get(key);
if (memory) return memory;
const redis = await this.redis.get(key);
if (redis) {
await this.memory.set(key, redis, 60);
return redis;
}
const product = await this.db.find(id);
await this.memory.set(key, product, 60);
await this.redis.set(key, product, 120);
return product;
}
Caching entire HTTP responses reduces load without touching service code.
intercept(context, next) {
const req = context.switchToHttp().getRequest();
if (req.method !== 'GET') return next.handle();
const key = this.generateKey(req);
const cached = await this.cache.get(key);
if (cached) return of(cached);
return next.handle().pipe(
tap(data => this.cache.set(key, data, 30))
);
}
Now let's build a real multi-layer caching system: memory → Redis → database.
Run the following commands:
npm i -g @nestjs/cli
nest new multilayer-cache
cd multilayer-cache
Install Redis:
npm install ioredis @nestjs/cache-manager cache-manager
Create a Redis module that connects with retry strategy and logging.
import Redis from 'ioredis';
const client = new Redis({
host: process.env.REDIS_HOST || 'localhost',
port: parseInt(process.env.REDIS_PORT) || 6379,
});
This service wraps all core Redis operations (get, set, delete, pattern delete, increment).
import { Injectable, OnModuleDestroy } from '@nestjs/common';
import { Inject } from '@nestjs/common';
import Redis from 'ioredis';
/**
* RedisService - Wrapper service for Redis operations
*
* This service provides a clean interface for Redis operations
* and handles connection lifecycle management.
*
* Use cases:
* - Distributed caching across multiple servers
* - Session storage
* - Rate limiting
* - Pub/Sub messaging
*/
@Injectable()
export class RedisService implements OnModuleDestroy {
constructor(@Inject('REDIS_CLIENT') private readonly redisClient: Redis) { }
/**
* Get the raw Redis client for advanced operations
*/
getClient(): Redis {
return this.redisClient;
}
/**
* Set a key-value pair with optional TTL (Time To Live)
* @param key - Cache key
* @param value - Value to cache (will be JSON stringified)
* @param ttlSeconds - Time to live in seconds (optional)
*/
async set(key: string, value: any, ttlSeconds?: number): Promise<void> {
const stringValue = JSON.stringify(value);
if (ttlSeconds) {
await this.redisClient.set(key, stringValue, 'EX', ttlSeconds);
} else {
await this.redisClient.set(key, stringValue);
}
}
/**
* Get a value by key
* @param key - Cache key
* @returns Parsed value or null if not found
*/
async get<T>(key: string): Promise<T | null> {
const value = await this.redisClient.get(key);
if (!value) return null;
try {
return JSON.parse(value) as T;
} catch {
return value as T;
}
}
/**
* Delete one or more keys
* @param keys - Keys to delete
* @returns Number of keys deleted
*/
async del(...keys: string[]): Promise<number> {
return await this.redisClient.del(...keys);
}
/**
* Delete all keys matching a pattern
* WARNING: Use with caution in production
* @param pattern - Pattern to match (e.g., 'product:*')
*/
async delPattern(pattern: string): Promise<number> {
const keys = await this.redisClient.keys(pattern);
if (keys.length === 0) return 0;
return await this.redisClient.del(...keys);
}
/**
* Check if a key exists
* @param key - Key to check
* @returns true if exists, false otherwise
*/
async exists(key: string): Promise<boolean> {
const result = await this.redisClient.exists(key);
return result === 1;
}
/**
* Set expiration time for a key
* @param key - Key to expire
* @param seconds - Seconds until expiration
*/
async expire(key: string, seconds: number): Promise<boolean> {
const result = await this.redisClient.expire(key, seconds);
return result === 1;
}
/**
* Get time to live for a key
* @param key - Key to check
* @returns Seconds until expiration, -1 if no expiration, -2 if key doesn't exist
*/
async ttl(key: string): Promise<number> {
return await this.redisClient.ttl(key);
}
/**
* Increment a numeric value
* @param key - Key to increment
* @param amount - Amount to increment by (default: 1)
*/
async increment(key: string, amount: number = 1): Promise<number> {
return await this.redisClient.incrby(key, amount);
}
/**
* Cleanup on module destroy
*/
async onModuleDestroy() {
await this.redisClient.quit();
}
}
This service handles:
Example logic:
async getProduct(id) {
const key = `product:${id}`;
const memory = await this.memoryCache.get(key);
if (memory) return { data: memory, source: 'memory' };
const redis = await this.redis.get(key);
if (redis) {
await this.memoryCache.set(key, redis, 60000);
return { data: redis, source: 'redis' };
}
const product = await this.fetchFromDatabase(id);
await this.memoryCache.set(key, product, 60000);
await this.redis.set(key, product, 120);
return { data: product, source: 'database' };
}
Include endpoints like:
Example:
@Get('product/:id')
async getProduct(id) {
return this.cacheService.getProduct(id);
}
Cache invalidation must be handled carefully to avoid stale data.
There are three reliable patterns:
Example of clearing both layers:
await this.memoryCache.del(`product:${id}`);
await this.redis.del(`product:${id}`);
Good cache keys make invalidation and debugging easier.
Use this format:
resource:identifier:sub-resource:filters
Examples:
product:123 products:list:page:1:limit:20 products:category:mobile
This structure allows pattern invalidation like:
products:category:mobile:*
Track:
Hit rate formula:
(hits / totalRequests) × 100
Aim for above 70%.
Preload frequently accessed data to eliminate cold starts.
You can warm:
Warm on startup, deployment, or hourly using cron jobs.
Here are common mistakes and their solutions:
Cache stampede: Avoid by using locks or wait-and-retry Stale data: Apply correct invalidation Memory leaks: Set max cache size Inconsistent layers: Always update both memory and Redis
Before caching:
After multi-layer caching:
Multi-layer caching dramatically increases performance while reducing database load and server cost. It also improves user experience by providing blazing-fast responses.
Follow these steps:
This system is scalable, production-ready, and proven in real high-load environments.
GraphQL has changed how modern APIs are built. Instead of fixed REST endpoints, GraphQL allows clients to ask for exactly the data they need — no more and no less. When combined with NestJS and MongoDB, GraphQL becomes extremely powerful, scalable, and production-ready.
Street Learner
21 Jan 2025
Optimizing the performance of a NestJS application is critical for building scalable, fast, and production-ready APIs. Even though NestJS is a high-performance framework, improper coding practices, unoptimized database queries, and lack of caching can slow down your application.
Street Learner
21 Jan 2025
NestJS interceptors are one of the most powerful tools in the framework, enabling developers to transform responses, cache results, log performance, and optimize requests. For large-scale applications, building high-performance interceptors is essential to improve speed, maintainability, and scalability.
Street Learner
18 Jan 2025