Learn NestJS (the modern backend framework built on Node.js and TypeScript) from the fundamentals to production-grade: pre-requisites & environment setup, history & background, core concepts & main architecture, building your first application, controllers & routing, providers & dependency injection, data access & persistence, validation & exception handling, configuration & environment management, logging monitoring & health, transaction & persistence advanced, background jobs & scheduling, security & authentication, oauth2 openid connect & api security, api gateway & microservices, graphql & api integration, performance optimization, testing & quality assurance, architecture & design patterns, modern tooling & build automation, containerization & cloud deployment, ci/cd & devops practices, observability & production support, through to stable modern features & future trends, in 24 episodes total.
Before touching NestJS, you need to master TypeScript, OOP concepts, dependency injection, and the basics of HTTP and REST APIs. In this episode you'll also set up Node.js LTS, an editor, the Nest CLI, and the local database needed to follow the entire series.

This episode traces the evolution of the Node.js backend from Express to the birth of NestJS, the goals of modular and scalable architecture, and a comparison with Express, Koa, and other backend frameworks to understand when and why NestJS is needed.

This episode dissects the core NestJS architecture: how the framework works behind the scenes as an Express wrapper, the role of module-controller-provider, the dependency injection container, the application lifecycle, and the pipes, guards, filters, and interceptors components.

This episode walks you through creating your first NestJS project with the Nest CLI, understanding the src/app.module.ts and main.ts structure, running the application, checking the basic endpoint, and applying initial configuration with @nestjs/config.

This episode covers the controller as the layer that handles HTTP requests: creating controllers and route handlers, using the GET POST PUT DELETE PATCH method decorators, reading route parameters, query parameters, and body, plus setting status codes and serialization.

This episode covers providers as the core of NestJS dependency injection: creating services, injecting them into controllers, understanding singleton and request-scoped scopes, custom providers, factory providers, alias providers, and module boundaries and sharing providers between modules.

This episode covers database integration in NestJS: choosing TypeORM, Sequelize, or Prisma; defining entities and migrations; using the repository pattern and query builder; and in-memory databases for development and testing.

This episode covers validation and error handling in NestJS: validation with class-validator and class-transformer, a global validation pipe, custom pipes, exception filters, and a consistent error response structure.

This episode covers NestJS configuration management: the @nestjs/config module, configuration modules, per-environment configuration, validation schemas, externalized configuration using environment variables, and secrets management practices in development and production.

This episode covers basic NestJS observability: the built-in Logger and a custom logger service, external logging integration with Winston and Pino, health checks using @nestjs/terminus, and basic metrics and observability patterns.
