NestJS architecture Interview Preparation Guide

While Express and Fastify are low-level unopinionated routing libraries, NestJS is an opinionated enterprise framework. NestJS provides a robust Inversion of Control (IoC) dependency injection container, a modular architectural layout, and a structured request execution pipeline out of the box. Instead of writing boilerplate setup code, developers leverage decorators, guards, interceptors, and pipes to enforce clean separation of concerns, making large-scale codebases significantly more maintainable and testable.

Guards execute before route handlers and are strictly responsible for authorization and authentication, returning a boolean indicating whether a request is allowed to proceed. Interceptors wrap around the method execution using RxJS observables, allowing developers to inspect, transform, or cache data both before the handler runs and after the response is generated. Interceptors have full access to response streams, whereas guards are strictly binary gatekeepers.

You should use singleton providers (the default) for nearly all services because they are instantiated once at startup and cached in memory, ensuring optimal performance. Request-scoped providers create a fresh class instance for every incoming request, which introduces severe memory overhead and CPU latency. Request scope should only be used when you genuinely need to track immutable per-request transactional state that cannot be passed explicitly via method parameters.

Circular dependencies occur when Module A imports Module B while Module B simultaneously imports Module A, creating an initialization deadlock. NestJS provides the forwardRef() utility function to defer instantiation until both modules are loaded. However, circular dependencies are generally considered an architectural smell indicating poor domain boundaries. They should be avoided by extracting shared business logic into a third independent module or refactoring service structures.

A dynamic module allows developers to create modules configurable at runtime by passing parameters or asynchronous factory functions (e.g., ConfigModule.forRootAsync()). This is essential when building reusable libraries or infrastructure plugins—such as database clients or logging SDKs—that need to adapt their internal providers based on environment variables or external configuration files before the dependency graph is resolved.

Switching to Fastify requires installing the @nestjs/platform-fastify package and passing a NestFastifyApplication adapter instance into NestFactory.create() in main.ts. Developers make this switch to drastically boost request throughput (often up to 2x) and reduce memory overhead under high-load production environments, as Fastify uses highly optimized JSON serialization and lower-level routing.

Middleware executes before the routing controller is reached and has access to raw Express or Fastify request and response objects, operating globally or per-route. Exception Filters are dedicated error boundaries that catch unhandled exceptions thrown anywhere in the application lifecycle. Filters provide typed exception handling, allowing developers to transform custom business errors into standardized JSON error responses before they leave the server.

RxJS is deeply integrated into NestJS, particularly within Interceptors, microservice transport layers, and event emitters. Because NestJS relies on reactive streams, developers can use RxJS operators like map, catchError, timeout, and tap to manipulate request and response data streams asynchronously. This makes handling complex event-driven architectures, WebSockets, and distributed microservice message passing exceptionally powerful.

E2E tests in NestJS are written using Jest and Supertest. The testing module is compiled using Test.createTestingModule(), allowing developers to override specific providers, mock database connections, or substitute external API clients. Tests simulate real HTTP requests against the compiled application instance to verify that controllers, guards, pipes, and exception filters interact correctly across the entire request lifecycle.

ValidationPipe integrates class-validator and class-transformer into the NestJS request pipeline to automatically validate incoming JSON payloads against TypeScript DTO (Data Transfer Object) classes. By enabling options like { whitelist: true, forbidNonWhitelisted: true }, the pipe strips uninvited properties and rejects malformed payloads instantly, protecting the application from mass assignment vulnerabilities before business logic executes.