Articles tagged with #Distributed Systems
A curated list of engineering series, deep dives, and notes related to #Distributed Systems.
Building a Custom Kubernetes Operator in Java: The Kubernetes Capstone
Build a complete, functional Kubernetes Custom Operator in Java with Custom Resources, Informer watchers, and Observe-Diff-Act reconciliation loops.
Building a Custom Distributed Rate Limiter & Resilience Gateway in Java: The System Design Capstone
Build a custom, runnable Distributed Rate Limiter & Resilience Gateway in Java from first principles. Synthesize token buckets, circuit breakers, and singleflight locks.
The Master System Design Framework: 4-Step Methodology for Senior & Staff Architect Interviews
Master the 4-step System Design interview framework. Learn requirement scoping, back-of-the-envelope estimation, and architecture deep dives.
Distributed Tracing & Observability: Trace Context Propagation, OpenTelemetry, and W3C Headers
Master distributed tracing and observability. Learn Trace IDs, Span IDs, W3C traceparent context propagation, and OpenTelemetry instrumentation.
Multi-Region Distributed Databases: Active-Active vs Active-Passive Cross-Data-Center Replication
Master multi-region distributed databases. Compare Active-Passive and Active-Active cross-datacenter replication models and conflict resolution.
Distributed Storage Engines: LSM-Trees (Cassandra/RocksDB) vs B+ Trees (Spanner/CockroachDB)
Master distributed storage engines. Compare Log-Structured Merge-Trees (Cassandra, RocksDB) with B+ Trees (InnoDB, Spanner, CockroachDB).
Kafka Exactly-Once Semantics (EOS): Idempotent Producers & 2PC Transactions
Learn how Kafka achieves Exactly-Once Semantics (EOS) across read-process-write stream loops using Idempotent Producers, Transactional Coordinators, and 2PC.
Distributed Message Queues: Log-Based (Kafka) vs AMQP Broker-Based (RabbitMQ)
Master distributed message queues. Compare log-based event streaming (Kafka) with AMQP smart broker routing (RabbitMQ).
Event-Driven Systems: CQRS (Command Query Responsibility Segregation) & Event Sourcing
Master CQRS and Event Sourcing. Learn how separating commands from queries and storing events as immutable facts scales complex domain models.
Kafka Partition Replication: High Watermark, LEO & In-Sync Replicas (ISR)
Learn how Kafka achieves high availability without data corruption using leader/follower replication, High Watermarks, ISR tracking, and Leader Epochs.
Distributed Caching Patterns: Cache-Aside, Write-Through, Write-Back, and Cache Stampedes
Master distributed caching patterns. Learn Cache-Aside, Write-Through, Write-Back, Cache Penetration, Cache Breakdown, and Thundering Herd mitigation.
Load Balancing Architectures: Layer 4 vs Layer 7, Consistent Hash, and Power of Two Choices
Master load balancing architectures. Learn Layer 4 vs Layer 7 load balancing, gRPC HTTP/2 connection pooling traps, and Power of Two Random Choices.
The Circuit Breaker Pattern: Protecting Services from Cascading Failures
Master the Circuit Breaker pattern. Learn how state transitions (Closed, Open, Half-Open) isolate failing dependencies and prevent cascading outages.
Building Distributed Rate Limiters: Token Bucket, Leaky Bucket, and Sliding Window Logs
Master distributed rate limiters. Learn Token Bucket, Leaky Bucket, Fixed Window, and Sliding Window algorithms with atomic Redis Lua scripts.
Distributed Locking Mechanics: Lease Expiration, Redlock, and ZooKeeper Fencing Tokens
Master distributed locking algorithms. Understand Redis Redlock flaws, ZooKeeper ephemeral sequential nodes, and monotonically increasing fencing tokens.
Distributed Consensus Protocols: Paxos vs Raft Leader Election & Log Replication
Master distributed consensus. Compare Paxos and Raft leader election, log replication, safety invariants, and quorum math.
Distributed Transactions: Two-Phase Commit (2PC) vs The Saga Pattern
Master distributed transactions. Compare Two-Phase Commit (2PC) blocking mechanics with Saga Pattern choreography, orchestration, and compensating actions.
Gossip Protocols & Cluster Membership: How Decentralized Nodes Maintain Topology
Master Gossip Protocols and cluster membership. Learn how decentralized nodes detect failures and propagate state without a central master.
Database Sharding & Partitioning Strategies: Range, Hash, and Dynamic Rebalancing
Master database sharding strategies. Learn range partitioning, hash sharding, cross-shard query traps, and dynamic shard splitting.
Book Notes: Designing Data-Intensive Applications by Martin Kleppmann
Key architectural takeaways, data model trade-offs, replication logs, and consensus algorithms from Kleppmann's classic text.
Kafka Architecture Deep Dive: Topics, Partitions, and Offset Ordering Rules
Deconstruct Kafka storage anatomy: Topics, Partitions, and Offsets. Learn how partition sharding scales write throughput and consumer parallelism.
Consistent Hashing & Virtual Nodes: Distributing Keys Without Mass Resharding
Master Consistent Hashing and Virtual Nodes. Learn how distributed caches and databases route keys without mass key migration.
The Append-Only Log Abstraction: Why Immutability Rules Event Streaming
Explore the append-only log data structure behind Apache Kafka. Learn how immutability enables lock-free concurrency and multi-team data replay.
etcd Internals: Raft Consensus, MVCC Key-Value Storage, and Watch Streams
Master etcd internals: Raft consensus quorum math, MVCC bbolt B+ tree storage, revision counters, compaction, and gRPC watch streams.
Vector Clocks and Conflict Resolution: Detecting Concurrent Writes in Distributed State
Master Vector Clocks and causal consistency. Learn how vector timestamps detect concurrent writes, manage sibling branches, and resolve conflicts.
Time in Distributed Systems: Physical Clock Skew, NTP Drift, and Lamport Timestamps
Master time in distributed systems. Learn why physical clocks drift, NTP synchronization fails, and how Lamport Timestamps enforce logical event ordering.
Why Apache Kafka Exists: Solving Microservice N² Integration Spaghetti
Discover why Apache Kafka was created at LinkedIn. Learn how central append-only event logs solve microservice point-to-point integration spaghetti.
Why Single-Host Docker Fails at Scale: The Distributed Orchestration Problem
Discover why single-host Docker setups fail at scale: host failure domains, manual port allocation conflicts, stateful failover, and scheduling bottlenecks.
The Fallacies of Distributed Computing: PACELC, CAP Theorem, and Network Partitions
Understand the 8 Fallacies of Distributed Computing, CAP Theorem trade-offs, PACELC model, and network partition failure modes.
Mastering Apache Kafka from First Principles: Series Introduction & Learning Roadmap
Discover what you will learn in this 19-part series on Apache Kafka internals. Master distributed append-only logs, zero-copy I/O, and KRaft.
Mastering Kubernetes & Distributed Orchestration: Series Introduction & Learning Roadmap
Discover what you will learn in this 20-part series on Kubernetes Internals. Build a custom Kubernetes Operator and master control plane mechanics.
Mastering System Design & Distributed Systems: Series Introduction & Learning Roadmap
Discover what you will learn in this 20-part series on System Design & Distributed Systems. Build a distributed rate limiter and master Raft.