MERN Bootcamp with Microservices DSA & System Design

You can write modern, strongly typed JavaScript with ES6+ features and set up a robust local development environment.

1. The JavaScript execution model and async programming3 hrs
   • call stack and event loop mechanics
   • callbacks and callback hell
   • Promises and async/await syntax
   • Promise.all and error handling in asynchronous flows
2. ES6+ features used in production React apps3 hrs
   • destructuring and spread/rest operators
   • arrow functions and lexical this binding
   • map, filter, and reduce array methods
   • modules with import and export statements
3. TypeScript type systems, interfaces and generics4 hrs
   • primitive types, arrays, and tuples
   • interfaces versus type aliases
   • union and intersection types
   • generic functions and constraints
4. Linting with ESLint, formatting with Prettier, and debugging in VS Code3 hrs
   • ESLint configuration and plugins
   • Prettier integration with editor config
   • VS Code debugger attach and breakpoints
   • husky pre-commit hook setup
5. Git workflows, branching, and pull requests3 hrs
   • feature branch git workflow
   • interactive rebasing and conflict resolution
   • pull request templates and code review etiquette
   • semantic commit messages

Hands-on project: Set up a fully typed TypeScript and Node starter repo with strict linting rules, automated pre-commit hooks, and a clean folder structure.

You can build complex, responsive single-page applications using React hooks, custom state management, and Tailwind CSS.

1. Component architecture and rendering cycles5 hrs
   • JSX transformation and virtual DOM reconciliation
   • props and children typing
   • component composition patterns
   • conditional rendering techniques
2. State management with useState, useEffect, and custom hooks6 hrs
   • useState setter functions and batching
   • useEffect lifecycle synchronization and dependency arrays
   • building reusable custom hooks
   • useMemo and useCallback optimization hooks
3. Routing with React Router and protected routes5 hrs
   • BrowserRouter and route definitions
   • dynamic route parameters and query strings
   • nested layouts and Outlet component
   • redirects and protected route wrappers
4. Form handling with React Hook Form and Zod validation6 hrs
   • register and handleSubmit functions
   • Zod schema validation integration
   • error message rendering and field states
   • controlled versus uncontrolled inputs
5. Consuming REST APIs with Axios and handling error states5 hrs
   • Axios instance configuration and base URLs
   • request and response interceptors
   • loading, success, and error state patterns
   • abort controllers for cancelling requests
6. Testing React components with Jest and React Testing Library5 hrs
   • render, screen, and fireEvent utilities
   • querying by role, text, and test-id
   • mocking API calls with Jest
   • testing user interactions and async state changes

Hands-on project: Build a feature-rich e-commerce storefront UI with product filtering, cart state management, and form validation using Zod.

You can build fast, secure REST APIs using Node.js and Express with robust middleware and global error handling.

1. Node.js runtime, modules, and event loop mechanics4 hrs
   • CommonJS versus ES Modules in Node
   • fs and path standard modules
   • libuv event loop phases and callbacks
   • process environment variables and configuration
2. Express architecture, routing, and controller patterns5 hrs
   • Express application initialization
   • router-level middleware structuring
   • controller function decoupling
   • request and response object methods
3. Writing custom middleware for logging, rate-limiting, and request parsing5 hrs
   • next function execution flow
   • morgan request logging middleware
   • express-rate-limit implementation
   • body parsing for JSON and URL-encoded payloads
4. Global error handling and validation pipelines5 hrs
   • four-argument error-handling middleware
   • custom AppError classes and status codes
   • request payload validation with Zod middleware
   • uncaught exception and unhandled rejection handlers
5. API documentation using Swagger/OpenAPI specs5 hrs
   • swagger-jsdoc configuration
   • swagger-ui-express mounting
   • documenting request bodies and responses
   • schema annotations in JSDoc comments

Hands-on project: Build a production-ready Express REST API with centralized error handling, request validation middleware, and OpenAPI documentation.

You can design efficient NoSQL data models, perform complex aggregations, and optimize query performance with indexes.

1. Document data modeling and schema design principles3 hrs
   • embedding versus referencing documents
   • one-to-many and many-to-many modeling in NoSQL
   • bounded growth patterns
   • normalization trade-offs in MongoDB
2. Mongoose schemas, models, and middleware hooks4 hrs
   • schema types and validation rules
   • pre and post save hooks
   • virtual properties and getters
   • static and instance methods on models
3. Advanced queries and MongoDB aggregation pipelines5 hrs
   • $match, $group, and $project stages
   • $lookup for joining collections
   • $facet for parallel multi-faceted queries
   • cursor iteration and stream handling
4. Indexing strategies and query performance tuning4 hrs
   • single field and compound indexes
   • explain plans and query execution stats
   • text search indexes
   • index creation overhead and storage considerations

Hands-on project: Design and implement a robust Mongoose ODM data layer with custom indexes and aggregation pipelines for reporting.

You can secure web applications using JWTs, secure cookie handling, password hashing with bcrypt, and role-based access control.

1. Understanding stateless authentication and session cookies2 hrs
   • stateful sessions versus token-based auth
   • HttpOnly, Secure, and SameSite cookie flags
   • XSS and CSRF attack vectors
   • cookie-parser middleware configuration
2. Password hashing and salting with bcrypt2 hrs
   • bcrypt cost factor and salting mechanism
   • asynchronous password hashing on registration
   • password comparison during login
   • timing attack prevention
3. JWT issuance, verification, and refresh token rotation2 hrs
   • jsonwebtoken library sign and verify methods
   • access token short lifespan configuration
   • refresh token storage and rotation strategies
   • token revocation patterns
4. Role-based access control (RBAC) and security headers2 hrs
   • user role schema fields
   • middleware to check user roles and permissions
   • helmet middleware for secure HTTP headers
   • CORS policy configuration and origin whitelisting

Hands-on project: Implement a secure auth service featuring HttpOnly refresh token cookies, bcrypt hashing, and RBAC middleware.

You can analyze algorithm time complexity using Big-O notation and solve fundamental array and string problems.

1. Big-O time and space complexity analysis3 hrs
   • growth rates and asymptotic notation
   • worst-case, best-case, and average-case analysis
   • space complexity and auxiliary memory
   • common complexity classes from O(1) to O(n!)
2. Arrays, strings, and the two-pointer technique4 hrs
   • array memory layout and pointer manipulation
   • opposite ends two-pointer pattern
   • same direction two-pointer pattern
   • string reversal and palindrome validation
3. Sliding window pattern for contiguous subarrays4 hrs
   • fixed-size sliding window problems
   • dynamic-size sliding window templates
   • subarray sum and substring character counts
   • optimizing O(n^2) brute force to O(n)
4. Hashing: HashMaps and frequency counting patterns5 hrs
   • JavaScript Map data structure performance
   • frequency map construction
   • two sum and anagram grouping problems
   • collision handling concepts

Hands-on project: Solve 30 core algorithmic problems on arrays and strings using JavaScript with optimal O(n) time complexity.

You can implement linked lists, stacks, queues, and binary search trees to solve complex algorithmic challenges.

1. Linked list manipulation and slow-fast pointer patterns4 hrs
   • singly and doubly linked list node structures
   • reversing a linked list iteratively and recursively
   • tortoise and hare cycle detection
   • finding middle nodes and merging sorted lists
2. Stacks, queues, and monotonic stack patterns4 hrs
   • stack LIFO operations and array implementations
   • queue FIFO operations and circular buffers
   • valid parenthesis matching
   • monotonic stack for next greater element
3. Recursion, backtracking, and divide-and-conquer4 hrs
   • base cases and recursive call stack frames
   • permutations and combinations backtracking
   • merge sort divide-and-conquer algorithm
   • memoization basics for recursive calls
4. Binary search trees and tree traversals (DFS/BFS)4 hrs
   • binary tree node structure and definitions
   • preorder, inorder, and postorder DFS traversals
   • level-order BFS traversal with queues
   • validating and searching binary search trees

Hands-on project: Implement custom stack, queue, and tree data structures in JavaScript and solve 25 corresponding LeetCode problems.

You can break down monolithic backends into decoupled microservices communicating via REST and message brokers like RabbitMQ.

1. Monoliths vs microservices and domain-driven design boundaries4 hrs
   • scaling bottlenecks in monolithic applications
   • bounded contexts and domain decomposition
   • database-per-service pattern
   • distributed transaction challenges
2. Asynchronous communication with RabbitMQ and event-driven patterns6 hrs
   • amqp protocol and RabbitMQ exchange types
   • publisher-subscriber and work queue patterns
   • message acknowledgment and dead-letter queues
   • handling idempotency in consumer services
3. API Gateway pattern, service routing, and load balancing5 hrs
   • API gateway responsibilities and routing rules
   • request aggregation and SSL termination
   • client-side versus server-side load balancing
   • rate limiting at the gateway level
4. Caching strategies with Redis for session stores and hot data5 hrs
   • Redis data types: strings, hashes, sets, sorted sets
   • cache-aside and write-through caching patterns
   • TTL expiration and memory eviction policies
   • distributed locking with Redlock
5. Resilience patterns: circuit breakers, retries, and timeouts4 hrs
   • cascading failures in distributed systems
   • circuit breaker state machine: closed, open, half-open
   • exponential backoff and jitter retry strategies
   • request timeouts and bulkhead isolation

Hands-on project: Refactor a monolithic e-commerce app into three decoupled microservices communicating asynchronously over RabbitMQ.

You can write clean, extensible object-oriented code applying SOLID principles and standard design patterns.

1. Object-oriented design principles and UML class diagrams2 hrs
   • encapsulation, inheritance, and polymorphism
   • composition over inheritance principle
   • UML class diagrams and relationship notations
   • identifying domain objects from requirements
2. SOLID principles with practical JavaScript examples2 hrs
   • Single Responsibility Principle
   • Open-Closed Principle
   • Liskov Substitution Principle
   • Interface Segregation and Dependency Inversion Principles
3. Creational, structural, and behavioral design patterns2 hrs
   • Singleton and Factory creational patterns
   • Adapter and Decorator structural patterns
   • Observer and Strategy behavioral patterns
   • when to apply patterns versus simple functions
4. Machine coding interview preparation and best practices2 hrs
   • clarifying requirements and edge cases
   • modular folder structure and code organization
   • writing testable and extensible classes
   • managing time during machine coding rounds

Hands-on project: Design and code a concurrency-safe parking lot or movie ticket booking system applying clean SOLID principles.

You can architect large-scale distributed systems, design for high availability, and reason about trade-offs.

1. Horizontal scaling, load balancing algorithms, and proxy servers3 hrs
   • vertical versus horizontal scaling trade-offs
   • round-robin, least connections, and IP hash load balancing
   • reverse proxies with Nginx
   • health checks and failover mechanisms
2. Database replication, sharding, and CAP theorem trade-offs4 hrs
   • leader-follower database replication
   • horizontal sharding and consistent hashing
   • CAP theorem: Consistency, Availability, Partition Tolerance
   • eventual consistency models
3. Content Delivery Networks (CDNs) and object storage3 hrs
   • CDN edge caching and cache invalidation
   • object storage architecture (AWS S3)
   • media optimization and streaming delivery
   • DNS routing and Anycast
4. Designing real-world systems: URL shortener, chat apps, and news feeds6 hrs
   • URL shortener key generation and redirect flow
   • chat application WebSocket scaling and message stores
   • news feed fan-out on write versus fan-out on read
   • back-of-the-envelope estimation for QPS and storage

Hands-on project: Design a complete distributed chat system architecture document covering sharding, load balancing, and failure recovery.

You can test microservice APIs with Jest, instrument logs, and set up structured error monitoring for production environments.

1. Integration testing Express APIs with Supertest and MongoDB Memory Server2 hrs
   • setting up test environments with mongodb-memory-server
   • Supertest HTTP assertions on Express endpoints
   • mocking external message broker publishers
   • database seeding and cleanup between test runs
2. Structured logging with Winston and request correlation IDs2 hrs
   • JSON structured logging formats
   • Winston transports for console and file output
   • generating and passing X-Request-ID headers across services
   • log levels: debug, info, warn, error
3. Application performance monitoring and error tracking2 hrs
   • collecting runtime metrics and memory usage
   • error tracking setup and stack trace capture
   • health check endpoints for container orchestrators
   • setting up alerts for unhandled errors
4. Security hardening and dependency vulnerability audits2 hrs
   • npm audit and dependency vulnerability scanning
   • environment variable secret management best practices
   • HTTP security headers tuning with Helmet
   • rate limiting and DDoS mitigation techniques

Hands-on project: Implement comprehensive unit and integration test suites with Jest and configure structured Winston logging across microservices.

You can harden a MERN application against the attacks that actually hit it.

1. The OWASP risks that hit MERN90 min
   • NoSQL injection
   • Broken object-level auth
   • Mass assignment
2. Hardening Express90 min
   • helmet security headers
   • CORS done correctly
   • Rate limiting and slow-down
3. Tokens, sessions and CSRF90 min
   • JWT storage trade-offs
   • httpOnly cookies
   • CSRF tokens
4. Front-end and supply chain90 min
   • XSS and dangerouslySetInnerHTML
   • npm audit in CI
   • Lockfile integrity

Hands-on project: Harden the capstone: fix a deliberately vulnerable endpoint for NoSQL injection and broken object-level authorisation, add helmet headers, CSRF protection and per-route rate limiting, and run an npm audit gate that blocks a critical advisory.

You can containerise MERN microservices with Docker, automate CI/CD pipelines, and deploy production apps to AWS.

1. Dockerizing Node.js microservices with multi-stage builds4 hrs
   • Dockerfile syntax and instruction ordering
   • multi-stage builds to minimize image size
   • Docker Compose for multi-container local orchestration
   • volume mounting for development hot-reloading
2. Setting up CI/CD pipelines with GitHub Actions4 hrs
   • GitHub Actions workflow YAML syntax
   • automating test runs on pull requests
   • building and pushing Docker images to registries
   • storing secrets securely in GitHub repository settings
3. Deploying applications to AWS EC2 and managing environment variables4 hrs
   • provisioning AWS EC2 instances and security groups
   • installing Docker and Docker Compose on remote servers
   • managing production environment files securely
   • configuring Nginx reverse proxy and SSL certificates
4. System monitoring, log aggregation, and final capstone polish4 hrs
   • inspecting container logs on remote servers
   • verifying inter-service communication over Docker networks
   • final capstone code review and repository documentation
   • preparing project walkthroughs for technical interviews

Hands-on project: Deploy the full-stack microservices capstone application live to AWS using Docker containers and automated GitHub Actions CI/CD.