NestJS Microservices: Build a Distributed Job Engine

Master NestJS Microservices by Building a Scalable, Distributed Job Engine with gRPC, Pulsar, Kubernetes & AWS

What you'll learn

• Build a fully functional distributed job engine using NestJS microservices
• Structure a scalable monorepo using Nx for efficient development and dependency management
• Implement gRPC as the transport layer for high-performance, low-latency communication
• Use Apache Pulsar for distributed messaging and reliable job processing
• Expose a GraphQL API for flexible data access and interaction
• Secure microservices with JWT authentication and HTTP-only cookies
• Apply object-oriented design principles to keep code modular, reusable, and maintainable
• Implement horizontal scaling to efficiently handle high workloads
• Optimize Dockerization with Nx libraries and independent package.json files
• Use Prisma ORM and Drizzle ORM with PostgreSQL for robust database management
• Deploy microservices to Kubernetes with best practices for production readiness
• Set up a production-grade AWS deployment with a custom domain and SSL encryption
• Gain hands-on experience designing, developing, and deploying real-world NestJS microservices

Requirements

• Basic knowledge of JavaScript or TypeScript
• Familiarity with Node.js and backend development concepts
• Understanding of REST APIs (GraphQL knowledge is helpful but not required)
• Some experience with databases like PostgreSQL is beneficial
• Basic understanding of Docker and containerization concepts
• Familiarity with basic NestJS concepts
• Familiarity with Kubernetes for deployment

Description

Master the art of building scalable, distributed microservices with NestJS by developing a fully functional job engine from the ground up. This course is designed to teach you NestJS microservices the right way, covering everything from architecture and design to deployment and scaling in production.

You’ll start by setting up a monorepo with Nx, allowing you to manage multiple services within a single codebase efficiently. Using gRPC as the transport layer, you'll enable high-performance, low-latency communication between services. The course dives into Apache Pulsar, a powerful distributed messaging system, that allows us to add multiple consumers to a shared queue & achieve scale. You'll also expose a GraphQL API, providing a flexible and efficient way to interact with your microservices.

Security is a core focus, and you'll implement JWT-based authentication with secure, HTTP-only cookies. Throughout the course, everything is built using object-oriented design principles, ensuring a clean, modular, and reusable codebase that follows DRY (Don’t Repeat Yourself) principles. This makes your codebase more maintainable as it scales.

You'll also optimize your Docker setup, using Nx libraries with separate package.json files for better dependency management. Horizontal scaling techniques will ensure your services can handle increasing workloads efficiently. As your job engine matures, you'll implement job state tracking, allowing you to monitor job progress.

For database management, you’ll use Prisma ORM and Drizzle ORM with PostgreSQL, ensuring type safety, migrations, and optimized queries. Finally, you’ll deploy everything to Kubernetes, taking your microservices to production with AWS, a custom domain, and SSL encryption.

By the end of this course, you'll have a fully operational distributed job engine with robust state tracking and the expertise to design, develop, and deploy scalable NestJS microservices in real-world production environments.

Who this course is for:

• Backend developers looking to achieve scale through Node.js
• Backend developers looking to master NestJS microservices
• Software engineers interested in learning gRPC and Apache Pulsar for high-performance communication and job processing
• Developers interested in building real-world production-grade applications with NestJS
• Anyone looking to gain hands-on experience with modern backend technologies like Prisma, Drizzle, Docker, and GraphQL
• Those who want to improve their ability to design scalable, maintainable, and efficient microservices architectures