Articles tagged with #System Design
A curated list of engineering series, deep dives, and notes related to #System Design.
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.
Frontend System Design Interview Framework: Component Topology, Data Flow, and Scalability
Master the 4-step Frontend System Design Interview Framework. Learn component topology, API contract design, state data flow, and scalability.
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).
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.
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.
Demystifying ACID: Transactions as an Isolation & Recovery Abstraction
Deconstruct ACID transaction guarantees in database engines. Learn how atomicity, consistency, isolation, and durability function under the hood.
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.
TypeScript for System Design: Advanced Type Mechanics, Nominal Branding, and Turing Completeness
Master TypeScript for System Design. Learn nominal branding, distributive conditional types, template literal key remapping, and type-level state machines.
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 Files Fail as Databases: Concurrent Access, Update Anomalies & Crash Recovery
Discover why storing application data inside flat CSV or JSON files leads to race conditions, lost updates, corrupted data on crash, and performance failure.
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.
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 Database Internals from First Principles: Series Introduction & Learning Roadmap
Discover what you will learn in this 20-part series on Database Internals. Build a transactional storage engine and master B+ Trees and MVCC.
Mastering Frontend Web Architecture & Performance: Series Introduction & Learning Roadmap
Master frontend web architecture from first principles. Explore V8 internals, React Fiber, Core Web Vitals, micro-frontends, and edge rendering.
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.