Understand the systems behind modern software.
Explore the engineering concepts, infrastructure, and architecture patterns that power real-world applications. Learn how components connect, how systems scale, and why engineering decisions matter.
Terminates TLS 1.3, manages 340 open socket file descriptors. Round-robin forwarding to backend workers.
Interactive Architecture Map
Trace how fundamental networking primitives connect to operating system syscalls, distributed caches, and large-scale message brokers. Select any concept to explore its prerequisites and downstream dependencies.
Engineering Concepts, Prerequisites & Dependencies
Click nodes to trace architectural prerequisites, explore upstream invariants, and inspect downstream unlock paths.
Computer Networking Invariants
How bytes traverse the wire, OSI boundaries, and network demarcation points.
Client-Server Architecture
The foundational request-response paradigm powering distributed internet systems.
DNS Resolution & Anycast
Hierarchical name resolution, root servers, recursive caching, and DNS failure modes.
Request Lifecycle & Transport Protocols
TCP 3-way handshake, TLS 1.3 records, and HTTP/1.1 vs HTTP/2 multiplexing.
Linux Epoll & File Descriptors
Solving the C10K concurrency bottleneck with O(1) kernel event readiness.
Docker Internals: Namespaces & Cgroups
Creating process isolation using Linux kernel primitives and OverlayFS.
Kubernetes Services Explained
Exposing Pods via ClusterIP, NodePort, and LoadBalancer abstractions.
Reverse Proxies & Load Balancers
Nginx connection pooling, TLS termination, health probes, and round-robin routing.
Redis: In-Memory Caching & Eviction
Sub-millisecond latency, LRU/LFU memory eviction, and thundering herd mitigation.
Asynchronous Queues & Message Brokers
Decoupling peak traffic spikes from database writes with RabbitMQ and worker pools.
Kafka: Distributed Commit Logs & Partitions
Sequential disk append-only I/O, page cache exploitation, and consumer rebalancing.
Rate Limiting: Token Bucket vs Sliding Window
Algorithms and mathematical invariants for protecting APIs against resource exhaustion.
Circuit Breakers & Cascading Outages
Three-state failure detection, timeout budgets, and half-open automated probes.
System Design: High-Throughput URL Shortener
Base62 encoding, 100k QPS read-heavy caching, and B-Tree database indexing.
System Design: Real-Time Chat Architecture
Persistent WebSocket gateways, Redis Pub/Sub multiplexers, and message archives.
Client-Server Architecture
Deconstructs socket creation, state synchronization, client-side timeouts, and stateless service design. Examines why servers maintain connection tables and how client multiplexing scales.
Sequential Learning Paths
Systems engineering cannot be mastered through disconnected summaries. Every phase builds upon the physical invariants and operating system primitives mastered in the previous phase.
Curriculum Flow & Prerequisites
Engineering Foundations
Sockets, Transport Protocols, Hardware & Network Demarcation
Infrastructure & Linux
Kernel Syscalls, Container Runtimes, Reverse Proxies & In-Memory Caching
Backend & Distributed Systems
Message Brokers, Event Streams, Replication & Partitioning
Production Engineering
Fault Tolerance, Graceful Degradation, Rate Limiting & SRE
System Design Stories
Production Architectural Blueprints & End-to-End Case Studies
Advanced Architecture
Multi-Region Active-Active Systems & Distributed Consensus
Engineering Foundations
Sockets, Transport Protocols, Hardware & Network Demarcation
Featured Engineering Topics
Linux Epoll & File Descriptors
Why select() and poll() scale with O(N) complexity and how the Linux kernel solved the C10K concurrency bottleneck with epoll event readiness.
Redis: In-Memory Caching & Eviction
Single-threaded event loops, LRU/LFU memory eviction algorithms, and thundering herd mitigation under extreme traffic surges.
Kafka: Distributed Commit Logs
Zero-copy sequential disk I/O, OS page cache exploitation, consumer group rebalancing, and partition leader election.
Rate Limiting Algorithms
Mathematical comparison of Token Bucket, Leaky Bucket, and Sliding Window Log algorithms for high-throughput API gateway protection.
Circuit Breakers & Cascading Outages
Preventing catastrophic retry storms when downstream microservices degrade, with automated three-state failure detection.
Docker Internals: Namespaces & Cgroups
How container engines create the illusion of isolated operating systems using Linux PID/mount namespaces, cgroups, and layered file systems.
How a Request Moves Across the Wire
Step through an HTTP request lifecycle from DNS query and TCP/TLS handshakes to kernel socket buffer allocation, reverse proxying, and cache-aside storage.
Host domain "api.complexity.io" is translated into machine routable IP address "198.51.100.24".
Checks OS /etc/hosts cache and invokes getaddrinfo() POSIX syscall.
First-Principles Architecture Guides
Introduction to Client-Server Architecture
Deconstructing the foundational communication paradigm of distributed software. Socket allocations, state invariants, and physical network boundaries.
Request Lifecycle & Transport Protocols
Tracing a network packet from socket allocation down through TCP handshake, TLS 1.3 negotiation, and HTTP/2 stream multiplexing.
Kubernetes Services: ClusterIP vs NodePort vs LoadBalancer
Routing ingress traffic to ephemeral pods across cluster nodes. Interactive packet routing stepper and production YAML specifications.
Production Architecture Case Studies
High-Throughput URL Shortener
Base62 encoding, distributed counter ranges, multi-tier Redis caching, and B-Tree index guarantees.
Real-Time Chat & Direct Messaging
Stateful WebSocket connection gateways, Redis Pub/Sub multiplexers, presence heartbeats, and Cassandra archives.
Adaptive Bitrate Video Streaming
Chunked HLS media segmentation, distributed transcoding DAGs, multi-tier edge CDN caching, and origin shield protection.
Diagram Studio: Design Systems Directly in Your Browser.
An approachable, vector drawing workspace inspired by Excalidraw—tailored specifically for backend engineers and distributed architects. Connect microservices, trace request lifecycles, and export publication-ready diagrams with zero login required.
The 7 Questions Behind Every System
Every article, simulation, and case study on Complexity deconstructs engineering choices against these immutable production constraints.
01. Why does it exist?
What historic wall or bottleneck led to its creation?
02. What problem does it solve?
Exactly what pain point does it address?
03. How does it work internally?
Data structures, sockets, and concurrency models.
04. What happens under traffic?
Connection pooling, queue depth, and thread pools.
05. What happens when it fails?
Cascading timeouts and network partitions.
06. What alternatives exist?
Trade-offs and architectural comparison matrices.
07. Why choose it in production?
Operational complexity and maintenance overhead.
08. First-Principles Verified
Zero fake benchmarks or fabricated statistics.