System design lessons
39 lessons across 6 learning paths. Your progress is saved in this browser.
Foundations
Complexity, concurrency, latency, design principles and architecture styles.
Big-O Notation & Time Complexity
A shared language for how the cost of an algorithm grows as its input grows.
FoundationsConcurrency vs Parallelism
Concurrency is dealing with many things at once; parallelism is doing many things at once.
FoundationsLatency Numbers & the Memory Hierarchy
Rough timings for memory, disk and network that make back-of-the-envelope design possible.
FoundationsSOLID, DRY, KISS & YAGNI
Principles that keep code easy to change as a system grows.
FoundationsArchitecture Styles
Monolith, modular monolith, microservices, event-driven and serverless — and how to choose.
FoundationsDependency Injection Lifetimes (.NET)
Singleton, scoped and transient — how long a service instance lives, and why it matters.
Scalability & Performance
Scaling out, load balancing, caching, CDNs, rate limiting and low latency.
Vertical vs Horizontal Scaling
Make one machine bigger, or add more machines — the first decision in every scaling story.
Scalability & PerformanceLoad Balancing
Spread traffic across healthy servers so no single machine becomes the bottleneck.
Scalability & PerformanceCaching Strategies
Keep frequently read data close and fast, and decide carefully how it stays fresh.
Scalability & PerformanceContent Delivery Networks (CDN)
Serve static content from edge servers near your users instead of a single origin.
Scalability & PerformanceRate Limiting
Cap how many requests a client can make so one caller can’t overwhelm everyone else.
Scalability & PerformanceRules for Low-Latency Systems
Practical habits that keep response times low and predictable under load.
Data & Storage
Replication, sharding, CAP, SQL vs NoSQL, indexing and query pitfalls.
Database Scaling & Replication
From one database server to replicas, partitions and shards — in the order you should reach for them.
Data & StorageSharding Strategies
Range, hash, consistent hashing and directory-based sharding — how data is split across servers.
Data & StorageCAP Theorem & Consistency
During a network partition, a distributed store must choose between consistency and availability.
Data & StorageSQL vs NoSQL
Relational, document, key-value, wide-column and graph databases — match the store to the access pattern.
Data & StorageIndexing & Query Performance
How indexes turn full table scans into fast lookups — and the other habits that keep queries quick.
Data & StorageThe N+1 Query Problem
One query for a list, then one more for every item — a silent performance killer in ORMs.
APIs & Security
API styles, gateways, versioning, performance, authentication, SSO and idempotency.
API Architecture Styles
REST, GraphQL, gRPC, WebSockets, webhooks and SOAP — what each is for.
APIs & SecurityAPI Gateway
A single front door that routes, secures and shapes traffic to your back-end services.
APIs & SecurityAPI Versioning
Evolve an API without breaking the clients that already depend on it.
APIs & SecurityImproving API Performance
Pagination, caching, compression, async processing and connection pooling.
APIs & SecurityAPI Security Essentials
Defence in depth for APIs: transport, identity, authorization, input and abuse controls.
APIs & SecurityAPI Authentication Methods
Basic auth, API keys, sessions, JWT bearer tokens and OAuth 2.0 compared.
APIs & SecuritySingle Sign-On (SSO)
Sign in once with a central identity provider and access many applications.
APIs & SecurityHTTP Status Codes for APIs
Return the right status code so clients, proxies and monitoring understand what happened.
APIs & SecurityIdempotency & Preventing Double Payments
Make retries safe, so a timeout never charges a customer twice.
Messaging & Microservices
Message brokers, event streaming, microservice patterns, sagas and resilience.
Message Brokers: RabbitMQ vs Kafka vs ActiveMQ
Queues and logs for decoupling services — and how the three popular brokers differ.
Messaging & MicroservicesReal-Time Event Streaming
Process continuous streams of events as they happen, not in nightly batches.
Messaging & MicroservicesMicroservices Design Patterns
Decomposition, integration, data, resilience and deployment patterns for service-based systems.
Messaging & MicroservicesThe Saga Pattern
Run a business transaction across services as a series of local steps with compensations.
Messaging & MicroservicesResilience: Timeouts, Retries & Circuit Breakers
Contain failures so one slow dependency doesn’t take the whole system down.
Cloud & Delivery
CI/CD, deployment strategies, Kubernetes, ingress, observability and cloud services.
How Git Works
Working directory, staging area, local and remote repositories — and the commands that move changes between them.
Cloud & DeliveryCI/CD Pipelines
Automate build, test and deployment so every change reaches production safely and quickly.
Cloud & DeliveryDeployment Strategies
Rolling, blue-green, canary and feature flags — release without downtime and roll back fast.
Cloud & DeliveryKubernetes Architecture
The control plane, worker nodes and core objects that run containers at scale.
Cloud & DeliveryKubernetes Ingress vs Gateway API
Two ways to bring outside traffic into a cluster, and why Gateway API is the successor.
Cloud & DeliveryObservability: Logs, Metrics & Traces
Know what your system is doing, why it is slow and where it failed.
Cloud & DeliveryCloud Services Map: AWS, Azure & Google Cloud
The equivalent building blocks across the three major cloud providers.
No lessons match your search. Try a broader term such as “database” or “API”.