Art of Code
Back to Blog
tutorials

How WhatsApp Handles Billions of Messages

Every time you send a “hi” or a meme, it feels instant. But behind that simplicity is a system engineered to handle **billions of messages daily** across unreli...

Jayanth Sanku4 min read
How WhatsApp Handles Billions of Messages

Every time you send a “hi” or a meme, it feels instant. But behind that simplicity is a system engineered to handle billions of messages daily across unreliable networks, diverse devices, and strict privacy guarantees. Let’s break down how a platform like WhatsApp actually pulls this off.

The Core Challenge

Messaging at this scale isn’t just about sending data from point A to B. The system must ensure:

  • Near real-time delivery

  • High availability (always on)

  • Message ordering and consistency

  • End-to-end encryption

  • Efficient handling of offline users

And all of this has to work globally, across different network conditions.

1. High-Level Architecture

At a high level, WhatsApp follows a client-server architecture:

  • Client (your phone): Creates, encrypts, and sends messages

  • Server: Routes messages, handles delivery, stores temporary data

  • Recipient client: Receives, decrypts, and displays messages

Unlike traditional systems, servers do not permanently store messages once delivered. This design improves privacy and reduces storage overhead.

2. Persistent Connections (Always-On Communication)

Instead of opening a new connection for every message, WhatsApp uses persistent TCP connections.

  • Your app maintains a lightweight, always-open connection to the server

  • Messages flow instantly without repeated handshakes

  • This reduces latency and battery usage

This is why messages feel “instant” even on slower networks.

3. Message Flow (Step-by-Step)

Here’s what happens when you hit send:

  1. Message is created on your device

  2. It gets encrypted locally

  3. Sent to WhatsApp servers

  4. Server identifies recipient and forwards message

  5. If recipient is online → delivered instantly

  6. If offline → stored temporarily and delivered later

Delivery States

  • ✔ Sent (one tick)

  • ✔✔ Delivered (two ticks)

  • ✔✔ Read (blue ticks)

These are just acknowledgments moving back through the same system.

4. Handling Offline Users

Not everyone is online all the time. So WhatsApp uses temporary message queues:

  • Messages are stored on the server only until delivered

  • Once delivered → deleted from the server

  • If undelivered for too long → may expire

This keeps storage minimal while still ensuring reliability.

5. Horizontal Scaling (The Real Backbone)

Handling billions of users means scaling across thousands of machines.

Key idea: Horizontal scaling

  • Instead of one powerful server → many smaller servers

  • Load is distributed across clusters

  • New servers can be added easily

WhatsApp historically used Erlang-based systems because they handle millions of concurrent connections efficiently.

6. Efficient Data Routing

When you send a message, the system needs to quickly locate the recipient.

  • User sessions are tracked in memory

  • Servers maintain mappings like: user → active server

  • Messages are routed directly without unnecessary hops

This reduces latency and improves throughput.

7. End-to-End Encryption (Privacy First)

One of WhatsApp’s defining features is end-to-end encryption, powered by the Signal Protocol.

  • Messages are encrypted on the sender’s device

  • Only the recipient can decrypt them

  • Even WhatsApp servers cannot read the content

This introduces challenges:

  • Servers can’t inspect messages for optimization

  • Metadata (not content) becomes important for routing

8. Media Handling (Images, Videos, Files)

Sending media is different from text:

  • Media is uploaded to a storage service

  • A secure link is generated

  • The link is sent via message

  • Recipient downloads media from storage

This avoids sending large files directly through messaging servers.

9. Reliability and Fault Tolerance

To avoid message loss:

  • Messages are acknowledged at each step

  • Retry mechanisms exist if delivery fails

  • Systems are replicated across regions

Even if part of the system fails, messages still get delivered.

10. Database and Storage Strategy

WhatsApp doesn’t rely heavily on traditional databases for messages.

  • Minimal persistent storage

  • Focus on in-memory systems for speed

  • Metadata stored efficiently

This design keeps the system fast and lightweight.

Key Design Trade-offs

Every system has compromises:

  • Speed vs Consistency: Slight delays to ensure ordering

  • Privacy vs Debugging: Encryption limits server-side insights

  • Storage vs Reliability: Minimal storage reduces cost but needs smart retry logic

Final Thoughts

What looks like a simple chat app is actually a massive distributed system optimized for:

  • Speed

  • Scale

  • Privacy

The brilliance of WhatsApp lies in keeping the user experience simple while solving deeply complex engineering problems behind the scenes.

One-line takeaway

“Messaging at scale is not about sending text — it’s about managing connections, consistency, and trust across billions of interactions.”