Why NestJS?

Real-world analogy

What is it?

NestJS is a progressive Node.js framework for building server-side applications. Built on top of Express (or Fastify), it provides an opinionated structure inspired by Angular, using modules, controllers, and services. It includes powerful features like Pipes, Interceptors, Filters, Middleware, and custom Decorators.

Real-world relevance

NestJS is used by Adidas, Roche, Autodesk, and many startups. It's the most popular structured Node.js framework, with over 70K GitHub stars.

Key points

• Built-in Structure — Module → Controller → Service pattern. Everyone organizes code the same way — no more 'where did John put that file?'
• Dependency Injection — Instead of manually creating instances, you just declare what you need and NestJS delivers it. Like room service!
• TypeScript First — NestJS is built FOR TypeScript. Decorators (@Get, @Post, @Injectable) make code readable and self-documenting.
• Batteries Included — Validation, auth guards, Swagger docs, WebSockets, microservices — all built-in or plug-and-play.
• Scalable from Day 1 — Start small with one controller. Grow to 100 modules without refactoring. NestJS scales with your team!
• Rich Ecosystem — @nestjs/jwt, @nestjs/passport, @nestjs/websockets, @nestjs/graphql. Add what you need, nothing more.
• Pipes — Data Transformation & Validation — Pipes transform or validate incoming data before it reaches your controller. ValidationPipe automatically checks DTOs, ParseIntPipe converts strings to numbers. Think of pipes as airport security — they inspect your luggage (data) before you board the plane (controller).
• Interceptors — Before & After Logic — Interceptors wrap around your route handler. They can transform the response, add logging, cache results, or measure execution time. Like a sandwich — interceptor code runs before AND after your handler. Example: automatically wrapping all responses in {success: true, data: ...} format.
• Exception Filters — Centralized Error Handling — Instead of try/catch everywhere, exception filters catch errors globally and return consistent error responses. Create a custom filter to log errors, send alerts, and return user-friendly messages. One place to handle ALL errors.
• Middleware — Request Pipeline — Middleware runs BEFORE the route handler on every request. Use it for logging, CORS, rate limiting, or authentication checks. It's the bouncer at the door — checking everyone before they enter the club (your controller).
• Custom Decorators — Create your own decorators like @CurrentUser() to extract the logged-in user from the request, or @Roles('admin') to mark routes. Custom decorators make your code cleaner and more readable — hiding complexity behind a simple @ symbol.

Code example

// The NestJS Holy Trinity 🔺
// 1. MODULE — wires everything together
@Module({
  controllers: [UserController],
  providers: [UserService],
})
export class UserModule {}

// 2. CONTROLLER — handles HTTP requests (the front door 🚪)
@Controller('users')
export class UserController {
  constructor(private userService: UserService) {}
  //          ↑ NestJS auto-injects this! Magic! ✨

  @Get()          // GET /users
  findAll() {
    return this.userService.findAll();
  }

  @Get(':id')     // GET /users/123
  findOne(@Param('id') id: string) {
    return this.userService.findOne(id);
  }

  @Post()         // POST /users
  create(@Body() data: CreateUserDto) {
    return this.userService.create(data);
  }
}

// 3. SERVICE — business logic (the brain 🧠)
@Injectable()
export class UserService {
  constructor(private prisma: PrismaService) {}

  findAll() {
    return this.prisma.user.findMany();
  }

  findOne(id: string) {
    return this.prisma.user.findUnique({ where: { id } });
  }

  create(data: CreateUserDto) {
    return this.prisma.user.create({ data });
  }
}

// DTO — validate input 📋
import { IsString, IsEmail, MinLength } from 'class-validator';

export class CreateUserDto {
  @IsString()
  @MinLength(2)
  name: string;

  @IsEmail()
  email: string;
}

Line-by-line walkthrough

1. 1. The NestJS Holy Trinity 🔺
2. 2. 1. MODULE — wires everything together
3. 3. Decorator that adds metadata or behavior
4. 4.
5. 5.
6. 6.
7. 7. Exporting for use in other files
8. 8.
9. 9. 2. CONTROLLER — handles HTTP requests (the front door 🚪)
10. 10. Decorator that adds metadata or behavior
11. 11. Exporting for use in other files
12. 12.
13. 13. ↑ NestJS auto-injects this! Magic! ✨
14. 14.
15. 15. Decorator that adds metadata or behavior
16. 16.
17. 17. Returning a value
18. 18. Closing block
19. 19.
20. 20. Decorator that adds metadata or behavior
21. 21.
22. 22. Returning a value
23. 23. Closing block
24. 24.
25. 25. Decorator that adds metadata or behavior
26. 26.
27. 27. Returning a value
28. 28. Closing block
29. 29. Closing block
30. 30.
31. 31. 3. SERVICE — business logic (the brain 🧠)
32. 32. Decorator that adds metadata or behavior
33. 33. Exporting for use in other files
34. 34.
35. 35.
36. 36.
37. 37. Returning a value
38. 38. Closing block
39. 39.
40. 40.
41. 41. Returning a value
42. 42. Closing block
43. 43.
44. 44.
45. 45. Returning a value
46. 46. Closing block
47. 47. Closing block
48. 48.
49. 49. DTO — validate input 📋
50. 50. Importing required dependencies
51. 51.
52. 52. Exporting for use in other files
53. 53. Decorator that adds metadata or behavior
54. 54. Decorator that adds metadata or behavior
55. 55.
56. 56.
57. 57. Decorator that adds metadata or behavior
58. 58.
59. 59. Closing block

Spot the bug

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

  @Get()
  findAll() {
    return this.userService.findAll();
  }
}

export class UserService {
  findAll() { return []; }
}

Explain like I'm 5

Fun fact

Hands-on challenge

More resources

• NestJS Official Documentation (NestJS Official)
• NestJS in 100 Seconds (Fireship)
• NestJS First Steps (NestJS Official)