Home>Learn>Distributed Systems

distributed systems

Distributed Systems

Move through replication, consensus, quorum, leader election, transactions, and failure recovery as one connected system.

132

Resources

40h 32m

Total Learning Time

0/132

Completed

Start Learning

Choose your learning style

Multiple ways to learn the same concept. Pick what works best for you.

Distributed Systems

Choose your learning style

Recommended Articles

Data Anomalies in Distributed Systems: Split Brain, Clock Skew, Stale Reads, and More

A Guide to Raft, Paxos, and Consensus Algorithms

The Dual Write Problem in NoSQL: MongoDB, DynamoDB, and Cassandra

Split Brain Explained: When Two Nodes Both Think They Are Leader

How Kafka Works: The Log That Never Forgets

The 8 Fallacies of Distributed Systems

Key Terms in Distributed Systems: The Definitive Glossary

System Design for Agentic AI Systems: From Distributed Systems Principles to Production

Bulkhead Pattern: Isolating Capacity to Protect Critical Workloads

Database Anomalies: How SQL and NoSQL Handle Dirty Reads, Phantom Reads, and Write Skew

Dirty Write Explained: When Uncommitted Data Gets Overwritten

Dirty Read Explained: How Uncommitted Data Corrupts Transactions

Lost Update Explained: When Two Writes Become One

Non-Repeatable Read Explained: When the Same Query Returns Different Results

Phantom Read Explained: When New Rows Appear Mid-Transaction

Read Skew Explained: Inconsistent Snapshots Across Multiple Objects

System Design Databases: SQL vs NoSQL and Scaling

System Design Multi-Region Deployment: Latency, Failover, and Consistency Across Regions

System Design Replication and Failover: Keep Services Alive When a Primary Dies

System Design Sharding Strategy: Choosing Keys, Avoiding Hot Spots, and Resharding Safely

Write Skew Explained: The Anomaly That Requires Serializable Isolation

CAP Theorem Explained

The Consistency Continuum: From Read-Your-Own-Writes to Leaderless Replication

Stale Reads and Cascading Failures in Distributed Systems

Change Feed vs Change Stream: CDC Internals, Reliability, and When to Avoid Each

Redis Sorted Sets Explained: Skip Lists, Scores, and Real-World Use Cases

System Design HLD Example: Distributed Job Scheduler

System Design HLD Example: Notification Service (Email, SMS, Push)

ACID Transactions in Distributed Databases: DynamoDB, Cosmos DB, and Spanner Compared

Azure Cosmos DB API Modes Explained: NoSQL, MongoDB, Cassandra, PostgreSQL, Gremlin, and Table

The Dual Write Problem: Why Two Writes Always Fail Eventually — and How to Fix It

Distributed Transactions: 2PC, Saga, and XA Explained

System Design HLD Example: Chat and Messaging Platform

Cloud Architecture Patterns: Cells, Control Planes, Sidecars, and Queue-Based Load Leveling

Consistent Hashing: Scaling Without Chaos

Compare-and-Swap and Optimistic Locking: How Every Database Implements It

Azure Cosmos DB Consistency Levels Explained: Strong, Bounded Staleness, Session, Consistent Prefix, and Eventual

Event Sourcing Pattern: Auditability, Replay, and Evolution of Domain State

System Design: Designing an Autonomous AI Coding Agent (Devin at Scale)

Integration Architecture Patterns: Orchestration, Choreography, Schema Contracts, and Idempotent Receivers

Modernization Architecture Patterns: Strangler Fig, Anti-Corruption Layers, and Modular Monoliths

Sharding Approaches in SQL and NoSQL: Range, Hash, and Directory-Based Strategies Compared

System Design Advanced: Security, Rate Limiting, and Reliability

System Design API Design for Interviews: Contracts, Idempotency, and Pagination

System Design HLD Example: Distributed Cache Platform

Microservices Architecture: Decomposition, Communication, and Trade-offs

System Design HLD Example: Distributed Rate Limiter

System Design Message Queues and Event-Driven Architecture: Building Reliable Asynchronous Systems

System Design Protocols: REST, RPC, and TCP/UDP

System Design HLD Example: Payment Processing Platform

High-Level Design: Scaling a Concert Ticket Booking System under Flash Load

System Design Networking: DNS, CDNs, and Load Balancers

System Design Interview Basics: A Beginner-Friendly Framework for Clear Answers

System Design Service Discovery and Health Checks: Routing Traffic to Healthy Instances

System Design Requirements and Constraints: Ask Better Questions Before You Draw

Understanding Consistency Patterns: An In-Depth Analysis

Write-Time vs Read-Time Fan-Out: How Social Feeds Scale

Apache Cassandra Architecture: When to Use, Pitfalls, and Performance Tuning

Remote Service Adapters: Decoupling Inter-Service Dependencies with Hexagonal Architecture

Delta CRDTs: Bandwidth‑Efficient Edge Collaboration

Mastering Backpressure in Distributed Systems: Strategies for Flow Control and Resilience

SAGA Pattern Compensations

Ordering Matters: Outbox vs Saga for Event‑Driven Consistency

Big Data 101: The 5 Vs, Ecosystem, and Why Scale Breaks Everything

Reading and Writing Data in Spark: Parquet, Delta, JSON, and JDBC

Partitioning in Spark: HashPartitioner, RangePartitioner, and Custom Strategies

Shuffles in Spark: Why groupBy Kills Performance

Watermarking and Late Data Handling in Spark Structured Streaming

System Design HLD Example: Ride-Sharing (Uber/Lyft)

Sharding vs Partitioning

Outbox Table Partitioning: Scaling Event Delivery Without Locking

Transactional Outbox Pattern: Design, Implementation, and Scaling Trade‑offs in Event‑Driven Microservices

Bloom Filters Explained: Membership Testing with Zero False Negatives

The Role of Data in Precise Capacity Estimations for System Design

Clock Skew and Causality Violations: Why Distributed Clocks Lie

Count-Min Sketch Explained: Frequency Estimation at Streaming Scale

CQRS Pattern: Separating Write Models from Query Models at Scale

Hybrid Logical Clocks: The Invisible Timekeeper for Causal Consistency