MERN Stack with Microservices & Gen AI

You can write modern, type-safe asynchronous JavaScript using ES6+ syntax, clean module structures, and strict TypeScript configurations.

1. Modern JavaScript: ES6+, functions and modules90 min
   • arrow functions and lexical this binding
   • ES modules import and export syntax
   • template literals and tagged template functions
   • default and named export patterns
   • block-scoped declarations with let and const
2. Arrays, objects, destructuring and the spread operator90 min
   • nested object destructuring and renaming
   • rest and spread parameters in function calls
   • array methods map, filter, and reduce chaining
   • shallow versus deep cloning techniques
   • optional chaining and nullish coalescing operators
3. Asynchronous JavaScript: callbacks, promises and async/await120 min
   • event loop execution order and call stack
   • Promise constructor, chaining, and settlement
   • async/await syntax with try/catch error handling
   • Promise.all and Promise.allSettled concurrency
   • microtasks queue versus macrotasks queue
4. The DOM, events and fetch90 min
   • DOM element selection and attribute manipulation
   • event delegation, bubbling, and capture phases
   • AbortController with fetch API for request cancellation
   • FormData handling and multipart submissions
   • browser storage with localStorage and sessionStorage
5. TypeScript fundamentals for full-stack development120 min
   • primitive, union, and intersection types
   • interfaces versus type aliases definitions
   • tsconfig.json strict compiler flags configuration
   • type narrowing with typeof and instanceof guards
   • generics in functions and basic classes
6. Debugging and tooling for TypeScript apps90 min
   • source maps configuration for debugging
   • ESLint and Prettier code formatting setup
   • VS Code workspace settings and extensions
   • handling unknown and any types safely
   • reading compiler error messages and stack traces

Hands-on project: Refactor a legacy CommonJS monolithic script into a modular TypeScript application utilizing strict interfaces, custom type guards, and native fetch wrappers.

You can build interactive, type-safe user interfaces with React components, custom hooks, form validation, and optimized remote data fetching.

1. React fundamentals: components and JSX120 min
   • JSX transformation and virtual DOM element trees
   • functional components and props typing
   • conditional rendering patterns and short-circuit evaluation
   • list rendering with unique key props
   • fragment syntax and component composition
2. Props, state and Hooks120 min
   • useState hook for local component state
   • useEffect lifecycles, dependencies, and cleanup functions
   • useRef hook for DOM element referencing
   • building custom hooks for reusable business logic
   • useMemo and useCallback optimization hooks
3. Routing, forms and state management120 min
   • React Router DOM nested layouts and loaders
   • React Hook Form registration and handleSubmit
   • Zod schema validation integration with forms
   • Context API for global UI theme state
   • handling URL search params for filtering states
4. Calling APIs and React Query120 min
   • TanStack Query cache management and stale times
   • mutation handling, cache invalidation, and optimistic updates
   • loading skeleton and error boundary fallback states
   • infinite scrolling and pagination queries
   • axios interceptors for base URL and auth headers
5. Styling with Tailwind and building a real frontend120 min
   • Tailwind utility classes and responsive breakpoints
   • component composition and design token variables
   • accessibility roles, ARIA attributes, and keyboard navigation
   • handling dark mode toggles with class strategies
   • building reusable modal and dropdown primitives
6. Testing and production build for React apps90 min
   • Vitest and React Testing Library setup
   • testing component rendering and user event clicks
   • mocking API requests with MSW (Mock Service Worker)
   • Vite production bundling and code splitting
   • analyzing bundle size and chunk optimization

Hands-on project: Build a responsive dashboard SPA with React, TypeScript, and Tailwind CSS featuring data tables, optimistic updates, and persistent client-side routing.

You can build non-blocking backend runtimes using Node.js event loops, stream pipelines, module resolution, and environment configurations.

1. The Node.js runtime and the event loop120 min
   • V8 engine execution and libuv worker thread pool
   • phases of the event loop (timers, poll, check)
   • process.nextTick versus setImmediate execution order
   • handling blocking synchronous operations correctly
   • monitoring memory usage with process.memoryUsage
2. Modules, npm and the package ecosystem90 min
   • CommonJS require/module.exports versus ESM import/export
   • package.json semver versioning rules and lockfiles
   • publishing and consuming private npm packages
   • managing dependencies, peer dependencies, and devDependencies
   • resolving module path aliasing in Node
3. Asynchronous Node and streams120 min
   • readable, writable, and transform stream mechanics
   • pipeline error handling and stream completion events
   • backpressure management during high throughput data flows
   • zlib compression stream integration
   • reading line-by-line with readline modules
4. The file system and environment configuration90 min
   • fs/promises file reading, writing, and directory scanning
   • path module resolution and cross-platform paths
   • dotenv configuration validation and parsing
   • watching file changes with fs.watch
   • handling process exit signals gracefully
5. Building a basic HTTP server90 min
   • http.createServer module usage without frameworks
   • request URL parsing and incoming header inspection
   • handling JSON payloads and chunked request bodies
   • setting response status codes and content type headers
   • implementing simple request routing manually
6. Logging, diagnostics and error handling in Node90 min
   • uncaughtException and unhandledRejection handlers
   • structured JSON logging with Pino
   • diagnostic report generation
   • debugging Node apps with inspector flags
   • profiling CPU bottlenecks in Node runtimes

Hands-on project: Build a CLI file processor in Node.js that ingests large CSV datasets using readable and writable streams, transforming records concurrently.

You can architect clean, modular RESTful APIs using Express.js middleware pipelines, centralized error handlers, and robust request validation.

1. Express fundamentals and routing120 min
   • express.Router modular route mounting
   • route parameters, wildcards, and query string parsing
   • response methods json, send, status, and redirect
   • handling 404 routes cleanly
   • async handler wrappers to catch promise rejections
2. Middleware and the request lifecycle120 min
   • execution order of application and router middleware
   • modifying request and response objects down the chain
   • third-party middleware integration (morgan, cors)
   • conditional middleware execution based on paths
   • response lifecycle completion checks with res.headersSent
3. Building RESTful APIs120 min
   • resource naming conventions and pluralization
   • pagination, sorting, and filtering query design patterns
   • idempotency principles across HTTP methods
   • HATEOAS and standard API response envelopes
   • handling bulk operations and batch requests
4. Validation and error handling120 min
   • request validation middleware using Zod schemas
   • custom AppError and OperationalError base classes
   • global Express error handling middleware with status codes
   • sanitizing validation error messages for clients
   • operational versus programmer error distinction
5. Structuring a production Express app120 min
   • feature-based and layered directory structures
   • service layer decoupling from HTTP transports
   • dependency injection patterns in Node
   • graceful shutdown handling for HTTP servers
   • configuration management via validated environment objects
6. Testing Express APIs90 min
   • Supertest integration testing setup with Express
   • mocking service dependencies in API tests
   • testing error responses and validation failures
   • database test seeding and teardown hooks
   • measuring test coverage for backend routes

Hands-on project: Build a production-grade Express REST API with layered architecture (controllers, services, repositories), custom logging middleware, and Zod validation.

You can model complex document schemas, execute aggregation pipelines, and optimize query indexing with MongoDB and Mongoose.

1. NoSQL and document databases120 min
   • BSON data types and 16MB document size limits
   • embedding versus referencing data modeling patterns
   • ACID transactions across multiple documents in MongoDB
   • capped collections and time-to-live indexes
   • replica set concepts for data availability
2. MongoDB CRUD and the query language120 min
   • query and projection operators ($gt, $in, $elemMatch)
   • update operators ($set, $push, $addToSet, $inc)
   • cursor methods limit, skip, sort, and batch sizing
   • bulk write operations for high throughput inserts
   • upsert flag usage in update queries
3. Mongoose schemas and models120 min
   • schema types, default values, and custom validators
   • virtual properties, getters, and setters
   • document and query middleware hooks (pre/post save)
   • discriminators for schema inheritance patterns
   • timestamps option configuration
4. Relationships, population and references120 min
   • ObjectId references and populate method usage
   • handling parent-child hierarchies and tree structures
   • optimizing populate queries with select fields
   • virtual population across collections
   • managing cascade deletes via Mongoose middleware
5. Aggregation, indexing and performance120 min
   • aggregation pipeline stages ($match, $group, $lookup, $project)
   • single-field, compound, and multikey indexes
   • text search indexes and scoring
   • explain plans analysis with executionStats
   • avoiding collection scans at scale
6. Database migration and maintenance90 min
   • handling schema version changes in production
   • data backfill scripts using cursor iteration
   • backup and restore procedures with mongodump
   • connection pooling configuration in Mongoose
   • monitoring database slow queries and connection drops

Hands-on project: Design a complete e-commerce product and inventory data schema in MongoDB with Mongoose pre-save hooks, compound indexes, and aggregation pipelines for analytics.

You can secure full-stack applications using stateless JWT authentication, password hashing, OAuth social logins, and role-based access control.

1. Authentication and authorization concepts90 min
   • stateless token authentication versus stateful sessions
   • session cookies versus local storage token holding
   • OWASP top 10 security risks in web applications
   • cross-site scripting (XSS) prevention strategies
   • cross-site request forgery (CSRF) mitigation
2. JWT-based authentication120 min
   • signing and verifying JSON Web Tokens with secret keys
   • access token short-life and refresh token rotation
   • token revocation strategies and blacklist stores
   • storing tokens securely in HTTP-only cookies
   • decoding claims and user payload attachment
3. Password hashing with bcrypt90 min
   • salt rounds generation and computational work factor
   • secure password comparison against database hashes
   • preventing timing attacks during password validation
   • enforcing strong password complexity policies
   • handling password reset token hashing
4. OAuth and social login with Passport120 min
   • OAuth 2.0 authorization code grant flow
   • Passport.js strategy configuration for Google login
   • linking social authentication profiles to local users
   • handling token exchange and user provisioning
   • state parameter validation in OAuth redirects
5. Securing APIs and role-based access120 min
   • Helmet.js HTTP header hardening configuration
   • rate limiting brute force attacks with express-rate-limit
   • role and permission checking middleware
   • input sanitization against NoSQL injection attacks
   • CORS policy configuration and origin whitelisting
6. Audit logging and security testing90 min
   • logging failed login attempts and suspicious traffic
   • dependency vulnerability scanning with npm audit
   • secret management and environment variable leakage prevention
   • penetration testing basic API endpoints
   • secure headers verification tools

Hands-on project: Implement a secure authentication service in Express with access/refresh token rotation, HTTP-only cookies, bcrypt password hashing, and RBAC middleware.

You can build bidirectional, real-time event-driven applications using WebSockets, Socket.io rooms, namespaces, and horizontal scaling adapters.

1. WebSockets and real-time communication90 min
   • HTTP polling versus WebSocket protocol handshake
   • WebSocket frame structure and ping/pong keepalives
   • connection lifecycle and handshake headers
   • handling network disconnections gracefully
   • security considerations for WebSocket endpoints
2. Socket.io fundamentals90 min
   • initializing Socket.io server alongside Express
   • client library connection and transport fallback
   • emitting and listening to custom named events
   • acknowledgments and callback functions in events
   • packet serialization and binary data transmission
3. Building chat and live features120 min
   • broadcasting messages to connected clients
   • handling client disconnection and automatic reconnection
   • state synchronization across active client sessions
   • implementing typing indicators with debounce
   • user presence tracking and online status lists
4. Rooms, namespaces and events90 min
   • joining and leaving dynamic Socket.io rooms
   • namespacing socket connections for logical separation
   • broadcasting messages within specific rooms only
   • managing room state in memory or Redis
   • authorization checks on room entry
5. Scaling real-time applications90 min
   • sticky sessions requirement on load balancers
   • Redis adapter setup for multi-node Socket.io scaling
   • handling high concurrency connection bottlenecks
   • load testing WebSocket servers with artillery
   • monitoring active socket connection counts
6. Testing real-time event flows60 min
   • setting up client test sockets in Jest or Vitest
   • testing event emission and response loops
   • simulating network drops in test suites
   • mocking Redis adapter in multi-node unit tests
   • debugging socket payload serialization issues

Hands-on project: Build a real-time collaborative chat application with Socket.io supporting private rooms, typing indicators, user presence lists, and connection recovery.

You can decompose monolithic applications into bounded microservices communicating over REST and gRPC with clear domain boundaries.

1. Monolith versus microservices90 min
   • trade-offs between monolithic and distributed architectures
   • organizational scaling and Conway's Law implications
   • when to transition away from a monolithic codebase
   • distributed system failure modes and fallback strategies
   • operational overhead of microservice fleets
2. Designing services and bounded contexts120 min
   • Domain-Driven Design tactical patterns and entities
   • identifying service boundaries using event storming
   • database-per-service isolation pattern
   • avoiding distributed monolith anti-patterns
   • shared library management across services
3. Building Node.js microservices120 min
   • scaffolding lightweight Node microservice templates
   • independent configuration management per service
   • health check endpoints and readiness probes
   • service telemetry and correlation ID propagation
   • graceful startup and shutdown sequences
4. Inter-service communication with REST and gRPC120 min
   • synchronous HTTP service discovery patterns
   • Protocol Buffers (.proto) schema definition language
   • generating TypeScript code from proto files
   • gRPC streaming (unary, client stream, server stream)
   • performance comparison between REST and gRPC
5. API design and versioning90 min
   • URL path versus header versioning strategies
   • backward compatibility principles in distributed APIs
   • contract testing with Pact across services
   • handling breaking changes in shared schemas
   • API documentation with OpenAPI and Swagger specs
6. Distributed tracing and debugging90 min
   • propagating request IDs across service boundaries
   • OpenTelemetry instrumentation for Node services
   • tracing HTTP and gRPC request lifecycles
   • aggregating logs from multiple service containers
   • identifying latency bottlenecks in distributed calls

Hands-on project: Refactor a monolithic e-commerce app into independent Node.js microservices for users, products, and orders communicating via HTTP and gRPC.

You can implement asynchronous event-driven architectures with RabbitMQ and Kafka, high-performance caching with Redis, and route traffic through an API gateway.

1. Asynchronous communication patterns90 min
   • pub/sub and point-to-point messaging paradigms
   • eventual consistency models in distributed apps
   • handling duplicate messages and ensuring idempotency
   • outbox pattern for reliable event publishing
   • message ordering guarantees in distributed queues
2. Message queues with RabbitMQ and Kafka120 min
   • RabbitMQ exchanges (direct, topic, fanout) and bindings
   • Kafka topics, partitions, and consumer groups
   • dead letter queues (DLQ) and retry backoff policies
   • message acknowledgment and manual commit strategies
   • scaling consumers across multiple container instances
3. Redis for caching and pub/sub120 min
   • Redis data structures (strings, hashes, sorted sets)
   • cache-aside, write-through, and cache invalidation patterns
   • Redis pub/sub channels for lightweight messaging
   • setting TTL expiration and memory eviction policies
   • distributed locking with Redlock algorithm
4. Event-driven microservices120 min
   • event sourcing architecture basics
   • CQRS (Command Query Responsibility Segregation) separation
   • handling schema evolution in published events
   • replay mechanisms for failed event streams
   • event bus abstraction layers in Node
5. API gateway and service coordination120 min
   • reverse proxy routing with Node and http-proxy-middleware
   • centralized authentication and JWT validation at gateway
   • circuit breaker pattern implementation with opossum
   • load balancing strategies across upstream services
   • request throttling and rate limiting at the edge
6. Operational resilience and testing90 min
   • chaos engineering principles for message queues
   • simulating broker outages and network partitions
   • monitoring consumer lag in Kafka and RabbitMQ
   • optimizing Redis memory usage under load
   • integration testing event-driven message flows

Hands-on project: Implement an event-driven messaging backbone using RabbitMQ for order fulfillment events, Redis for session caching and rate limiting, and an API Gateway for request routing.

You can containerize microservices with Docker, orchestrate deployments using Kubernetes, and automate delivery pipelines with GitHub Actions.

1. Containerising services with Docker120 min
   • writing optimized multi-stage Dockerfiles for Node
   • layer caching best practices to speed up builds
   • managing non-root user security permissions in containers
   • reducing final image size below 150MB
   • scanning container images for known vulnerabilities
2. Docker Compose for local microservices90 min
   • networking multiple containers in Docker Compose
   • volume mounts for source code hot reloading
   • environment variable injection and .env file loading
   • managing container startup dependencies with healthchecks
   • local persistence with named volumes
3. Kubernetes fundamentals120 min
   • Pods, Deployments, and ReplicaSets architecture
   • Services (ClusterIP, NodePort, LoadBalancer) networking
   • ConfigMaps and Secrets configuration management
   • ingress controllers and path-based routing rules
   • resource requests and limits allocation
4. Deploying to the cloud90 min
   • pushing images to private container registries
   • provisioning managed cloud Kubernetes clusters
   • managing persistent volume claims for databases
   • rolling updates and zero-downtime deployment strategies
   • troubleshooting crash loop backoff pod errors
5. CI/CD basics with GitHub Actions120 min
   • writing workflow YAML configuration files
   • automated testing, linting, and security scan steps
   • building and pushing container images on merge to main
   • managing GitHub repository secrets securely
   • deploying updates automatically to cloud clusters
6. Production monitoring and logging90 min
   • collecting container stdout logs with Fluentbit
   • setting up Prometheus metrics scraping for Node apps
   • visualizing service health on Grafana dashboards
   • configuring alerting rules for high error rates
   • pod liveness and readiness probe tuning

Hands-on project: Create multi-stage Dockerfiles for Node services under 150MB, configure Docker Compose for local multi-service testing, and deploy to a Kubernetes cluster with CI/CD.

You can integrate Large Language Models into applications using prompt engineering, vector embeddings, and direct API calls from Node.js.

1. What LLMs are and how they work90 min
   • transformer neural network architecture fundamentals
   • next-token prediction mechanism and probability distributions
   • temperature, top-p, and frequency penalty parameters
   • understanding model weights and training cutoffs
   • open-weights models versus proprietary hosted APIs
2. Prompt engineering for applications120 min
   • system and user prompt structuring best practices
   • few-shot prompting techniques with examples
   • chain-of-thought reasoning prompt construction
   • mitigating prompt injection vulnerabilities
   • enforcing structured JSON outputs from models
3. Calling LLM APIs from Node.js (OpenAI, Claude, Gemini)120 min
   • official SDK integration in Node.js runtime
   • handling API rate limits, backoff, and retries
   • streaming responses with Server-Sent Events (SSE)
   • managing timeout and network failure conditions
   • securely storing API keys in environment variables
4. Embeddings and vector representations90 min
   • high-dimensional vector space mathematical concepts
   • generating semantic embeddings via embedding APIs
   • calculating cosine similarity between vectors
   • dimensionality reduction and embedding normalization
   • semantic clustering of text documents
5. Tokens, context windows and cost90 min
   • tokenization algorithms (BPE) and token counting tools
   • managing context window limits and overflow errors
   • token budgeting and cost optimization strategies
   • summarizing long context histories dynamically
   • monitoring token usage per API request
6. Testing and evaluating LLM outputs90 min
   • evaluating deterministic outputs from stochastic models
   • unit testing prompt wrappers and API handlers
   • mocking LLM API responses in test suites
   • detecting hallucinations and factual drift
   • logging prompt/response pairs for quality review

Hands-on project: Build a Node.js utility script that connects to LLM APIs, generates text embeddings for document chunks, and calculates cosine similarities.

You can build advanced LLM pipelines, RAG systems, and vector search applications using LangChain.js and the Vercel AI SDK.

1. LangChain.js and the Vercel AI SDK120 min
   • core abstractions: models, prompt templates, and chains
   • Vercel AI SDK UI hooks and streamText server helpers
   • managing conversation history and memory stores
   • integrating AI SDK with React frontend components
   • handling streaming chat UI states on the client
2. Chains, prompts and memory120 min
   • LCEL (LangChain Expression Language) syntax
   • RunnablePassthrough and RunnableSequence composition
   • buffer memory and windowed history management
   • passing runtime variables into LangChain chains
   • error handling within LCEL pipeline steps
3. Retrieval-Augmented Generation (RAG)120 min
   • document loading and text chunking strategies
   • overlap configurations and semantic splitters
   • retriever query expansion and rewriting
   • grounding LLM responses with exact source citations
   • handling empty retrieval results gracefully
4. Vector databases (MongoDB Atlas Vector Search, Pinecone)120 min
   • configuring MongoDB Atlas Vector Search index definitions
   • approximate nearest neighbor (ANN) search algorithms
   • hybrid keyword and semantic vector search queries
   • managing vector index updates on document changes
   • performance tuning vector search parameters
5. Streaming, tools and function calling120 min
   • defining tool schemas for LLM function calling
   • handling model tool call request payloads in Node
   • executing local functions and returning tool outputs
   • streaming structured JSON outputs from models
   • validating tool arguments against schemas
6. Production optimization for RAG apps90 min
   • reranking retrieved chunks for higher relevance
   • caching frequent vector search query results
   • reducing latency in multi-step AI pipelines
   • monitoring vector database query performance
   • handling concurrent AI request spikes

Hands-on project: Build a Retrieval-Augmented Generation (RAG) backend service using LangChain.js, MongoDB Atlas Vector Search, and the Vercel AI SDK.

You can design autonomous AI agents with specialized tool loops and package them as dedicated AI microservices.

1. Building AI agents and tool use90 min
   • ReAct (Reason + Act) agent loop architectural pattern
   • managing multi-step tool execution sequences
   • preventing infinite agent execution loops with step limits
   • handling tool execution errors inside agent loops
   • logging agent thought processes for debugging
2. Designing an AI-powered Node microservice120 min
   • encapsulating LLM logic in dedicated microservices
   • asynchronous job queues for heavy AI processing tasks
   • service-to-service AI communication via gRPC
   • rate limiting AI service endpoints to control cost
   • health checks and circuit breakers for AI backends
3. Combining RAG with your own data90 min
   • dynamic context injection based on user intent classification
   • reranking retrieved chunks for maximum relevance
   • handling stale vector embeddings in the background
   • multi-tenant data isolation in vector search
   • auditing retrieved documents for sensitive data leaks
4. Streaming responses and guardrails90 min
   • content filtering and input sanitization for AI prompts
   • output validation against strict JSON schemas
   • streaming token chunks to frontend clients via WebSockets
   • detecting and blocking toxic or harmful model outputs
   • fallback mechanisms when models return malformed data
5. Evaluating and improving AI features90 min
   • evaluating agent success rates and hallucination metrics
   • logging prompts, tools, and responses for auditing
   • prompt versioning and regression testing frameworks
   • tracking token costs per user session
   • collecting user feedback ratings on AI responses
6. Security and compliance in AI microservices60 min
   • preventing indirect prompt injection attacks via user data
   • masking PII before sending text to third-party LLMs
   • managing API key rotation securely in Kubernetes
   • compliance requirements for data retention in AI apps
   • network security policies for AI backend services

Hands-on project: Build an autonomous AI support agent microservice that queries internal databases, invokes external APIs, and returns validated answers.

You can design, build, containerize, and deploy a production-grade full-stack MERN application integrating microservices, real-time sockets, and Generative AI features.

1. Plan a full-stack, microservices-based product120 min
   • system architecture design and data flow diagramming
   • defining service boundaries, APIs, and event contracts
   • task breakdown and Git branching strategy for teams
   • database schema planning across microservices
   • setting up the monorepo or multi-repo project structure
2. Build the React frontend and Node microservices120 min
   • implementing React UI with Tailwind and state management
   • building core Node microservices with Express and TypeScript
   • connecting services via REST and gRPC protocols
   • integrating MongoDB persistence and Mongoose models
   • implementing centralized error handling and logging
3. Add auth, real-time and an AI feature120 min
   • integrating JWT authentication and RBAC across services
   • adding Socket.io for real-time collaborative updates
   • implementing LangChain.js RAG assistant with vector search
   • setting up Redis caching for high-frequency queries
   • configuring message queues for asynchronous background tasks
4. Containerise, deploy and document120 min
   • writing multi-service Docker Compose manifests
   • deploying container workloads to cloud infrastructure
   • configuring environment variables and secrets in production
   • writing comprehensive README and API documentation
   • verifying health checks and monitoring dashboards
5. Portfolio, GitHub, mock interviews and career prep120 min
   • GitHub repository polishing, tagging, and pinning
   • resume and LinkedIn profile optimization for full-stack roles
   • mock technical interviews covering MERN and microservices
   • system design interview walkthrough and Q&A prep
   • behavioral interview preparation for product companies
6. Final project review and graduation60 min
   • code review feedback and refactoring recommendations
   • performance audit of deployed capstone applications
   • certificate issuance and alumni network onboarding
   • continuing learning paths in advanced cloud architecture
   • celebrating graduation and career launch

Hands-on project: Build and deploy an end-to-end multi-service MERN application featuring React frontend, Node microservices, RabbitMQ messaging, Redis caching, MongoDB persistence, and an AI RAG assistant, containerized via Docker and deployed to the cloud.