Build the non-negotiable baseline. Networking, OS, DB basics, and the SD Interview Framework. Learn Back-of-Envelope estimation as a repeatable skill. Everyone starts here.

Master SOLID principles with real violations and fixes. Learn UML Class and Sequence diagrams. Build the design instinct before patterns.

Singleton, Factory, Abstract Factory, Builder, Prototype — each mapped to a real system (Logging, Parking Lot, Snake & Ladder, Chess, File System).

Adapter, Decorator, Proxy, Composite, Facade, Bridge, Flyweight — mapped to Vending Machine, Pizza Billing, Car Rental, Splitwise, CricBuzz, TrueCaller.

12 behavioral patterns: Strategy, Observer, Chain of Responsibility, State, Command, Iterator, Mediator, Memento, Template Method, Visitor, Null Object, Interpreter.

Threads, Locks, Semaphores, Monitors. Producer-Consumer, Thread Pool, Deadlock prevention. The bridge between OOP design and systems programming.

LinkedIn, Amazon, Uber/Ola, Hotel Booking, Online Voting, Cache Mechanism, Rate Limiter, Food Delivery, Chat System, Restaurant Management, Bowling Alley.

Scalability, CAP Theorem, Consistency Models, Availability Patterns, Load Balancing, Latency vs Throughput. Back-of-envelope estimation and the SD Interview Framework.

Indexing (B-Tree, Hash, Composite), ACID vs BASE, SQL vs NoSQL decision framework, Replication (leader-follower, multi-leader), Sharding (range, hash, consistent), DB Selection Guide.

Cache-Aside, Write-Through, Write-Back, Read-Through patterns. LRU/LFU eviction, cache invalidation strategies, stampede prevention. Redis data structures and CDN caching.

Async messaging patterns, Kafka architecture (partitions, offsets, consumer groups), at-least-once vs exactly-once delivery guarantees, push vs pull semantics, event-driven backpressure.

Base62 encoding strategies, distributed unique ID generation (Snowflake), API rate limiting, 301 vs 302 redirects, caching topologies, read-heavy system scaling.

Fan-out on write vs read methodologies, hybrid timeline generation for celebrities, distributed caching with Redis, timeline pre-computation, asynchronous count updates.

Persistent WebSockets with session stores, Cassandra optimizations for chat history, three-state delivery receipts, high-throughput presence systems, group messaging fan-out.

Chunked resumable uploads with SHA-256 deduplication, temporal parallelism transcoding (60× speedup), HLS adaptive bitrate streaming (.m3u8 manifests + .ts segments), 3-tier CDN architecture (58 Tbps), sharded view counter with Kafka durability, Elasticsearch search via CDC.

Five rate limiting algorithms with exact memory/accuracy trade-offs: Fixed Window, Sliding Window Log, Sliding Window Counter (production default), Token Bucket, Leaky Bucket. Redis Lua scripts for atomicity, centralised vs distributed strategies, HTTP 429 headers, multi-tier architecture at CDN → Gateway → App → DB layers.

Why modulo hashing breaks when nodes change, hash ring with [0, 2³²) address space, clockwise key lookup (TreeMap ceilingEntry), virtual nodes (150/node) for uniform distribution, heterogeneous capacity weighting. Service discovery patterns: client-side, server-side, DNS (Kubernetes CoreDNS). Consul HTTP API, ZooKeeper ephemeral znodes, health checks, gossip protocol vs Raft.

ACID properties, isolation levels. The distributed transaction problem: no ACID across DBs. Two-Phase Commit (blocking, coordinator SPOF). Saga pattern: local transactions + compensating transactions. Choreography vs Orchestration. Outbox pattern for atomic DB + event publishing. Idempotency keys. BASE vs ACID.

The 7-step framework for 45-minute system design interviews. Time allocation map. Requirements templates. Capacity estimation cheat sheet. Communication patterns that signal seniority. 7 most common mistakes. 6 full mock interview problems (Pastebin, Notifications, Job Scheduler, Google Drive, Live Streaming, Autocomplete). Quick answers card.

Feature stores, training pipelines, model serving, A/B testing infrastructure, recommendation systems, real-time ML inference at scale. MLOps fundamentals.

Containers → Pods → Services → Ingress. Deployments, StatefulSets, HPA, resource management. Service mesh basics (Istio). K8s in system design interviews.

Both tracks merge. Apply LLD + HLD together. Each system: Requirements → Estimation → HLD diagram → Deep dive 2 components → Trade-offs. 10+ complete system designs.

Maintainability, Observability, SLOs. Security patterns (AuthN, AuthZ, mTLS, Zero Trust). Cost optimization (Spot instances, tiered storage). Fraud detection + Auth+Monitoring system designs.

20 timed mock problems with evaluation rubric. Then the final capstone: choose one end-to-end project that combines everything — LLD entities, HLD architecture, storage, reliability, and trade-off analysis.

Deep-dive into production-grade advanced systems. Five focused modules covering distributed consensus (Raft/Paxos), geo-distribution, ML infrastructure, observability/SRE, and security architecture.