Backend / Web frameworks / Nestjs / 01_nestjs.md

NestJS

Updated 6 interview angles 4 min read source
On this page5
  1. The shape
  2. Mapping from FastAPI
  3. Where it fits
  4. Related
  5. Interview angle

NestJS

The TypeScript backend framework that turns up when a job wants “Node.js: NestJS or comparable”. For someone whose depth is FastAPI or Django, the useful framing is that NestJS is Spring’s architecture on Node - opinionated, decorator-driven, dependency-injected.

The shape

Three decorated building blocks, and the framework wires them.

ts 
@Injectable()
export class InvoiceService {
  constructor(private readonly repo: InvoiceRepo) {}

  async get(id: string): Promise<Invoice> {
    return this.repo.findOne(id);
  }
}

@Controller('invoices')
export class InvoiceController {
  constructor(private readonly svc: InvoiceService) {}

  @Get(':id')
  get(@Param('id') id: string) {
    return this.svc.get(id);
  }
}

A module groups providers and controllers and declares what it exports. That is the unit of encapsulation: a provider is injectable only where its module is imported, which is stricter than FastAPI’s “import it and call it”.

The DI container resolves constructor parameters by type. Compared with FastAPI’s Depends, the difference is when: Nest builds the graph at startup, so a missing provider fails at boot rather than on first request.

Mapping from FastAPI

FastAPI NestJS
Depends() Constructor injection
Pydantic model DTO class plus ValidationPipe
Middleware Guards, interceptors, pipes, filters
Router Module plus controller

The request pipeline is where Nest is genuinely different - it splits what FastAPI does with dependencies and middleware into four named stages:

  • Guards decide access. Return false and the request is rejected before the handler. This is where auth lives.
  • Pipes transform and validate input. ValidationPipe with class-validator is the Pydantic equivalent.
  • Interceptors wrap the handler - timing, logging, response shaping, cache.
  • Exception filters map thrown errors to HTTP responses.

Knowing which stage owns a concern is most of what “experience with NestJS” means in practice.

Validation is not automatic

The trap for someone arriving from FastAPI: a DTO’s decorators do nothing unless a pipe runs. Pydantic validates because the type annotation is the contract; class-validator needs the pipe registered.

ts 
export class CreateInvoice {
  @IsUUID() customerId: string;
  @IsPositive() amount: number;
}

app.useGlobalPipes(new ValidationPipe({
  whitelist: true,        // strip unknown properties
  forbidNonWhitelisted: true,
}));

Without whitelist, properties you never declared are passed through to your service untouched - the mass-assignment hole. TypeScript types are erased at runtime and enforce nothing, which is the mental adjustment from Python where Pydantic runs on real objects.

Where it fits

It earns its structure on a large codebase with several teams: the module boundaries, the enforced layering, and startup-time DI failures are the same argument as a typed, layered Python service. It also ships first-party support for the things such a service needs - WebSocket gateways, microservice transports, GraphQL, scheduled tasks - so those do not become five library choices.

It costs you in ceremony. A small service is more code in NestJS than in Express or Fastify, and the decorator metadata means reflect-metadata and experimentalDecorators, which occasionally fight bundlers and newer runtimes.

For an interview, the honest comparison is that NestJS is to Express what Django is to Flask: structure you will be glad of at scale and resent at three endpoints.

Interview angle 6

  • “What is NestJS?” - an opinionated TypeScript backend framework built on modules, controllers and injectable providers, with a DI container resolved at startup. Architecturally it is Spring on Node, and it sits above Express or Fastify rather than replacing them.
  • “How does its DI differ from FastAPI’s Depends?” - Nest resolves constructor parameters by type and builds the graph at boot, so a missing provider is a startup failure rather than a request-time one. Modules also scope providers, so a provider is injectable only where its module is imported.
  • “Guards, pipes, interceptors, filters - which does what?” - guards decide access before the handler, pipes transform and validate input, interceptors wrap the handler for timing or response shaping, exception filters map errors to responses. Knowing which owns a concern is the practical skill.
  • “Why did your DTO validation not run?” - decorators on a DTO do nothing without a ValidationPipe. Unlike Pydantic, TypeScript types are erased at runtime, so nothing validates unless the pipe is registered.
  • “What does whitelist do and why does it matter?” - strips properties not declared on the DTO. Without it, undeclared fields reach your service, which is the mass-assignment vulnerability.
  • “When would you not use it?” - a small service, where the module and decorator ceremony costs more than it returns. Express or Fastify is lighter, the same way Flask is against Django.