Question 1

Explain NestJS Guards and how they differ from Middleware.

Accepted Answer

Guards, annotated with `@Injectable()`, implement the `CanActivate` interface. They determine whether a request should be processed by the controller handler based on permissions, roles, or ACL settings. Unlike Middleware, Guards have access to the `ExecutionContext`, letting them inspect exactly which handler and metadata are targeted next.

Question 2

Explain NestJS Interceptors and write a basic logging interceptor.

Accepted Answer

Interceptors, annotated with `@Injectable()`, implement the `NestInterceptor` interface. They bind extra logic to requests and responses, transform return payloads, or extend timeouts. Write an interceptor using RxJS operators:
```typescript
@Injectable()
export class LoggingInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    console.log('Before...');
    const now = Date.now();
    return next.handle().pipe(tap(() => console.log(`After... ${Date.now() - now}ms`)));
  }
}
```

Question 3

How do you perform unit and integration testing in NestJS using the Test module?

Accepted Answer

Use `@nestjs/testing`. Build a mock testing module using `Test.createTestingModule` to compile the Nest container. You can mock providers using `overrideProvider` and mock database calls (using Jest mocks), isolating components or running full integration assertions.

Question 4

Explain the role of Reflector and Metadata in custom validation or security rules.

Accepted Answer

NestJS provides `SetMetadata()` to attach custom metadata tags to handlers. In Guards or Interceptors, inject the `Reflector` helper class to read these tags from the class or target method, letting you check user roles or validate routes dynamically.

Question 5

What is AsyncLocalStorage in NestJS and how is it configured?

Accepted Answer

`AsyncLocalStorage` allows you to store and access context data (like request IDs or user sessions) across asynchronous call chains without passing them as parameters. It is configured inside middleware, setting request context dynamically.

Question 6

How do you optimize NestJS boot times by dynamic module loading?

Accepted Answer

Avoid importing all modules globally. Use dynamic importing or configuration overrides to load modular databases or services only when needed, reducing container compiling steps.

Question 7

How do you write tests for NestJS controllers that check status code validation?

Accepted Answer

Use Supertest. Compile a testing module, initialize the app instance using `app.init()`, and run HTTP requests using `supertest(app.getHttpServer())`, asserting returned status codes and JSON properties.

Question 8

Explain the differences between NestJS Middleware, Guards, and Interceptors.

Accepted Answer

- Middleware: Runs before handlers, modifies req/res, lacks ExecutionContext access.
- Guards: Runs next, determines access, has access to ExecutionContext.
- Interceptors: Wraps handler, modifies input parameters and output streams using RxJS.

Question 9

How do you implement global validation filters in NestJS?

Accepted Answer

Write a custom exception filter implementing `ExceptionFilter`. Catch `ValidationError` exceptions thrown by ValidationPipe, and format the returned JSON response with details.

Question 10

Explain how to write custom Pipes for input data transformation.

Accepted Answer

Implement the `PipeTransform` interface and write the `transform()` method. Parse inputs (e.g. converting a string ID into a Mongoose ObjectId) and throw `BadRequestException` if invalid.

Question 11

How do you integrate database connection caching in NestJS?

Accepted Answer

Initialize connection pools in database modules (using TypeORM or Mongoose). Configure pooling variables (max connections, idle timeouts) to optimize queries and prevent connection leaks.

Question 12

What is the difference between global scoped, controller scoped, and route scoped interceptors?

Accepted Answer

- Global: Registered in `main.ts` or as a provider, wraps all routes.
- Controller: Registered with `@UseInterceptors()` on class, wraps all handlers in that class.
- Route: Registered on a handler method, wraps only that route.

Question 13

How do you mock Redis calls inside NestJS services during testing?

Accepted Answer

Use Jest mocks. Provide a mock implementation of the Redis client service in the testing module configuration, stubbing get/set calls to isolate your service tests from external servers.

Question 14

Explain how dynamic modules register dynamic providers.

Accepted Answer

A dynamic module returns a module object containing a list of `providers` dynamically generated based on runtime parameters, which is useful for configuring connection factories.

Question 15

How do you optimize memory footprints in NestJS containers?

Accepted Answer

Keep injection scopes Singleton by default. Avoid transient or request scopes unless necessary, as they force Nest to recreate service instances on every request, increasing memory garbage collection overhead.

Question 16

How do you write integration tests that verify database migrations?

Accepted Answer

Run migration scripts on a test database inside `beforeAll`. Compile the Nest app module, execute API mutation requests, verify the changes in the DB, and rollback migrations inside `afterAll`.

Question 17

Explain Dependency Injection scopes in NestJS (Singleton, Transient, Request) and their performance implications.

Accepted Answer

NestJS supports three provider scopes:
1. Singleton (Default): A single instance of the provider is cached and shared across the entire application. It is highly performant and recommended.
2. Transient: A new instance of the provider is created for each injecting module, which has a moderate memory overhead.
3. Request: A new instance of the provider is created for each incoming request, discarded once the request-response cycle completes. This scope propagates up: if a Singleton injects a Request-scoped service, the Singleton automatically becomes Request-scoped. This increases garbage collection overhead and slows down API performance.

Question 18

How would you design a scalable microservices architecture in NestJS supporting gRPC and Kafka transports?

Accepted Answer

To build a scalable microservices network, separate applications into modular components:
- Hybrid Apps: Configure Nest to handle both HTTP endpoints (Express/Fastify) and microservice transports (using `app.connectMicroservice()`).
- Transports: Use gRPC for synchronous, low-latency internal communication (service-to-service), and Kafka or RabbitMQ for asynchronous, event-driven task processing.
- Clustering: Scale microservice containers horizontally, using consumer groups in Kafka to distribute partitions across instances.

Question 19

Explain the CQRS (Command Query Responsibility Segregation) pattern in NestJS and write a command handler.

Accepted Answer

CQRS segregates write operations (Commands) from read operations (Queries) using `@nestjs/cqrs`:
- Commands modify state (e.g. `CreateUserCommand`).
- Queries read state (e.g. `GetUsersQuery`).
- Handlers: Write handlers using `@CommandHandler(CreateUserCommand)`. They handle operations, publishing events to an `EventBus` to sync states asynchronously.

Question 20

How would you handle distributed transactions across multiple microservices in a NestJS app?

Accepted Answer

Since microservices have separate databases, 2PC (Two-Phase Commit) blocks scalability. Implement the Saga Pattern:
- Orchestration: A central orchestrator service triggers step APIs sequentially in other services.
- Compensating Transactions: If step 3 fails (e.g. billing fails), the orchestrator triggers rollback actions (compensating transactions) in step 2 and step 1 in reverse order to restore consistency.

Question 21

How do you secure NestJS APIs against common vulnerabilities (Rate Limiting, Cors, CSP, SQLi)?

Accepted Answer

Secure NestJS applications by:
1. Rate Limiting: Register `@nestjs/throttler` to enforce request limits.
2. Security headers: Register Helmet middleware globally to configure CSP, CORS, and HSTS headers.
3. Input validation: Validate parameters inside global `ValidationPipe` instances using `whitelist: true` and `forbidNonWhitelisted: true` to block injection payloads.

Question 22

Explain how NestJS schedules async queues using BullMQ.

Accepted Answer

Use `@nestjs/bullmq`. Configure BullMQ connections to Redis. Define queues and write job consumer classes annotated with `@Processor('queue')`. Workers process tasks in background threads, handling retries.

Question 23

How do you implement distributed tracing inside NestJS applications?

Accepted Answer

Use OpenTelemetry with automatic instrumentation. Initialize tracing before bootstrapping NestJS to patch dependencies (like `http`, `pg`, `ioredis`), correlating trace IDs in logs across microservice calls.

Question 24

Explain database replication routing inside NestJS modules.

Accepted Answer

Create a custom database module. Configure a read pool (connecting to database replicas) and a write pool (connecting to the primary master database). Route queries dynamically based on transaction types.

Question 25

How do you deploy NestJS on serverless infrastructures?

Accepted Answer

Wrap NestJS in a handler using `@vendia/serverless-express`. This converts AWS Lambda gateway events into Express requests. Bootstrap the Nest container once globally outside the Lambda handler to prevent cold starts.

Question 26

How do you build a multi-tenant routing database factory in NestJS?

Accepted Answer

Create a request-scoped database provider. Inside a factory function, intercept the request context, read the tenant ID header, and retrieve or create a matching connection pool from a connection registry.

Question 27

Explain circular dependencies in NestJS and how to resolve them.

Accepted Answer

Circular dependencies occur when module A imports module B, and B imports module A. Resolve them using forward reference helpers: `ModuleRef` or `forwardRef(() => ModuleB)` in imports, ensuring resolved compilation.

Question 28

How do you profile memory leaks inside NestJS containers in production?

Accepted Answer

Start the container process with inspection flags. Port-forward the inspection port locally (`ssh -L 9229:localhost:9229 container-ip`). Attach Chrome DevTools, capture heap snapshots, and analyze growing classes.

Question 29

Explain how to write custom interceptors that mutate output stream buffers.

Accepted Answer

Write an interceptor. Map the returned observable from `next.handle()` using RxJS operators (like `map` or `concatMap`) to intercept, modify, or compress response payloads dynamically.

Question 30

How do you configure dynamic API versioning in NestJS?

Accepted Answer

Enable versioning globally in `main.ts` using `app.enableVersioning()`. Configure type settings (e.g. URI, Header, or Media Type) and assign `@Version('1')` decorators to controller routes.

Question 31

How do you set up distributed telemetry metrics in NestJS?

Accepted Answer

Install Prometheus client libraries. Register custom middleware to record HTTP latencies and request counts, exporting metric schemas to Prometheus endpoints for scrape scraping.

Question 32

Explain execution context reflection in NestJS guards.

Accepted Answer

In Guards, use `context.switchToHttp().getRequest()` to read the request. Use `Reflector` to query custom metadata (e.g. permissions) attached to the route handler method or parent controller class.

Question 33

How do you debug container bootstrapping issues in NestJS?

Accepted Answer

Enable Nest's logger early. Set `logger: ['log', 'error', 'warn', 'debug']` in `NestFactory.create` options to trace module resolution steps and identify which provider dependency fails to compile.

Senior NestJS Interview Questions (5+ Years Experience) (2026)

What is NestJS and Why is it Critical in Modern Engineering?

NestJS Lifecycle Visualizer

Core Architectural Concepts in NestJS

Dependency Injection

Modules & Providers

Guards & Interceptors

Exception Filters

Microservice Transport Logs

check_circleWhy Modern Companies Choose NestJS

lightbulbStrategic Preparation Tips

errorCrucial Mistakes to Avoid

trending_upHiring Trends & Career Outlook (2026)

Architecture