Why caching reduces response latency in NestJS - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

How does caching improve response time in NestJS?

In a NestJS application, why does using caching typically reduce the response latency for repeated requests?

A Because caching compresses the response data, making it smaller to send over the network.

B Because caching stores the result of expensive operations, so the server can quickly return the stored data without recalculating.

C Because caching sends the request to multiple servers simultaneously to get the fastest response.

D Because caching increases the server's CPU speed, making all operations faster.

💡 Hint

Think about what happens when the server has already done the work once and saves the result.

Caching stores the output of expensive or slow operations so that when the same data is requested again, the server can return the cached result immediately without repeating the work. This reduces the time the server spends processing and thus lowers response latency.

❓ component_behavior

intermediate

What happens when a cached value is available in NestJS?

Consider a NestJS controller method that uses caching. What is the behavior when a cached value exists for a request?

A The method skips executing its logic and returns the cached value immediately.

B The method executes fully but ignores the cached value.

C The method clears the cache and then executes its logic.

D The method returns an error because cached values are not allowed.

💡 Hint

Think about why caching is used: to avoid repeating work.

When a cached value exists, the NestJS method returns that value immediately without running the full logic again. This saves time and reduces latency.

📝 Syntax

advanced

Identify the correct NestJS cache interceptor usage

Which option correctly applies the built-in cache interceptor to a NestJS controller method to enable caching?

NestJS

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

@Controller('items')
export class ItemsController {
  @Get()
  @UseInterceptors(/* ??? */)
  findAll() {
    // expensive operation
    return ['item1', 'item2'];
  }
}

A CacheInterceptor

B CacheManager

C CacheService

D CacheModule

💡 Hint

Look for the interceptor class that handles caching.

The CacheInterceptor is the built-in NestJS interceptor that enables caching for controller methods. It should be passed to @UseInterceptors.

❓ state_output

advanced

What is the response time difference with and without caching?

Given a NestJS endpoint that takes 2 seconds to compute a response, what will be the approximate response time for the second request if caching is enabled?

A About 4 seconds because caching doubles the processing time.

B About 2 seconds because caching does not affect response time.

C About 0.01 seconds because the cached result is returned instantly.

D About 1 second because caching halves the processing time.

💡 Hint

Think about how caching avoids repeating the expensive operation.

After the first request, the result is cached. The second request returns the cached data immediately, so the response time is very short, close to zero.

🔧 Debug

expert

Why does caching not reduce latency in this NestJS example?

Consider this NestJS controller method using caching, but response times remain slow on repeated requests. What is the likely cause?

NestJS

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

@Controller('data')
export class DataController {
  @Get()
  @UseInterceptors(CacheInterceptor)
  async fetchData() {
    const result = await this.expensiveOperation();
    return result;
  }

  async expensiveOperation() {
    // Simulate delay
    await new Promise(res => setTimeout(res, 2000));
    return { data: 'value' };
  }
}

A The controller method must return a string, not an object, for caching to work.

B The expensiveOperation method is async, so caching cannot store async results.

C The CacheInterceptor only caches POST requests, not GET requests.

D The cache is not enabled globally or the CacheModule is not imported, so caching does not work.

💡 Hint

Check if the caching system is properly set up in the app module.

In NestJS, caching requires importing CacheModule globally or in the module. Without this, CacheInterceptor does not cache responses, so repeated requests remain slow.