Month 1 Software Engineering Rigor & Clean Domain Modeling Weeks 1–4 • 8 Live Sessions
  • Session 1-2: Architectural Decision Records (ADRs), monolith trade-offs, and Domain-Driven Design (DDD) bounded contexts.
  • Session 3-4: Hexagonal Architecture, Ports & Adapters pattern, and strict dependency inversion in NestJS.
  • Session 5-6: Domain entities, value objects, domain events, and clean application service layers.
  • Session 7-8 (Live Hand-Holding): Monolith Refactoring Lab — Taking a bloated production codebase and refactoring it into domain-isolated modules with live PR reviews.
Month 2 Advanced Relational Data Modeling & PostgreSQL Internals Weeks 5–8 • 8 Live Sessions
  • Session 9-10: Relational schema optimization, normalization vs denormalization, and data integrity constraints.
  • Session 11-12: B-Tree, GIN, and BRIN indexing strategies; deep-dive into query execution plans with EXPLAIN ANALYZE.
  • Session 13-14: MVCC mechanics, write amplification, vacuuming strategies, connection pooling with PgBouncer, and deadlock resolution.
  • Session 15-16 (Live Hand-Holding): Slow-Query Remediation Lab — Optimizing a million-row database bottleneck and resolving locking issues under high concurrent write loads.
Month 3 High-Concurrency Caching, Locking & Event Pipelines with Redis Weeks 9–12 • 8 Live Sessions
  • Session 17-18: Multi-tier caching architectures (Cache-aside, Write-through, Write-behind) and mitigating cache stampede/thundering herd.
  • Session 19-20: Redis data structures deep-dive: Bitmaps, HyperLogLogs, and Sorted Sets for high-performance ranking engines.
  • Session 21-22: Distributed mutual exclusion using Redlock to prevent double-spending in race conditions.
  • Session 23-24 (Live Hand-Holding): Flash-Sale Concurrency Lab — Building an e-commerce inventory reservation system sustaining 15,000 requests/sec with Redis Lua scripts.
Month 4 Asynchronous Job Orchestration & BullMQ Message Processing Weeks 13–16 • 8 Live Sessions
  • Session 25-26: Distributed job queues vs Pub/Sub; designing resilient background workers with BullMQ.
  • Session 27-28: Rate limiting, exponential backoff strategies, and Dead Letter Queue (DLQ) automated replay mechanisms.
  • Session 29-30: Heavy payload handling, stream chunking, and worker concurrency tuning.
  • Session 31-32 (Live Hand-Holding): Media Processing Pipeline Lab — Designing a distributed audio/video transcode worker farm with real-time WebSocket progress telemetry.
Month 5 Microservice Inter-Process Transports & High-Speed gRPC Weeks 17–20 • 8 Live Sessions
  • Session 33-34: Synchronous REST vs Asynchronous IPC trade-offs; NestJS transport abstractions (TCP, Redis, NATS).
  • Session 35-36: High-throughput binary RPC: Protocol Buffers, service definitions, and contract versioning.
  • Session 37-38: Client-side load balancing, unary endpoints vs bi-directional streaming, and HTTP/2 multiplexing.
  • Session 39-40 (Live Hand-Holding): Cross-Service Communication Lab — Replacing legacy JSON HTTP calls with binary gRPC streaming between Orders and Billing services.
Month 6 Distributed Data Consistency & Transactional Sagas Weeks 21–24 • 8 Live Sessions
  • Session 41-42: The Dual-Write dilemma and implementing the Transactional Outbox Pattern with CDC (Change Data Capture).
  • Session 43-44: Choreographed vs Orchestrated Sagas; designing compensating actions for financial transactions.
  • Session 45-46: Exactly-once processing semantics, idempotent consumer design, and distributed tracing with correlation IDs.
  • Session 47-48 (Live Hand-Holding): End-to-End Checkout Saga Lab — Building a resilient multi-stage checkout saga across Payment, Wallet, and Inventory modules with simulated failures.
Month 7 Event-Driven Streaming Architectures with Apache Kafka Weeks 25–28 • 8 Live Sessions
  • Session 49-50: Kafka fundamental architecture: Topics, partitions, brokers, consumer groups, and write-ahead logs.
  • Session 51-52: Partition key strategies, ordered message delivery, and producer acks guarantees.
  • Session 53-54: Schema Registry (Avro/Protobuf), consumer lag monitoring, rebalancing triggers, and commit strategies.
  • Session 55-56 (Live Hand-Holding): Real-Time Analytics Ingestion Lab — Building an audit-trail and user clickstream ingestion pipeline processing 20k events/sec into persistent sinks.
Month 8 Production Containerization & Multi-Stage Docker Engine Weeks 29–32 • 8 Live Sessions
  • Session 57-58: Linux namespaces, cgroups, and multi-stage Docker build optimizations (<90MB distroless images).
  • Session 59-60: Advanced Docker networking: Bridge, host, overlay networks, DNS resolution, and internal firewalling.
  • Session 61-62: Volume management, non-root user execution, secrets injection, and zero-trust container security scanning.
  • Session 63-64 (Live Hand-Holding): Production Docker Compose Cluster Lab — Orchestrating a full multi-service development environment with PostgreSQL, Redis, Kafka, and telemetry services.
Month 9 Kubernetes Clustering, Service Meshes & Traffic Routing Weeks 33–36 • 8 Live Sessions
  • Session 65-66: Kubernetes core primitives: Pods, Deployments, Services (ClusterIP, NodePort), and ConfigMaps/Secrets.
  • Session 67-68: Persistent Volumes (PV/PVC), StatefulSets, and zero-downtime rolling updates with readiness/liveness probes.
  • Session 69-70: Ingress Controllers (Traefik/Nginx), SSL termination, rate limiting, and horizontal pod autoscaling (HPA).
  • Session 71-72 (Live Hand-Holding): K8s Deployment Lab — Deploying a replicated microservice cluster on a managed cloud Kubernetes cluster with dynamic auto-scaling.
Month 10 Observability, Distributed Tracing & Chaos Engineering Weeks 37–40 • 8 Live Sessions
  • Session 73-74: The Three Pillars of Observability: Metrics (Prometheus), Structured Logs (Pino/Loki), and Traces (OpenTelemetry).
  • Session 75-76: Distributed trace propagation across gRPC, HTTP, and async Kafka message boundaries using Jaeger.
  • Session 77-78: Alerting thresholds, SLA/SLO definition, error budget formulation, and Grafana dashboard craftsmanship.
  • Session 79-80 (Live Hand-Holding): Chaos Engineering Drill — Intentionally killing database nodes and injecting network latency to audit system self-healing and alert pipelines.
Month 11 Agentic AI Workflows, Local LLMs & Model Context Protocol (MCP) Weeks 41–44 • 8 Live Sessions
  • Session 81-82: Architecture of Autonomous AI Agents: ReAct framework, tool calling, memory management, and deterministic fallbacks.
  • Session 83-84: Model Context Protocol (MCP) server design: Exposing relational databases and internal APIs safely to AI agents.
  • Session 85-86: Private, air-gapped agent pipelines using Ollama, LangChain, and n8n workflow automations.
  • Session 87-88 (Live Hand-Holding): AI Dev-Assistant Engine Lab — Building an internal MCP agent capable of querying system telemetry, diagnosing slow queries, and proposing PR patches.
Month 12 Bare-Metal VPS Production Deployment & Capstone Defense Weeks 45–48 • 8 Live Sessions
  • Session 89-90: Linux VPS hardening: SSH keys, UFW/iptables firewalling, Fail2ban, swap memory tuning, and kernel network limits.
  • Session 91-92: GitHub Actions CI/CD deployment pipelines: Automated testing, image building, security linting, and zero-downtime SSH deploy hooks.
  • Session 93-94: Production backup automations: Automated PostgreSQL streaming backups to Cloudflare R2/S3 and point-in-time recovery testing.
  • Session 95-96 (Final Capstone & Architecture Defense): Live Production Launch — Deploying each student's end-to-end distributed system onto live servers, conducting load stress tests, and final 1-on-1 code defense.