System Design

Learn System Design

How to Learn System Design?

Scalability

Availability

Latency and Performance

Concurrency and Coordination

Monitoring and Observability

Resilience and Error Handling

Fault Tolerance vs. High Availability

Flashcards Review

Chapter Assessment

HTTP vs. HTTPS

TCP vs. UDP

HTTP: 1.0 vs. 1.1 vs 2.0 vs. 3.0

URL vs. URI vs. URN

What Happens When You Type a URL into the Browser

Flashcards Review

Chapter Assessment

Introduction to Real-Time Communication

What is Long-Polling?

What is WebSocket?

What are Server-Sent Events?

Difference Between Long-Polling, WebSockets, and Server-Sent Events

Flashcards Review

Chapter Assessment

Introduction to DNS

DNS Resolution Process

DNS Load Balancing and High Availability

Flashcards Review

Chapter Assessment

What is a Proxy Server?

Uses of Proxies

VPN vs. Proxy Server

Flashcards Review

Chapter Assessment

Introduction to Load Balancing

Load Balancing Algorithms

Uses of Load Balancing

Load Balancer Types

Stateless vs. Stateful Load Balancing

High Availability and Fault Tolerance

Scalability and Performance

Challenges of Load Balancers

Flashcards Review

Chapter Assessment

Introduction to API Gateway

Usage of API gateway

Advantages and disadvantages of using API gateway

Flashcards Review

Chapter Assessment

What Is an API?

What Are REST APIs?

Resources, Not Actions

HTTP Methods and Their Semantics

URL Design

Request and Response Shapes

Status Codes and Error Design

Pagination from the Consumer's View

Idempotency Keys

Versioning and Backward Compatibility

Concurrency and Conditional Requests

REST vs gRPC vs GraphQL

Flashcards Review

Chapter Assessment

What Is Rate Limiting

Rate Limiting Algorithms

Distributed Rate Limiting

Rate Limiting in Practice

Flashcards Review

Chapter Assessment

Introduction to Caching

Why is Caching Important?

Types of Caching

Cache Replacement Policies

Cache Invalidation

Cache Read Strategies

Cache Coherence and Consistency Models

Caching Challenges

Cache Performance Metrics

Flashcards Review

Chapter Assessment

What is CDN?

Origin Server vs. Edge Server

CDN Architecture

Push CDN vs. Pull CDN

Flashcards Review

Chapter Assessment

Introduction to Data Partitioning

Partitioning Methods

Data Sharding Techniques

Benefits of Data Partitioning

Common Problems Associated with Data Partitioning

Flashcards Review

Chapter Assessment

What is Redundancy?

What is Replication?

Replication Methods

Data Backup vs. Disaster Recovery

Flashcards Review

Chapter Assessment

Introduction to CAP Theorem

Components of CAP Theorem

Trade-offs in CAP Theorem

Examples of CAP Theorem in Practice

Beyond CAP Theorem

System Design Trade-offs in Interviews

Flashcards Review

Chapter Assessment

Introduction to Databases

SQL Databases

NoSQL Databases

SQL vs. NoSQL

ACID vs BASE Properties

Real-World Examples and Case Studies

SQL Normalization and Denormalization

In-Memory Database vs. On-Disk Database

Data Replication vs. Data Mirroring

Database Federation

Flashcards Review

Chapter Assessment

What are Indexes?

How a B-Tree Index Works

Types of Indexes

B-Tree vs. LSM Tree

Indexes in Distributed Systems

Flashcards Review

Chapter Assessment

Introduction to Bloom Filters

Benefits & Limitations of Bloom Filters

Variants and Extensions of Bloom Filters

Applications of Bloom Filters

Flashcards Review

Chapter Assessment

Why Quorum?

What is Quorum?

Flashcards Review

Chapter Assessment

What is Leader and Follower Pattern?

Flashcards Review

Chapter Assessment

What is Heartbeat?

Flashcards Review

Chapter Assessment

What is Checksum?

Uses of Checksum

Flashcards Review

Chapter Assessment

Introduction to Messaging System

Introduction to Kafka

Messaging patterns

Popular Messaging Queue Systems

RabbitMQ vs. Kafka vs. ActiveMQ

Scalability and Performance

Flashcards Review

Chapter Assessment

What is a Distributed File System?

Architecture of a Distributed File System

Key Components of a DFS

Flashcards Review

Chapter Assessment

What is Security and Privacy?

What is Authentication?

What is Authorization?

Authentication vs. Authorization

OAuth vs. JWT for Authentication

What is Encryption?

What are DDoS Attacks?

Flashcards Review

Chapter Assessment

Batch Processing vs. Stream Processing

XML vs. JSON

Synchronous vs. Asynchronous Communication

Push vs. Pull Notification Systems

Microservices vs. Serverless Architecture

Message Queues vs. Service Bus

Stateful vs. Stateless Architecture

Event-Driven vs. Polling Architecture

Flashcards Review

Chapter Assessment

Quiz

Importance of Discussing Trade-offs

Strong vs Eventual Consistency

Latency vs Throughput

ACID vs BASE Properties in Databases

Read-Through vs Write-Through Cache

Batch Processing vs Stream Processing

Load Balancer vs. API Gateway

API Gateway vs Direct Service Exposure

Proxy vs. Reverse Proxy

API Gateway vs. Reverse Proxy

SQL vs. NoSQL

Primary-Replica vs Peer-to-Peer Replication

Data Compression vs Data Deduplication

Server-Side Caching vs Client-Side Caching

REST vs RPC

Polling vs. Long-Polling vs. WebSockets vs. Webhooks

CDN Usage vs Direct Server Serving

Serverless Architecture vs Traditional Server-based

Stateful vs Stateless Architecture

Hybrid Cloud Storage vs All-Cloud Storage

Token Bucket vs Leaky Bucket

Read Heavy vs Write Heavy System

Quiz

System Design Interviews - A step by step guide

Functional vs. Non-functional Requirements

What are Back-of-the-Envelope Estimations?

Things to Avoid During System Design Interview

System Design Master Template

Quiz

Designing a URL Shortening Service like TinyURL

Quiz - Designing URL Shortner

Designing Pastebin

Quiz - Designing Pastebin

Designing Instagram

Quiz - Designing Instagram

Designing Dropbox

Quiz - Designing Dropbox

Designing Facebook Messenger

Quiz - Designing Facebook Messenger

Designing Twitter

Quiz - Designing Twitter

Designing Youtube or Netflix

Quiz - Designing Youtube

Designing Typeahead Suggestion

Quiz - Designing Typeahead Suggestion

Designing an API Rate Limiter

Quiz - Designing an API Rate Limiter

Designing Twitter Search

Quiz - Designing Twitter Search

Designing a Web Crawler

Quiz - Designing a Web Crawler

Designing Facebook’s Newsfeed

Quiz - Designing Facebook’s Newsfeed

Designing Yelp or Nearby Friends

Quiz - Designing Yelp or Nearby Friends

Designing Uber backend

Quiz - Designing Uber backend

Designing Ticketmaster

Quiz - Designing Ticketmaster

Dynamo: How to design a key value store?

Dynamo: Introduction

High-Level Architecture

Data Partitioning

Replication

Vector Clocks and Conflicting Data

The Life of Dynamo’s put() & get() Operations

Anti-entropy Through Merkle Trees

Gossip Protocol

Dynamo Characteristics and Criticism

Summary: Dynamo

Quiz: Dynamo

Mock Interview: Dynamo

YouTube Likes Counter

Quiz

Cassandra: Introduction

High-level Architecture

Replication

Cassandra Consistency Levels

Gossiper

Anatomy of Cassandra's Write Operation

Anatomy of Cassandra's Read Operation

Compaction

Tombstones

Summary: Cassandra

Quiz: Cassandra

Mock Interview: Cassandra

Messaging Systems: Introduction

Kafka: Introduction

High-level Architecture

Kafka: Deep Dive

Consumer Groups

Kafka Workflow

Role of ZooKeeper

Controller Broker

Kafka Delivery Semantics

Kafka Characteristics

Summary: Kafka

Quiz: Kafka

Mock Interview: Kafka

Chubby: Introduction

High-level Architecture

Design Rationale

How Chubby Works

File, Directories, and Handles

Locks, Sequencers, and Lock-delays

Sessions and Events

Master Election and Chubby Events

Caching

Database

Scaling Chubby

Summary: Chubby

Quiz: Chubby

Mock Interview: Chubby

Hadoop Distributed File System: Introduction

High-level Architecture

Deep Dive

Anatomy of a Read Operation

Anatomy of a Write Operation

Data Integrity & Caching

Fault Tolerance

HDFS High Availability (HA)

HDFS Characteristics

Summary: HDFS

Quiz: HDFS

Mock Interview: HDFS

Google File System: Introduction

High-level Architecture

Single Master and Large Chunk Size

Metadata

Master Operations

Anatomy of a Read Operation

Anatomy of a Write Operation

Anatomy of an Append Operation

GFS Consistency Model and Snapshotting

Fault Tolerance, High Availability, and Data Integrity

Garbage Collection

Criticism on GFS

Summary: GFS

Quiz: GFS

Mock Interview: GFS

BigTable: Introduction

BigTable Data Model

System APIs

Partitioning and High-level Architecture

SSTable

GFS and Chubby

Bigtable Components

Working with Tablets

The Life of BigTable's Read & Write Operations

Fault Tolerance and Compaction

BigTable Refinements

BigTable Characteristics

Summary: BigTable

Quiz: BigTable

Mock Interview: BigTable

Design Reddit

Quiz

Designing a Notification System

Quiz

Design Google calendar (Medium)

Quiz

Design a Recommendation System for Netflix

Quiz

Design Gmail

Quiz

Design Google News, a Global News Aggregator System (Medium)

Quiz

Design Unique ID Generator (Easy)

Quiz

Design Code Judging System like LeetCode (Medium)

Quiz

Design Payment System

Quiz

Design a Flash Sale for an E-commerce Site (Hard)

Quiz

Design a Reminder Alert System

Quiz

Introduction: System Design Patterns

1. Bloom Filters

2. Consistent Hashing

3. Quorum

4. Leader and Follower

5. Write-ahead Log

6. Segmented Log

7. High-Water Mark

8. Lease

9. Heartbeat

10. Gossip Protocol

11. Phi Accrual Failure Detection

12. Split Brain

13. Fencing

14. Checksum

15. Vector Clocks

16. CAP Theorem

17. PACELC Theorem

18. Hinted Handoff

19. Read Repair

20. Merkle Trees

Quiz

Vector Clocks and Conflicting Data

Vector Clocks and Conflicting Data

consistency models

distributed systems

vector clocks

conflict resolution

+3

hard
·
7 min
·Updated Aug 2026·Credit: Grokking the Advanced System Design Interview

The previous lesson showed why a sloppy quorum lets multiple conflicting values exist for the same key. Let's look at how that happens, and how Dynamo deals with it.

What is clock skew?

On a single machine, one clock is enough. Suppose a write to key k lands at wall-clock time t1. A second write to the same key lands at t2. Since t2 is greater than t1, the second write is newer, and the database can safely overwrite the first value with it.

A distributed system breaks that assumption. Different clocks tend to run at different rates, a problem called clock skew. So time t on node a does not necessarily come before time t + 1 on node b, even though the numbers say so. Tools like

NTP
synchronize clocks about as well as anything practical can. Even they cannot guarantee that every clock agrees at every instant. Short of specialized hardware, like GPS units or atomic clocks, wall-clock timestamps alone are not enough to order writes.

What is a vector clock?

Instead of relying on tight clock synchronization, Dynamo tracks causality between versions with a vector clock. A vector clock is a list of (node, counter) pairs. Every version of every object stored in Dynamo carries one.

Comparing two vector clocks tells you how their versions relate. Say every counter in the first clock is less than or equal to the matching counter in the second. Then the first version is an ancestor of the second, and it can be forgotten. Otherwise, neither version can claim to be the ancestor of the other. The two changes are in conflict, and need reconciliation. Vector clocks detect that conflict at read time. They do not resolve it. Dynamo discards a version only when it is a strict ancestor of another. A genuine conflict goes back to the client, which reconciles it. Here is an example that shows how this plays out:

  1. Server A writes key k1 with the value foo, and assigns it version [A:1]. This write replicates to server B.
  2. Server A writes key k1 again, this time with value bar, and assigns it version [A:2]. This write also replicates to B.
  3. A network partition occurs. A and B can no longer talk to each other.
  4. Server A writes key k1 with value baz, and assigns it version [A:3]. It cannot replicate this to B, so the write sits in a hinted handoff buffer on another server instead.
  5. Server B writes key k1 with value bax, and assigns it version [B:1]. It cannot replicate this to A, so it too sits in a hinted handoff buffer on another server.
  6. The network heals, and A and B can talk to each other again.
  7. A read request for k1 arrives at either server. It finds two versions, [A:3] and [A:2][B:1], and neither can claim to be newer. It returns both to the caller. It leaves the client to figure out the right version, and write it back into the system.
Image
Conflict resolution using vector clocks

In the example above, most conflicts resolve themselves. A newer version subsumes the older one, since the system can see that [A:2] came after [A:1]. But failures and concurrent updates can overlap. When they do, versions branch, and the system is left holding genuinely conflicting versions of the same object. At that point the system cannot reconcile them on its own. So the client does the work: it collapses the branches back into one. That process is called semantic reconciliation.

Merging different versions of a customer's shopping cart is the standard example of a collapse like this. With this kind of reconciliation, an add, putting an item in the cart, is never lost. A deleted item, though, can resurface.

<p align="center">Resolving conflicts here works much like Git. When Git can merge two versions on its own, it does. When it can't, the developer reconciles them by hand.</p>

Vector clocks cannot grow forever, so Dynamo truncates them, dropping the oldest entries first once a clock grows too large. That has a cost. Say Dynamo drops an old vector clock that was still needed to reconcile an object's state. Then it can no longer achieve eventual consistency for that object. Dynamo's authors call this out as a real risk, without offering a fix for it. They do note that, as of their writing, it had not shown up in any of their production systems.

Conflict-free replicated data types (CRDTs)

There is a more straightforward way to sidestep conflicts: CRDTs, conflict-free replicated data types. Using one means modeling your data so that concurrent changes commute. That means they produce the same end result, no matter what order they run in. Once that holds, the system never has to worry about ordering at all.

Amazon's shopping cart is the classic example. A user adds two items, A and B, to the cart. Those two additions can run on any node, in any order, and the cart still ends up holding both items. (Removing an item is modeled as a negative add.) This property has a name: strong eventual consistency. It means any two nodes that have received the same set of updates end up seeing the same result. Riak ships a few built-in CRDTs.

Last-write-wins (LWW)

Modeling data as CRDTs is not always practical. In many cases it takes more effort than it is worth. That is why vector clocks with client-side resolution are usually considered good enough on their own.

Dynamo also gives you a way to resolve conflicts automatically, on the server, instead of using vector clocks. Dynamo, and Apache Cassandra, commonly use a simple policy for this: last-write-wins (LWW). LWW keeps the version with the later wall-clock timestamp. LWW can lose data easily. Say two conflicting writes happen at close to the same instant. Then keeping one over the other is no better than a random choice about which write gets thrown away.

Discussion
Have a question or insight about this topic? Share it with the community.
Reading Progress
0%

On This Page