How much Nest.js do you already have?
Be honest — nobody is watching. This only decides which chapters come first; every chapter stays open to you either way.
“I can build a working resource.”
Start with a controller, a provider and a module — the three pieces every Nest app is assembled from — and a small CRUD resource end to end.
- You know Node/Express and basic TypeScript
- You haven't organized an app around dependency injection before
- You want the core loop — controller, provider, module — once, in order
“I can ship a real Nest service.”
You can build a resource. Now learn the request lifecycle in depth, real auth, testing, and the repository patterns behind a production app.
- Comfortable with controllers, providers and modules
- You've hit a circular dependency or a scope bug and guessed your way out
- You want a tested, authenticated, deployable Nest service
“I can reason about the module graph.”
Microservices, GraphQL, custom decorators, and the module patterns behind a Nest app that's outgrown a single service.
- You can already ship a tested, authenticated Nest API
- You debug DI scope bugs and module boundaries, not just endpoint bugs
- You want the why under dynamic modules and Nest's microservice transporters
Not sure? Start at Beginner — every path opens at the section people usually skip.
Full syllabus
Everything each level eventually covers — ticked sections are written, the rest are still on the desk.
Beginner0 / 8 sections written
- Project setup & the Nest CLIcoming soon
Modules, controllers and providers — the overview
- Controllers & routingcoming soon
Decorators, request/response, DTOs (intro)
- Providers & dependency injectioncoming soon
The basics — @Injectable, constructor injection
- Modulescoming soon
Organizing an app, imports/exports/providers
- Basic validationcoming soon
class-validator, pipes (intro)
- Configurationcoming soon
@nestjs/config, environment variables
- Connecting a database (basics)coming soon
TypeORM/Prisma module setup
- Building your first CRUD resourcecoming soon
Putting it together: a full resource end to end
✅ Checkpoint: you can build a small CRUD resource with Nest's CLI, validated input, and a database connection, without copying a tutorial.
Intermediate0 / 10 sections written
- Dependency injection in depthcoming soon
Provider scopes, custom providers, injection tokens
- Pipes, guards & interceptorscoming soon
The request lifecycle, in order
- Middleware in Nestcoming soon
Global vs route-scoped middleware
- Exception filterscoming soon
Custom error handling
- Authenticationcoming soon
Passport strategies, JWT guards
- Authorizationcoming soon
Roles/permissions, custom guards
- Testing in Nestcoming soon
Unit tests, e2e tests, testing modules
- Database & repository patternscoming soon
TypeORM/Prisma repositories, transactions
- OpenAPI/Swagger integrationcoming soon
Documenting a Nest API
- Task scheduling & queuescoming soon
@nestjs/schedule, Bull integration
✅ Checkpoint: you can ship a tested, authenticated Nest API with guards, interceptors, and a real repository layer.
Advanced0 / 8 sections written
- Microservices with Nestcoming soon
Transporters (TCP/Redis/Kafka), hybrid apps
- GraphQL with Nestcoming soon
Code-first vs schema-first, resolvers
- WebSockets & gatewayscoming soon
Building a real-time gateway
- Custom decorators & metadata reflectioncoming soon
Param decorators, reflect-metadata
- Advanced module patternscoming soon
Dynamic modules, global modules
- Performance & cachingcoming soon
Interceptor-based caching, CacheModule
- Monorepo Nest appscoming soon
Nx/Nest workspaces
- Production readinesscoming soon
Health checks, graceful shutdown, logging
✅ Checkpoint: you can split a Nest app into microservices with a real transporter, add a GraphQL resolver layer, and defend a dynamic-module design.
- Dependency injection gets a beginner pass (just enough to build something) and a full intermediate chapter — DI is the one idea that makes or breaks how well you understand Nest.
- Auth and testing sit in intermediate, same as Node's plain-Express curriculum, because that's genuinely when real Nest work starts.
- Microservices and dynamic modules are the deepest, rarest layer — most working Nest developers never build them, but the advanced tier doesn't skip them.