Systems Engineering
Dive into distributed systems, cloud architecture, and DevOps.
- Distributed Systems & Advanced Databases
- Containers, Kubernetes & Cloud
- CI/CD, Observability & Messaging
Start your 7-day free trial
Get full access to all learning paths across the platform.
All Lessons
The CAP Theorem
Understand the CAP theorem: consistency, availability, partition tolerance, and real-world trade-offs.
Consistency Models
Compare consistency models: strong, eventual, causal, and linearizable consistency.
Distributed Clocks & Ordering
Solve ordering problems with logical clocks, vector clocks, and hybrid logical clocks.
Consensus Algorithms
Understand consensus: Paxos, Raft, and how distributed systems agree on shared state.
TCP/IP Deep Dive
Understand TCP/IP: the protocol stack, connection lifecycle, flow control, and congestion management.
HTTP/2 & HTTP/3
Understand HTTP evolution: multiplexing, server push, header compression, and QUIC protocol.
DNS Architecture
Understand DNS: hierarchical resolution, caching, record types, and DNS-based load balancing.
Load Balancing Strategies
Distribute traffic with load balancing: round-robin, least connections, consistent hashing, and health checks.
Content Delivery Networks
Accelerate content delivery with CDNs: edge caching, cache invalidation, and global distribution.
Monoliths vs Microservices
Evaluate when to use monolithic vs microservice architectures and understand their operational trade-offs.
Service Meshes
Learn how service meshes handle traffic management, observability, and security between microservices.
API Gateway Design
Design API gateways for authentication, rate limiting, request routing, and protocol translation.
gRPC & Protocol Buffers
Build efficient inter-service communication with gRPC, Protocol Buffers, and streaming RPCs.
Message Queues
Decouple services with message queues: RabbitMQ, Kafka, pub/sub patterns, and dead letter queues.
Event-Driven Architecture
Build event-driven systems with event sourcing, CQRS, and domain events for loosely coupled services.
Idempotency & Retries
Design idempotent APIs that safely handle retries, duplicate messages, and network failures.
Circuit Breaker Pattern
Prevent cascade failures with circuit breakers: closed, open, half-open states and failure thresholds.
Distributed Tracing
Debug distributed systems with tracing: spans, trace context propagation, and OpenTelemetry.
Backpressure & Flow Control
Handle overload with backpressure: rate limiting, buffering, dropping, and reactive streams.
Caching Strategies
Choose the right caching strategy: cache-aside, write-through, write-behind, and read-through patterns.
Redis Deep Dive
Master Redis: data structures, pub/sub, Lua scripting, persistence, and high-availability clusters.
Cache Warming & Stampede
Prevent cache stampede with locking, probabilistic early expiration, and cache warming strategies.
Cache Invalidation
Tackle cache invalidation: TTL-based, event-driven, version-based, and tag-based strategies.
Consistent Hashing
Scale caching across nodes with consistent hashing, virtual nodes, and minimal key redistribution.
Database Replication
Set up database replication: leader-follower, multi-leader, and leaderless patterns for availability.
Database Sharding
Partition data across database instances with range-based, hash-based, and geographic sharding.
Write-Ahead Logging
Ensure durability with write-ahead logs: crash recovery, log compaction, and checkpointing.
Database Indexing Internals
Understand index internals: B-trees, LSM trees, hash indexes, and when to use each.
Connection Pooling
Manage database connections efficiently with connection pools, pool sizing, and connection lifecycle.
Linux Fundamentals
Master Linux for systems engineering: process management, file systems, permissions, and system monitoring.
Networking Fundamentals
Understand networking: subnets, CIDR, firewalls, NAT, VPNs, and network troubleshooting.
Infrastructure as Code
Manage infrastructure with code using Terraform: providers, resources, state, and modules.
Configuration Management
Manage server configuration with Ansible: playbooks, roles, inventory, and idempotent tasks.
Docker Internals
Understand Docker internals: namespaces, cgroups, union filesystems, and container isolation.
Dockerfile Best Practices
Write production Dockerfiles: multi-stage builds, layer caching, security, and small images.
Container Networking
Configure container networking: bridge networks, overlay networks, DNS resolution, and port mapping.
Container Security
Secure containers: read-only filesystems, non-root users, resource limits, and image scanning.
Container Orchestration Concepts
Understand orchestration concepts: scheduling, scaling, self-healing, and service discovery.
Kubernetes Architecture
Understand Kubernetes architecture: control plane, nodes, pods, and the reconciliation loop.
Pods & Deployments
Master K8s workloads: pods, deployments, ReplicaSets, rolling updates, and rollbacks.
Services & Ingress
Expose K8s workloads: ClusterIP, NodePort, LoadBalancer, and Ingress controllers.
ConfigMaps & Secrets
Externalize configuration: ConfigMaps for settings, Secrets for sensitive data, and environment injection.
Helm Charts
Package K8s applications with Helm: charts, templates, values, releases, and chart repositories.
Horizontal Pod Autoscaling
Auto-scale K8s workloads: HPA, VPA, CPU/memory metrics, custom metrics, and scaling policies.
Persistent Volumes
Manage storage in K8s: PersistentVolumes, PersistentVolumeClaims, StorageClasses, and stateful workloads.
Kubernetes Operators
Extend K8s with custom operators: CRDs, controllers, and the operator pattern for complex applications.
AWS Core Services
Navigate AWS core services: EC2, S3, RDS, Lambda, VPC, and IAM for cloud infrastructure.
Cloud Networking (VPC)
Design cloud networks: VPC, subnets, route tables, security groups, NACLs, and peering.
Serverless Architecture
Build with serverless: Lambda, API Gateway, event triggers, cold starts, and serverless patterns.
CI/CD Fundamentals
Build CI/CD pipelines: continuous integration, delivery, deployment, and pipeline design patterns.
GitHub Actions
Automate workflows with GitHub Actions: triggers, jobs, matrix builds, caching, and reusable actions.
Deployment Strategies
Deploy safely: blue-green, canary, rolling updates, A/B testing, and feature flags.
Structured Logging
Implement structured logging: JSON format, correlation IDs, log levels, and centralized log aggregation.
Metrics & Monitoring
Monitor systems with metrics: Prometheus, Grafana, RED/USE methods, and alerting strategies.
Alerting & On-Call
Design effective alerting: SLOs, error budgets, alert fatigue prevention, and on-call practices.
Incident Management
Handle incidents effectively: severity levels, incident response, post-mortems, and blameless culture.
Chaos Engineering
Test resilience with chaos engineering: fault injection, game days, and building confidence in system behavior.
Security Fundamentals
Secure distributed systems: zero trust, TLS/mTLS, secrets management, and defense in depth.
Performance Optimization
Optimize system performance: profiling, bottleneck analysis, database tuning, and capacity planning.
The Operating System Kernel
Understand the OS kernel: user space vs kernel space, system calls, and rings of privilege.
Process Memory Layout
Understand how memory is structured: Text, Data, Heap, and Stack segments.
CPU Scheduling
Learn how the OS shares the CPU: context switching, Round Robin, and Completely Fair Scheduler (CFS).
Virtual Memory & Paging
Understand virtual memory, page tables, the MMU, page faults, and swapping.
Inter-Process Communication (IPC)
Learn how processes talk: Pipes, Sockets, Signals, and Shared Memory.
Threads vs Processes
Concurrency models: why threads are cheaper, shared memory, and the Global Interpreter Lock (GIL).
Synchronization: Mutexes
Solve race conditions: Critical sections, Mutexes, Locks, and Semaphores.
Concurrency: Deadlocks
Understand the ultimate concurrency bug: Deadlocks, Coffman conditions, and deadlock prevention.
Asynchronous I/O
Understand non-blocking I/O: epoll, kqueue, the Event Loop, and the C10K problem.
File Systems Internals
Deep dive into disks: blocks, inodes, symlinks vs hardlinks, and journaled file systems (ext4).
Transactions & ACID
Understand database transactions: Atomicity, Consistency, Isolation, and Durability.
Isolation Levels
Navigate transaction isolation: Dirty Reads, Non-Repeatable Reads, Phantom Reads, and Serializable.
MVCC (Multi-Version Concurrency)
How databases use MVCC to allow lock-free reads while transactions write concurrently.
Distributed Transactions
Solve transactions across microservices using Two-Phase Commit (2PC) and Saga Patterns.
Consensus & Leader Election
Understand distributed consensus algorithms: Paxos, Raft, brain split, and leader election.
Distributed Locks & Leases
Synchronize distributed systems using Redis Redlock, ZooKeeper, and Leases.
Dynamo Architecture
NoSQL deep dive: DynamoDB/Cassandra, fully decentralized databases, Gossip, and Quorums.
Spanner & NewSQL
Understand Google Spanner: combining NoSQL scalability with SQL ACID via atomic clocks (TrueTime).
Time-Series Databases
Storing metric data efficiently: Time-Series DBs (TSDB), InfluxDB, Gorilla compression.
Search & Vector Databases
Understand inverted indices (Elasticsearch) and Vector Embeddings (Pinecone) for AI search.
Message Brokers vs Streaming
Understand the difference between Message Queues (RabbitMQ) vs Event Streams (Kafka).
RabbitMQ & AMQP
Understand Advanced Message Queuing Protocol: Exchanges, Queues, and Routing Keys.
Kafka Architecture
Dive into Apache Kafka: Topics, Partitions, Brokers, and Zero-Copy I/O.
Consumer Groups & Offsets
Master Kafka consumer scaling: Groups, Rebalancing, and committing offsets.
Exactly-Once Semantics
The hardest problem in streaming: At-Most-Once, At-Least-Once, and Exactly-Once Semantics (EOS).
Event Sourcing
Architect systems using Event Sourcing: storing state as a sequence of immutable events.
CQRS Architecture
Scale reads and writes independently using Command Query Responsibility Segregation (CQRS).
WebSockets & SSE
Real-time communication protocols: WebSockets vs Server-Sent Events vs Long Polling.
WebRTC
Understand WebRTC and Peer-to-Peer communication for ultra low-latency video and audio.
Stream Processing
Process endless data with Apache Flink, Spark Streaming, Stateful operators, and Time Windows.
Rate Limiting Algorithms
Protect APIs using Token Bucket, Leaky Bucket, and Sliding Window Rate Limiting.
Distributed ID Generation
Generate unique, sortable IDs across distributed servers using Twitter Snowflake.
Probabilistic Data Structures
Process massive datasets efficiently using Bloom Filters and HyperLogLog.
Spatial Indexing (Geohash)
Design Uber/Yelp architectures: Geohashes, QuadTrees, and spatial databases.
CRDTs & Real-Time Collab
Learn how Google Docs / Figma synchronize state collaboratively without locks using CRDTs.
Data Synchronization (Merkle Tree)
Find out how databases detect desynchronization efficiently using Merkle Trees (Anti-Entropy).
Distributed Job Scheduling
Cron at scale: Design a system to execute 1 million delayed tasks precisely on time.
Backpressure & Load Shedding
Keep systems alive during 100x traffic spikes: Backpressure, Circuit Breakers, and Load Shedding.
System Design: Chat App
Put it all together: Design a WhatsApp/Discord architecture using WebSockets and PubSub.
System Design: Video Streamer
The grand finale: Design YouTube/Netflix architecture. CDNs, Transcoding pipelines, and Scale.