How does WhatsApp deliver a message in real time?

Each phone holds a long-lived, persistent connection (a WebSocket-style socket, historically over XMPP) to a chat server, so the server can push a message down the instant it arrives rather than the phone polling for it. When you send a message it goes to the server, which looks up the recipient's connection and pushes it to their device. If the recipient is offline, the server stores the message and delivers it — and the queued delivery receipts — the moment they reconnect.

How do the one, two, and blue check marks work?

They are delivery and read receipts, and each is an acknowledgement traveling back up the chain. One grey tick means the server received your message. Two grey ticks mean it was delivered to the recipient's device (their phone ACKed it). Two blue ticks mean the recipient's app reported the chat was opened and the message read. Each state is a small ack message flowing the opposite direction of the original, which is why they can lag when someone is offline.

How does WhatsApp guarantee a message is never lost?

With acknowledgements and store-and-forward. The sender keeps a message marked 'pending' until the server acks it; the server persists the message durably before acking, then keeps it until the recipient's device acks delivery. If the recipient is offline the message sits in their server-side queue. Retries plus idempotent message IDs mean a dropped connection causes a resend, not a lost or duplicated message — the message ID lets the receiver discard a duplicate.

How is message ordering kept consistent?

Each message carries a monotonically increasing sequence number or timestamp scoped to the conversation, and the recipient's client orders by it, buffering briefly to reabsorb any out-of-order arrivals from retries. Routing a given conversation's messages through the same server or partition keeps a single ordering authority, so two people in a chat see the same sequence even though the network delivers packets unpredictably.

How does group messaging scale to hundreds of members?

The sender uploads the message once, and the server fans it out — it looks up every group member's connection and pushes a copy to each, queuing for anyone offline. This server-side fan-out means the sender's phone doesn't send N copies over its own limited uplink. For encryption, WhatsApp uses the Signal 'sender keys' scheme so a group message is encrypted once per sender rather than separately for every recipient, keeping large groups practical.

How does end-to-end encryption work here?

WhatsApp uses the Signal Protocol. Messages are encrypted on the sender's device with keys only the participants hold, so the server relays ciphertext it cannot read. The Double Ratchet algorithm rotates keys per message for forward secrecy (a stolen key can't decrypt past messages). The trade-off is that server-side features like search must happen on-device, and multi-device support requires syncing keys securely across a user's own devices.

How does presence — 'online' and 'typing…' — work?

Presence is ephemeral, high-churn state that is deliberately not stored durably. When you open a chat, your device subscribes to the other person's presence; their 'online' and 'typing…' events are pushed only to the currently subscribed watchers and kept in memory, not written to the main database. Because it changes constantly and matters only in the moment, presence is optimized for freshness over durability — losing it on a server restart is fine.

How does it handle billions of users and connections?

By keeping per-connection work cheap and sharding everything. Connections are spread across many chat servers built for massive concurrency (WhatsApp famously ran millions of connections per box on Erlang), a session registry maps each user to the server holding their live socket so messages can be routed to it, and users and message queues are partitioned by user ID. Offline queues and media live in separate horizontally-scaled stores, so no single component owns all the traffic.

Design WhatsApp — A Guided System Design

System Design · step by stepDesign WhatsApp

Step 1 / 10

Finished this one? 0 / 62 System Designs done

Explore the topic

See this alongside everything else on the same subject — handbooks, system designs, challenges and tools, in one place.

Real-time & Messaging

The concepts behind this design

The same core ideas underpin every system on this site. Master them once, then spot them everywhere.

The System Design Fundamentals HandbookThe load-bearing ideas behind every distributed system — the CAP theorem and consistency models, concurrency and locking, partitioning and replication, and consensus and coordination — each tied to a real worked design you can study interactively.Learn the fundamentals →
CAP Theorem & Consistency ModelsWhat a distributed system can promise when the network splits — CP vs AP, why "CA" is a myth, PACELC, and the full spectrum from linearizable to eventual consistency. Part of System Design Fundamentals.Learn the fundamentals →
Consensus, Transactions & CoordinationHow nodes that can crash still agree on one truth — majority quorums, Raft and Paxos, leader election, two-phase commit vs the saga pattern, and idempotency for exactly-once effects. Part of System Design Fundamentals.Learn the fundamentals →

More System Designs

Cite this page

Reference it in your work, paper or an AI's context window.

APASingh, S. (2026). Design WhatsApp. Vibe Engines. https://vibeengines.com/systemdesign/whatsapp-system-design

MLASingh, Saurabh. “Design WhatsApp.” Vibe Engines, 2026, vibeengines.com/systemdesign/whatsapp-system-design.

BibTeX

@online{vibeengines-whatsapp-system-design,
  author       = {Singh, Saurabh},
  title        = {Design WhatsApp},
  year         = {2026},
  organization = {Vibe Engines},
  url          = {https://vibeengines.com/systemdesign/whatsapp-system-design}
}

Explore the topic

The concepts behind this design

More System Designs

Explore more from Vibe Engines

Get the next one in your inbox.

Cite this page