Learn NestJS - Core Concepts & Main Architecture

#Introduction

After understanding why NestJS exists, now we move into how NestJS works. The NestJS architecture can look complicated at first because of the many terms: module, controller, provider, pipe, guard, filter, interceptor. In reality, they all follow one consistent pattern.

Episode 2 dissects the core concepts and main NestJS architecture. You'll understand the role of each component, how dependency injection works, and the application lifecycle from bootstrap to responding to requests.

#Architecture Behind the Scenes

#NestJS as an Express Wrapper

By default, NestJS wraps Express — NestJS doesn't replace Express, it runs on top of it. You can still access Express's req and res objects when needed. NestJS also supports Fastify as a faster alternative.

Bootstrap aplikasi NestJS

import { NestFactory } from "@nestjs/core";
import { AppModule } from "./app.module";
 
async function bootstrap(): Promise<void> {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
}
 
void bootstrap();

The bootstrap() function is the application's entry point. NestFactory.create creates the application instance and app.listen(3000) runs the HTTP server behind the scenes — Express by default.

#Application Lifecycle

NestJS has a clear lifecycle: modules and providers are initialized when the application starts, then hooks like OnModuleInit and OnModuleDestroy can be used to run code at specific stages — for example, opening a database connection or closing it during shutdown.

#Main NestJS Components

#Module

A module is the main organizational unit. Every application has a root module (AppModule), and features are split into feature modules. Modules declare controllers, providers, and other modules they import.

#Controller

A controller is responsible for receiving requests and returning responses. Controllers don't contain business logic — they delegate the work to services. Routing is defined through decorators like @Get and @Post.

Controller sederhana

import { Controller, Get } from "@nestjs/common";
 
@Controller("users")
export class UserController {
  @Get()
  findAll(): string[] {
    return ["Arman", "Budi"];
  }
}

The @Controller("users") decorator sets the route prefix, and @Get() specifies that this method responds to GET requests to /users.

#Provider

A provider is a class that contains application logic — usually called a service. Providers are registered in modules and injected into controllers or other providers through dependency injection.

#Dependency Injection Container

#How DI Works

NestJS has a dependency injection container that manages the creation and injection of providers. When a controller requests a service in its constructor, NestJS creates the service instance and injects it automatically.

Penyuntikan service ke controller

@Controller("users")
export class UserController {
  constructor(private readonly userService: UserService) {}
}

Notice that UserService isn't created manually — just declared in the constructor, and NestJS handles it. This is called constructor injection.

#Provider Resolution

The container resolves dependencies in order: if UserService itself needs DatabaseService, the container creates DatabaseService first, then UserService, and only then the controller. This dependency graph is built when the application starts.

#Cross-Cutting Components

#Pipes

Pipes validate and transform incoming data before it reaches the handler. Built-in examples: ValidationPipe and ParseIntPipe.

#Guards

Guards determine whether a request may proceed, usually for authentication and authorization. Guards run before pipes and handlers.

#Filters

Exception filters catch errors and turn them into clean responses. The default filter produces a JSON response with the appropriate status code.

#Interceptors

Interceptors wrap the execution of a handler — they can add logic before and after the handler, modify the response, or handle caching. This is a powerful pattern for cross-cutting concerns.

#Workflow and Module Structure

#Recommended Folder Structure

The Nest CLI already generates a clean structure from the start:

src/
  main.ts
  app.module.ts
  app.controller.ts
  app.service.ts

Each feature will later have its own folder, for example users/ containing users.module.ts, users.controller.ts, and users.service.ts.

#Shared and Global Modules

Modules can export providers for use by other modules (shared modules), or be marked @Global() so they're available throughout the application without being imported repeatedly. These two patterns keep the balance between structure and practicality.

#Conclusion

Episode 2 gives you a complete map of the NestJS architecture: NestJS runs on top of Express, is organized into modules, controllers, and providers, and is managed by a dependency injection container. The pipes, guards, filters, and interceptors components handle cross-cutting needs.

Key takeaways:

• NestJS is a wrapper on top of Express or Fastify.
• Modules organize the application; controllers handle requests; providers contain logic.
• The dependency injection container creates and injects dependencies automatically.
• Pipes, guards, filters, and interceptors handle cross-cutting concerns.
• The application lifecycle has OnModuleInit and OnModuleDestroy hooks.
• The folder structure from the Nest CLI is already optimal for scaling.

In the next episode 3 we'll discuss building your first application — creating a project with the Nest CLI, understanding the src/app.module.ts and main.ts structure, running the application, checking the basic endpoint, and initial configuration with @nestjs/config.