MOHAMMAD SHAKER
SOFTWARE ENGINEERING

SWE System Design

Core distributed-systems ideas for software engineers

CURRICULUM

A visual course on the concepts behind reliable large-scale software systems: availability, consistency, partition tolerance, replication, sharding, caching, queues, consensus, failure modes, and the tradeoffs engineers must choose explicitly.

  1. 01A Method for Designing SystemsA repeatable way to approach any design problem, and how to sketch it clearly.14 sections
  2. 02Scalable System Design PatternsCore patterns for growing a system from one server to a distributed architecture.17 sections
  3. 03Different Types of Data StorageChoosing storage by access pattern, consistency, scale, and query shape.20 sections
  4. 04Caching, In DepthHow caches actually work: strategies, eviction, invalidation, and the failure modes.16 sections
  5. 05Queues and Messaging, In DepthDecoupling with queues and logs: delivery guarantees, ordering, and failure handling.14 sections
  6. 06Event-Driven ArchitectureReacting to events instead of calling services directly: notification, state transfer, and event sourcing.11 sections
  7. 07Sharding and Partitioning, In DepthSplitting data across nodes: partition strategies, rebalancing, and the hard queries.16 sections
  8. 08Replication and Consensus, In DepthKeeping copies in sync: leader-follower, quorums, and how nodes agree.15 sections
  9. 09Managing Shared StateKeeping data correct when many servers, workers, and clients touch it at once.23 sections
  10. 10CAP TheoremWhen a distributed system is cut in half by a network partition, it must choose between answering and risking disagreement, or stopping until agreement is safe.26 sections
  11. 11The OSI Model (and why TCP/IP won)A first-principles tour of the seven layers, a real packet's journey, and where switches, routers, and load balancers actually sit.9 sections
  12. 12HTTP/1.1 vs HTTP/2 vs HTTP/3How the web's core protocol evolved to kill head-of-line blocking — and when each version actually matters for your design.7 sections
  13. 13Content Delivery Networks (CDN)A first-principles tour of edge PoPs, anycast routing, the cache hierarchy, and the headers that control it all.10 sections
  14. 14How SSH Really WorksA first-principles walk through the SSH handshake: key exchange, host verification, authentication, and the encrypted channel — and why it uses two different kinds of cryptography.9 sections
  15. 15gRPCContract-first RPC over HTTP/2: Protocol Buffers, streaming, deadlines, and when it beats REST.10 sections
  16. 16GraphQLOne endpoint, client-specified queries: solving over/under-fetching, and paying for it with resolver and caching complexity.10 sections
  17. 17The API Gateway PatternOne front door for many services: routing, auth, rate limiting, and the cross-cutting concerns you pull off the services.11 sections
  18. 18Data-Plane Proxies: Envoy & KongThe proxies that run the traffic: Envoy's sidecar mesh, Kong's centralized gateway, and the control-plane/data-plane split.10 sections
  19. 19WAF & Edge SecurityThe outer wall: filtering malicious traffic at the edge before it ever reaches your servers.11 sections
  20. 20Security in System DesignBuilding systems that stay safe even when one layer fails: defense in depth, least privilege, and trust boundaries.13 sections
  21. 21OAuth 2.0 & OpenID ConnectLetting an app act on your behalf without ever handing it your password — and telling authorization apart from authentication.11 sections
  22. 22LLM GatewaysOne unified proxy in front of many model providers: routing, fallback, cost, caching, and observability.12 sections
  23. 23Agentic System ArchitectureFrom a single prompt to an LLM in a loop that observes, decides, calls tools, and acts toward a goal.10 sections
  24. 24Agentic Patterns & ReliabilityThe building-block patterns for composing agents, and the guardrails that make them safe to run in production.12 sections
  25. 25Distributed System Patterns I: ResilienceThe handful of patterns that keep a distributed system standing when one of its parts misbehaves.13 sections
  26. 26Distributed System Patterns II: Data & CoordinationThe patterns for moving, storing, and agreeing on data once a single database is no longer enough.13 sections
  27. 27Design Principles: KISS, SOLID, CAP, BASEThe short list of acronyms that quietly shape almost every system-design decision.9 sections
  28. 28ACID Properties in DatabasesThe four guarantees that let a database survive crashes, concurrency, and half-finished work.11 sections
  29. 29Apache Airflow (Workflow Orchestration)Scheduling and dependency-managing batch data pipelines with a DAG as the core abstraction.8 sections
  30. 30Snowflake (Cloud Data Warehouse)Separating storage from compute so analytics can scale elastically over huge datasets.9 sections
  31. 31The Data LakehouseCheap lake storage plus warehouse-grade table management, unified in one architecture.7 sections
  32. 32Concurrency vs ParallelismDealing with many things at once versus doing many things at once — and why they're not the same.9 sections
  33. 33DevOps vs SRE vs Platform EngineeringThree overlapping disciplines that all attack the dev↔ops wall — a culture, an engineering practice, and a product — and when an org needs each.8 sections
  34. 34Data PipelinesThe automated plumbing that moves and reshapes data from where it is produced to where it is used — stages, ETL vs ELT, batch vs streaming, and why it exploded in popularity.10 sections