Why caching reduces response latency in NestJS

Introduction

Caching stores data temporarily so your app can get it faster next time. This makes your app respond quicker and feel smoother.

When your app fetches the same data many times, like user profiles or product lists.

When you want to reduce waiting time for users on slow or busy servers.

When you want to lower the load on your database or external services.

When you want to improve performance for repeated requests in a short time.

When you want to save bandwidth by not fetching unchanged data repeatedly.

Syntax

NestJS

import { CacheModule, Module } from '@nestjs/common';

@Module({
  imports: [CacheModule.register({ ttl: 5 })], // ttl is time to live in seconds
})
export class AppModule {}

ttl means how long the data stays in cache before it is refreshed.

CacheModule helps NestJS store and retrieve cached data easily.

Examples

This example caches the response of the findAll method so repeated calls return cached data quickly.

NestJS

import { CacheInterceptor, Controller, Get, UseInterceptors } from '@nestjs/common';

@Controller('items')
@UseInterceptors(CacheInterceptor)
export class ItemsController {
  @Get()
  findAll() {
    return ['item1', 'item2', 'item3'];
  }
}

Here, cache entries expire after 10 seconds, so data refreshes regularly.

NestJS

import { CacheModule, Module } from '@nestjs/common';

@Module({
  imports: [CacheModule.register({ ttl: 10 })],
})
export class AppModule {}

Sample Program

This NestJS app counts visitors but caches the greeting for 30 seconds. So, repeated requests within 30 seconds show the same visitor number, making responses faster.

NestJS

import { CacheModule, CacheInterceptor, Controller, Get, Module, UseInterceptors } from '@nestjs/common';

@Controller('greet')
@UseInterceptors(CacheInterceptor)
export class GreetController {
  private count = 0;

  @Get()
  sayHello() {
    this.count++;
    return `Hello! You are visitor number ${this.count}`;
  }
}

@Module({
  imports: [CacheModule.register({ ttl: 30 })],
  controllers: [GreetController],
})
export class AppModule {}

Important Notes

Caching improves speed but cached data might be outdated until refreshed.

Choose cache duration (ttl) wisely based on how fresh your data needs to be.

Use caching for data that does not change every second to get the best benefit.

Summary

Caching stores data temporarily to speed up repeated requests.

It reduces the time your app waits for data from slow sources.

In NestJS, CacheModule and CacheInterceptor make caching easy to add.

Practice

1. Why does caching reduce response latency in a NestJS application?

easy

A. Because it stores frequently requested data temporarily to avoid repeated slow operations

B. Because it increases the size of the database

C. Because it disables network requests completely

D. Because it compresses the response data before sending

Solution

1. Step 1: Understand what caching does

   Caching temporarily stores data that is requested often, so the system doesn't have to fetch it repeatedly from slow sources like databases or APIs.

2. Step 2: Connect caching to response time

   By avoiding repeated slow operations, caching reduces the time the app waits before sending a response, thus lowering latency.

3. Final Answer:

   Because it stores frequently requested data temporarily to avoid repeated slow operations -> Option A

4. Quick Check:

   Caching stores data to speed up responses = A [OK]

Hint: Caching saves repeated data fetch time to speed responses [OK]

Common Mistakes:

• Thinking caching increases database size
• Believing caching disables network requests
• Confusing caching with data compression

2. Which of the following is the correct way to import caching in a NestJS module?

easy

A. import { CacheModule } from '@nestjs/common';

B. import { CacheInterceptor } from '@nestjs/core';

C. import { CacheModule } from '@nestjs/cache';

D. import { CacheService } from '@nestjs/common';

Solution

1. Step 1: Identify the correct NestJS package for CacheModule

   CacheModule is part of the '@nestjs/common' package, so it should be imported from there.

2. Step 2: Verify other options

   CacheInterceptor is from '@nestjs/common', not '@nestjs/core'; '@nestjs/cache' and CacheService do not exist as valid imports.

3. Final Answer:

   import { CacheModule } from '@nestjs/common'; -> Option A

4. Quick Check:

   CacheModule import is from '@nestjs/common' = D [OK]

Hint: CacheModule always imports from '@nestjs/common' [OK]

Common Mistakes:

• Importing CacheModule from wrong package
• Confusing CacheInterceptor import location
• Using non-existent CacheService import

3. Given this NestJS controller snippet using caching:

  @UseInterceptors(CacheInterceptor)
  @Get('data')
  async getData() {
    console.log('Fetching data...');
    return { value: 42 };
  }

What will happen on the second request to /data?

medium

A. The console logs 'Fetching data...' again and returns { value: 42 }

B. The request fails with a cache error

C. The console does not log anything and returns cached { value: 42 }

D. The console logs twice and returns { value: 42 } twice

Solution

1. Step 1: Understand CacheInterceptor behavior

   CacheInterceptor caches the response of the first request and returns it directly on subsequent requests without calling the method again.

2. Step 2: Predict console output on second request

   Since the method is not called again, 'Fetching data...' is not logged on the second request, but the cached response is returned.

3. Final Answer:

   The console does not log anything and returns cached { value: 42 } -> Option C

4. Quick Check:

   CacheInterceptor returns cached data without method call = C [OK]

Hint: CacheInterceptor skips method call on cached requests [OK]

Common Mistakes:

• Assuming method runs every time
• Expecting cache errors on normal use
• Thinking console logs twice per request

4. This NestJS code tries to enable caching but has an error:

  @Module({
    imports: [CacheModule.register()],
    controllers: [AppController],
    providers: [AppService, CacheInterceptor],
  })
  export class AppModule {}

What is the main problem here?

medium

A. CacheModule.register() requires a cache store option

B. CacheInterceptor should be provided using APP_INTERCEPTOR token, not directly

C. CacheInterceptor cannot be used with AppService

D. CacheModule must be imported from '@nestjs/core'

Solution

1. Step 1: Check how to provide CacheInterceptor globally

   CacheInterceptor must be provided using the special token APP_INTERCEPTOR to work as a global interceptor.

2. Step 2: Identify the error in providers array

   Providing CacheInterceptor directly in providers does not activate it globally; it needs to be wrapped with APP_INTERCEPTOR.

3. Final Answer:

   CacheInterceptor should be provided using APP_INTERCEPTOR token, not directly -> Option B

4. Quick Check:

   Use APP_INTERCEPTOR token to provide CacheInterceptor = B [OK]

Hint: Use APP_INTERCEPTOR token to enable CacheInterceptor globally [OK]

Common Mistakes:

• Providing CacheInterceptor directly in providers
• Thinking CacheModule always needs cache store option
• Importing CacheModule from wrong package

5. You want to cache user profile data in NestJS but only for users with a premium subscription. Which approach best reduces response latency without caching non-premium users?

hard

A. Use CacheModule with a global TTL that applies to all users equally

B. Cache all user profiles regardless of subscription to simplify caching

C. Disable caching and fetch all profiles fresh every time

D. Use CacheInterceptor with a custom cache key that includes user type and skip caching for non-premium users

Solution

1. Step 1: Understand selective caching needs

   To cache only premium users, caching logic must distinguish user types and avoid caching non-premium data.

2. Step 2: Apply custom cache key and conditional caching

   Using CacheInterceptor with a custom cache key including user type allows caching premium users separately and skipping others.

3. Step 3: Evaluate other options

   Caching all users wastes resources; disabling caching loses latency benefits; global TTL applies to all users, not selective.

4. Final Answer:

   Use CacheInterceptor with a custom cache key that includes user type and skip caching for non-premium users -> Option D

5. Quick Check:

   Selective caching with custom keys reduces latency best = A [OK]

Hint: Customize cache keys to cache only needed data [OK]

Common Mistakes:

• Caching all data without filtering
• Disabling caching completely
• Using global TTL without user distinction