Building Microservices with NestJS is an intermediate course in splitting a backend into small services with NestJS 12, from service design and an API gateway to messaging with RabbitMQ, NATS and gRPC, sagas for cross-service data, tracing and deployment with Docker Compose. It suits backend developers who already use NestJS, tech leads and DevOps teams.
Microservices split a large system into small services by business function, such as users, products, orders and payments. Each service can be developed, deployed and scaled on its own, in exchange for more complex communication between services, data consistency and troubleshooting. NestJS provides the @nestjs/microservices package, which supports several transports with the same programming style, making it a good fit for teams building this kind of system on Node.js.
This course builds on Basic NestJS and Advanced NestJS using current NestJS 12. Learners design service boundaries, build microservices and an API gateway, communicate over TCP, RabbitMQ, NATS and gRPC, give each service its own database and handle cross-service transactions with sagas and the outbox pattern. They then make the system resilient and observable with logs and tracing, and finish by deploying a complete store system with Docker Compose. (3 days, 6 hours per day, 18 hours in total, Intermediate level.)
Course Details
This course is the 2026 edition of Building Microservices with NestJS. It runs for 3 days, 6 hours per day (18 hours in total, 09:00-16:00), as lectures with labs. Intermediate level. The previous edition built microservices over TCP and deployed with PM2. This edition moves to NestJS 12, which uses ES modules, organises the project as a monorepo and adds an API gateway, RabbitMQ, NATS, gRPC,
a database per service, sagas and the outbox pattern, resilience, health checks and distributed tracing with OpenTelemetry, then deploys the whole system with Docker Compose. It builds on Basic NestJS and Advanced NestJS, which already cover ORMs, JWT and OpenAPI. Every lab uses open source or free tools that run on the learner's own machine. Learners take home a lab guide and the source code of a microservices store system.
Section 1: What Microservices Are and When to Use Them
Section 2: Lab: Setting Up a Monorepo
Section 3: Lab: A First Microservice over TCP
Section 4: Message Patterns and Event Patterns
Section 5: Lab: API Gateway and Hybrid Applications
Section 6: Lab: Messaging with RabbitMQ
Section 7: NATS, Redis and an Overview of Kafka
Section 8: Lab: gRPC and Protocol Buffers
Section 9: A Database per Service
Section 10: Workshop: Sagas and the Outbox Pattern
Section 11: Lab: Resilience in a Multi-Service System
Section 12: Security between Services
Section 13: Lab: Health Checks, Logs and Tracing
Section 14: Lab: Testing and Deploying with Docker Compose
Section 15: Workshop: A Microservices Store Capstone
No public rounds are open right now. Join the waiting list and we will contact you first when the next round opens, or ask us on LINE. Or call 02-570-8449 or 088-807-9770
A monolith keeps every part of the system in one application deployed as a single unit: simple to start, but harder to change and scale as it grows. Microservices split the system into small services by business function, such as users, products and orders, each with its own database and each developed, deployed and scaled independently. The trade-off is more complex communication, troubleshooting and data consistency, so small teams or young systems may start with a modular monolith.
The @nestjs/microservices package supports several transports, including TCP, Redis, NATS, MQTT, RabbitMQ, Kafka and gRPC, all written in the same style. There are two main styles: request-response, sent with send and handled with @MessagePattern when a reply is needed, and event-based, sent with emit and handled with @EventPattern when you only announce that something happened. gRPC uses .proto files as the contract between services, and external clients usually call a REST API exposed by an API gateway.
When each service owns its database, one transaction cannot cover everything. Instead, a saga splits the work into local steps in each service, and if a step fails it runs compensating actions to undo earlier steps, such as returning stock when payment fails. Combine it with the outbox pattern, which stores events in the same database as the main data before publishing them, and design handlers to process repeated messages safely (idempotency).
The course writes a multi-stage Dockerfile for each service and combines the services, message brokers and databases in a docker-compose.yml file so the whole system starts with one command. Health checks use @nestjs/terminus, and graceful shutdown lets services stop cleanly. PM2 is still an option for a single server, and larger systems can move on to Kubernetes.
It suits backend developers who already use NestJS, learners who have completed Basic NestJS or Advanced NestJS, software architects and tech leads, and DevOps teams who run multi-service systems. You should be able to write NestJS and TypeScript, have built REST APIs and used a database, and know basic Docker commands.
Bring a laptop that can run the Node.js LTS release, the Nest CLI, VS Code and Docker Desktop. 16 GB of RAM is recommended, because several services run alongside RabbitMQ, NATS, Redis, PostgreSQL and Jaeger on Docker on one machine. All tools are open source or free, and no cloud account is needed.
Node.js lets the JavaScript that developers know from web pages run on the server and on their own machines, from file-handling scripts and command-line tools to web APIs and real-time systems. Current versions include more built-in tools, such as fetch, a…
The MEVN stack is a set of technologies for full-stack web development in a single language, JavaScript. It brings together MongoDB, a NoSQL database that stores data as documents, Express, a framework for building REST APIs on Node.js, and Vue.js, a popular…
Many modern applications need to store data whose structure changes often or is nested several levels deep, such as product data where each type has different attributes, user profiles or logs from different systems. A NoSQL database such as MongoDB stores…
