NestJS - Modern backend Development 2026

Welcome to "NestJS CLI Starter: Exploring the Generated Code"! ?

In this video, we’ll walk through the NestJS CLI, generate a new project, and break down the automatically created files and folder structure. Whether you're new to NestJS or looking to understand how it organizes code, this tutorial will help you get started efficiently.

Topics Covered:
Installing NestJS CLI
Creating a new NestJS project
Understanding the project structure
Exploring main.ts, app.module.ts, app.controller.ts, and app.service.ts
Best practices for organizing your NestJS code

Why NestJS? – Introduction to NestJS

• Scalable & Modular – Follows a modular architecture for better project structure and maintainability.

• Built with TypeScript – Provides strong typing, better code organization, and improved developer experience.

• Follows MVC & SOLID Principles – Ensures clean, maintainable, and testable code.

• Dependency Injection – Promotes efficient and flexible application development.

• Built-in Support for Microservices – Seamlessly integrates with Kafka, RabbitMQ, and other messaging systems.

• Easy Database Integration – Supports TypeORM, Prisma, MongoDB, PostgreSQL, MySQL, and more.

• Native Support for GraphQL – First-class GraphQL integration for API development.

• Powerful Authentication & Security – Integrates with Passport.js, JWT, OAuth, and role-based access control (RBAC).

• Extensive CLI & Powerful Tools – Simplifies project scaffolding, testing, and deployment.

• Ideal for Enterprise Applications – Used by top companies for building robust backend solutions.

1. NestJS: Modular, opinionated, TypeScript-first, with built-in dependency injection.

2. Express: Minimalistic, flexible, JavaScript-based, requires manual structuring.

3. NestJS has built-in features like Guards, Interceptors, WebSockets, and Microservices.

4. Express is lightweight and faster but needs third-party libraries for advanced features.

5. Use NestJS for large-scale apps and Express for quick, minimal APIs.

In this video, we explore how to use the NestJS CLI to generate a project and organize your code using a modular structure. ? Learn how to structure your NestJS application efficiently for scalability and maintainability.

Topics Covered:
Installing and using the NestJS CLI
Creating a new NestJS project
Understanding modules, controllers, and services
Best practices for modular architecture
Generating components with the CLI for clean code organization

In this video, we set up a baseline NestJS project with all the essential tools and libraries for a smooth development workflow. Whether you're a beginner or an experienced developer, this guide will help you quickly scaffold a structured NestJS project with best practices.

What You'll Learn:

Installing and configuring NestJS CLI
Setting up ESLint & Prettier for code quality
Configuring Husky & lint-staged for Git hooks
Setting up Jest for unit and integration testing

In this NestJS tutorial, we will build a REST API with full CRUD operations using in-memory data storage. This is perfect for learning how to structure a backend service before integrating a database!

What You’ll Learn:
Setting up a NestJS project
Creating a Controller, Service, and Module
Implementing CRUD operations (Create, Read, Update, Delete)
Using in-memory storage (No database required)
Testing API endpoints with Postman

In this tutorial, we will explore how to build RESTful APIs in NestJS using Controllers and Services.

What You’ll Learn:
Understanding the role of Controllers in NestJS
Creating Service classes for business logic
Using Dependency Injection in NestJS

Handling GET, POST, PUT, DELETE API requests
Connecting to a database (optional)

1. Learn how incoming HTTP requests are handled in a NestJS application

2. See how the request passes through middleware, guards, and interceptors

3. Understand the role of controllers and how they route requests

4. Explore how services process business logic before returning a response

5. Get a clear view of how NestJS organizes and manages the request/response flow behind the scenes

1. Kickstarting Your NestJS App with the CLI
   Learn how to install the NestJS CLI and generate a new project from scratch.

2. Exploring NestJS Project Structure Generated by the CLI
   Understand the default files and folders created by the CLI and how they fit into the NestJS framework.

3. Creating Modules, Controllers & Services Using NestJS CLI
   Use CLI commands to generate core components and see how they interact in a NestJS application.

4. Organizing Your Code the NestJS Way (with CLI Tools)
   Discover how to structure your app with a modular approach using CLI to keep your codebase clean and scalable.

1. Understand the role of middleware in intercepting requests and performing pre-processing tasks (e.g., logging, request validation).

2. Learn how to create custom middleware and apply it globally or to specific routes in your application.

3. Dive into Auth Guards to protect routes and implement authentication and authorization checks.

4. Explore the core components involved: Controllers, Services, and Modules working together with Middleware and Guards.

5. Discover how to apply guards in different scenarios (e.g., JWT authentication, role-based access control).

1. Learn how to integrate Swagger into your NestJS application for automatic API documentation generation.

2. Understand the process of setting up Swagger and configuring it within your NestJS project.

3. Explore how to document routes, models, and endpoints using decorators like @ApiOperation(), @ApiResponse(), and @ApiTags().

4. Discover how to customize and improve the user experience of your API documentation through Swagger UI.

5. Understand how to generate interactive API documentation that allows users to test API endpoints directly from the documentation page.

What Students Will Learn:

• Understand the concept of Dependency Injection (DI) and its role in software design

• Learn how NestJS implements DI using its own framework built on TypeScript and decorators

• Explore how the NestJS Inversion of Control (IoC) container works to manage dependencies

• Use decorators like @Injectable() and @Inject() to define and use injectable classes

• Apply constructor-based injection to automatically resolve dependencies

• Understand how providers are registered and resolved within NestJS modules

• Learn the different provider scopes: Singleton, Transient, and Request-scoped

• Implement custom providers using useClass, useValue, useFactory, and useExisting

• Gain insight into how NestJS DI is influenced by Angular's DI system

• Recognize how DI supports modularity, testability, and clean architecture

What Students Will Learn:

• Understand the purpose and importance of exception handling in backend applications

• Learn what Exception Filters are in NestJS and how they fit into the framework's request lifecycle

• Use built-in NestJS exceptions like HttpException, BadRequestException, NotFoundException, etc.

• Create custom exception filters by implementing the ExceptionFilter interface

• Use the @Catch() decorator to bind filters to specific exception types

• Apply exception filters at the method, controller, and global levels

• Understand the structure of exception responses and how to customize error messages

• Improve error consistency and maintainability using centralized exception handling

• Best practices for logging and debugging within exception filters

• Learn how to handle unexpected system-level errors gracefully

What Students Will Learn:

• Understand what interceptors are and where they fit in the NestJS request-response cycle

• Learn the main use cases for interceptors:

  • Binding extra logic before/after method execution

  • Transforming result returned from a function

  • Extending basic method behavior (e.g., logging, caching, timeout handling)

• Create a custom interceptor by implementing the NestInterceptor interface

• Use the @UseInterceptors() decorator to apply interceptors at:

  • The method level

  • The controller level

  • Globally

What Students Will Learn / Review:

• Review the core architectural concepts of NestJS

• Revisit the purpose and usage of Modules, Controllers, and Services

• Understand how Dependency Injection (DI) ties everything together

• Recap Providers and their registration patterns

• Summarize Exception Filters: handling and customizing error responses

• Recap Interceptors: pre- and post-processing of requests/responses

• Review Middleware: request-level logic applied before route handling

• Revisit Pipes: input validation and data transformation

• Recap Guards: controlling access to routes based on custom logic

• Compare the roles of all core building blocks and when to use each

• Understand the request lifecycle in NestJS and how each layer interacts

• Solidify best practices for modular, testable, and maintainable architecture

What Students Will Learn:

• The importance of environment variables in managing configuration settings for different environments (development, production, etc.)

• How to set up environment variables in a NestJS application using .env files

• Use the @nestjs/config package to easily manage environment variables

• How to load environment variables into the NestJS application with the ConfigModule

• How to access environment variables in services, controllers, and modules

• How to define default values and validation for environment variables using @nestjs/config

• Best practices for managing sensitive information like API keys, database credentials, and secret keys securely

• How to use configuration validation to ensure that required environment variables are present and correctly formatted

• Understanding environment-specific configurations and how to load different configurations for different environments (e.g., local, staging, production)

What Students Will Learn:

• What Providers Are in NestJS and their role in Dependency Injection (DI)

• How to define a class as a provider using the @Injectable() decorator

• How to register providers in the providers array of NestJS modules

• Understanding different types of providers:

  • Class-based providers

  • Custom providers using useClass, useValue, useFactory, and useExisting

• How to use tokens for provider injection (e.g., for non-class-based providers)

• How to inject dependencies into services, controllers, and other classes using DI

• The concept of Provider Scopes and how they influence provider behavior:

  • Singleton scope (default behavior)

  • Transient scope (creates a new instance every time)

  • Request-scoped (creates a new instance per request)

What Students Will Learn / Review:

• Architecture Overview:

  • Recap the modular architecture of NestJS and its core components: Modules, Controllers, Services, Providers, Pipes, Guards, Interceptors, and Middleware

  • Understand the role of Dependency Injection in NestJS and how it enables flexibility and maintainability

• Advanced Dependency Injection:

  • Review custom providers using different methods like useClass, useFactory, useValue, and useExisting

  • Understand provider scopes: Singleton, Request-scoped, and Transient

  • Learn how to manage dynamic providers and use tokens for advanced DI scenarios

• Error Handling and Exception Filters:

  • Review the concept of Exception Filters and how to handle errors gracefully in NestJS

  • Learn how to create custom exception filters and handle different error types in the application

• Interceptors and Advanced Request Handling:

  • Recap how interceptors can transform the request/response cycle, apply logging, handle caching, and more

  • Understand how interceptors can be used for cross-cutting concerns like logging, transformation, and timeouts

What Students Will Learn:

• Introduction to NX and PNPM:

  • Learn about NX as a tool for managing monorepos with multiple projects and libraries.

  • Understand the benefits of PNPM for fast, efficient dependency management in monorepos.

• Setting Up NX Workspace with PNPM:

  • Create a new NX workspace for NestJS applications using the @nrwl/nest preset.

  • Set up PNPM as the default package manager during workspace initialization.

  • Configure the workspace to work efficiently with PNPM for dependency management.

• Creating and Organizing NestJS Applications:

  • Generate multiple NestJS applications (e.g., demo1, demo2) in the NX workspace.

  • Structure the workspace to have separate apps for different demos (e.g., Dependency Injection, Exception Filters).

• Managing Dependencies with PNPM:

  • Use PNPM to install and manage dependencies for the entire workspace.

  • Learn how PNPM optimizes the installation process by linking shared dependencies, saving disk space, and improving performance.

• Creating and Using NX Libraries:

  • Generate shared libraries that can be used by multiple applications within the workspace.

  • Learn how to structure and import shared code (e.g., utility functions, DTOs, services) across multiple NestJS applications.

What Students Will Learn:

• Introduction to NX and PNPM:

  • Learn about NX as a tool for managing monorepos with multiple projects and libraries.

  • Understand the benefits of PNPM for fast, efficient dependency management in monorepos.

• Setting Up NX Workspace with PNPM:

  • Create a new NX workspace for NestJS applications using the @nrwl/nest preset.

  • Set up PNPM as the default package manager during workspace initialization.

  • Configure the workspace to work efficiently with PNPM for dependency management.

• Creating and Organizing NestJS Applications:

  • Generate multiple NestJS applications (e.g., demo1, demo2) in the NX workspace.

  • Structure the workspace to have separate apps for different demos (e.g., Dependency Injection, Exception Filters).

• Managing Dependencies with PNPM:

  • Use PNPM to install and manage dependencies for the entire workspace.

  • Learn how PNPM optimizes the installation process by linking shared dependencies, saving disk space, and improving performance.

• Creating and Using NX Libraries:

  • Generate shared libraries that can be used by multiple applications within the workspace.

  • Learn how to structure and import shared code (e.g., utility functions, DTOs, services) across multiple NestJS applications.

What Students Will Learn

• DTOs (Data Transfer Objects):

  • Understand the role of DTOs in NestJS and why they are essential for validation and data structure.

• Built-in Validation with NestJS:

  • Learn how to use class-validator and class-transformer to apply validation rules to DTOs.

  • Apply decorators like @IsString(), @IsInt(), @IsNotEmpty(), etc., to define validation rules on DTO properties.

• Advanced Validation Techniques:

  • Use custom validation decorators for complex or domain-specific validation logic.

  • Implement asynchronous validation for checking data asynchronously (e.g., unique email or username checks).

• Error Handling and Response:

  • Learn how to handle validation errors gracefully and send appropriate error responses to the client.

  • Customize validation error messages for better UX.

Advanced Swagger Setup in NestJS:

• Customizing Swagger Documentation:

  • Learn how to customize the Swagger UI to match your project's branding and layout.

  • Understand how to customize metadata such as title, version, description, and more.

  • Configure custom themes for Swagger documentation to create a unique API documentation experience.

• Grouping Endpoints with Tags:

  • Learn how to organize your Swagger UI by grouping endpoints using tags.

• Using API Response and Request Examples:

  • Providing Request/Response Examples in Swagger:

    • Learn how to document request and response bodies using the @ApiResponse() and @ApiOperation() decorators.

    • Provide example values for your API requests and responses to improve clarity for users consuming your API.

What Students Will Learn:

• Designing API Endpoints: Learn how to design efficient RESTful API endpoints for search, sort, and filter functionality in a NestJS application.

• Handling Query Parameters: Understand how to handle query parameters in NestJS controllers to process search, sorting, and filtering logic.

• Search Implementation: Implement the search functionality to allow users to find data based on a search term (e.g., searching for products by name).

• Sorting Logic: Add sorting capabilities to allow users to sort data by different fields (e.g., sorting products by price or name).

• Filtering Capabilities: Build filtering logic to allow users to filter data by specific attributes (e.g., filtering products by category, availability, or price range).

• Performance Optimization: Learn how to efficiently query the database to handle large datasets with filtering, searching, and sorting.

• Using TypeORM for Querying: Implement efficient queries using TypeORM for handling the search, sort, and filter operations in a PostgreSQL or any relational database.

What Students Will Learn in Part 2:

• Dynamic search filters based on user input and query parameters

• Implementing multi-field sorting (ascending and descending)

• Handling pagination using limit and offset, or skip and take

• Combining search, sort, and pagination in a single API request

• Implementing full-text search with indexing for faster search queries

• Searching through related entities using joins (e.g., users and their posts)

• Handling edge cases with custom error handling (invalid page, sort field)

• Optimizing search queries to improve performance and reduce database load