Question 1

What is NestJS and how does it implement architecture on top of Express?

Accepted Answer

NestJS is a progressive Node.js framework for building efficient, reliable, and scalable server-side applications. It uses TypeScript by default and implements an opinionated modular architecture inspired by Angular. Under the hood, NestJS wraps a HTTP server framework, defaulting to Express, but allowing developers to easily switch to Fastify for higher performance, while providing design patterns (Modules, Controllers, Providers) that enforce clean structure.

Question 2

Explain Modules, Controllers, and Providers in NestJS.

Accepted Answer

- Modules: Annotated with `@Module()`, they organize the application structure, encapsulating related controllers, providers, and exports.
- Controllers: Annotated with `@Controller()`, they handle incoming HTTP requests, map routing endpoints, and return response payloads.
- Providers: Annotated with `@Injectable()`, they house business logic (services, repositories, factories) and can be injected as dependencies.

Question 3

What is Dependency Injection (DI) and how does NestJS resolve dependencies?

Accepted Answer

Dependency Injection is a design pattern used to achieve Inversion of Control (IoC). In NestJS, when you annotate a class as `@Injectable()`, the Nest IoC container instantiates it. Dependencies are declared in the constructor (e.g. `constructor(private service: UserService)`). The Nest runtime automatically resolves, creates, and injects instances at startup.

Question 4

What is the purpose of main.ts in a NestJS application?

Accepted Answer

`main.ts` is the entry point of the application. It uses the `NestFactory` class to bootstrap the application, initialize the Nest IoC container, register global middlewares, filters, and pipes, and start the HTTP server on a port.

Question 5

How do you handle request validation in NestJS using DTOs?

Accepted Answer

DTOs (Data Transfer Objects) define the schema of request payloads. You combine them with validation libraries (like `class-validator` and `class-transformer`) and register a global `ValidationPipe`. When requests arrive, the pipe checks payloads against the decorators in the DTO, returning validation errors automatically.

Question 6

Explain Exception Filters in NestJS.

Accepted Answer

Exception Filters catch unhandled exceptions in the application request-response cycle. Nest has a built-in global exception filter that handles HTTP exceptions (like returning JSON for `NotFoundException`). You can write custom filters to format error logs or database errors.

Question 7

What are Pipes in NestJS and what are their two main use cases?

Accepted Answer

Pipes, annotated with `@Injectable()`, implement the `PipeTransform` interface. Their two main use cases are:
1. Transformation: Converting input data to expected types (e.g., converting a string ID to a number).
2. Validation: Checking input structures against schemas before passing execution.

Question 8

How do you load environment variables in NestJS using ConfigModule?

Accepted Answer

Register the `@nestjs/config` package and import `ConfigModule.forRoot()` in your root module. You can then inject `ConfigService` into providers to retrieve environment variables safely.

Question 9

What is the difference between @nestjs/platform-express and @nestjs/platform-fastify?

Accepted Answer

`@nestjs/platform-express` uses the Express framework underneath, which has standard middleware support. `@nestjs/platform-fastify` uses Fastify, which utilizes optimized routing and data structures, processing requests up to 2x faster.

Question 10

Explain the role of decorators in NestJS.

Accepted Answer

Decorators (like `@Controller()`, `@Injectable()`, `@Get()`) attach metadata to classes, methods, or parameters, which the Nest runtime uses at startup to configure routes, inject dependencies, and register modules.

Question 11

How do you create a custom decorator in NestJS?

Accepted Answer

Use the `createParamDecorator` helper function. This lets you write custom decorators (e.g., `@User()` to extract authenticated user objects from the request), simplifying parameters mapping in controllers.

Question 12

What is a dynamic module in NestJS?

Accepted Answer

A dynamic module is a module whose configuration can be customized dynamically when imported, usually exposing static methods like `register()`, `forRoot()`, or `forFeature()` that return module configurations.

Question 13

How do you validate request payloads using ValidationPipe?

Accepted Answer

Enable validation globally in `main.ts` using `app.useGlobalPipes(new ValidationPipe())`. Any DTO parameter decorated with validators will trigger validations automatically.

Question 14

Explain the role of the NestJS Logger service.

Accepted Answer

NestJS provides a built-in `Logger` class that formats and outputs runtime logs. It supports log level filtering (log, error, warn, debug, verbose), which is useful for debugging and tracing.

Question 15

What is the NestJS CLI and how is it used?

Accepted Answer

The NestJS CLI is a development command-line tool. It generates components (modules, controllers, services) using simple command prompts: `nest g co users` generates a users controller, registering it automatically.

Question 16

How do you configure database connections in NestJS?

Accepted Answer

Use modules like `@nestjs/typeorm` or `@nestjs/mongoose`. Import them dynamically inside the root module, configuring connection credentials and registering entities for injection.

Question 17

Explain the NestJS request-response cycle.

Accepted Answer

Requests enter the pipeline sequentially matching: Middleware -> Guards -> Interceptors -> Pipes -> Controller Handler -> Interceptors (response) -> Exception Filters (errors) -> Response.

Question 18

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 19

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 20

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 21

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 22

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 23

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 24

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 25

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 26

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 27

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 28

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 29

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 30

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 31

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 32

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 33

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 34

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 35

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 36

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 37

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 38

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 39

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 40

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 41

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 42

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 43

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 44

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 45

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 46

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 47

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 48

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 49

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 50

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.

NestJS Interview Questions for 2–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)

Basics