DEV Community

Cover image for What Really Happens When You Send a WhatsApp Message?
Tanu Priya
Tanu Priya

Posted on

What Really Happens When You Send a WhatsApp Message?

You type:

“Hey, are you free tonight?”

You tap Send.

A second later, your friend receives it.

It feels like your phone simply sent a few characters to another phone.

It didn't.

Behind that single message is a distributed system handling network communication, encryption, message delivery, acknowledgements, offline users, multiple devices, and millions of concurrent users.

So what actually happens?

The Big Picture

A simplified messaging architecture looks like this:

Your Phone
    ↓
Encrypt Message
    ↓
Internet
    ↓
Messaging Infrastructure
    ↓
Message Routing
    ↓
Recipient's Device
    ↓
Decrypt Message
    ↓
Display Message
Enter fullscreen mode Exit fullscreen mode

If the recipient is offline:

Sender
   ↓
Messaging Infrastructure
   ↓
Temporary Storage
   ↓
Recipient Comes Online
   ↓
Message Delivered
Enter fullscreen mode Exit fullscreen mode

Let's understand the theory behind each stage.

1. The Message Starts on Your Device

When you press Send, the WhatsApp application creates a message containing the information required to process and deliver it.

Conceptually:

Message
├── Content
├── Sender
├── Recipient
├── Message ID
└── Metadata
Enter fullscreen mode Exit fullscreen mode

The message also needs a unique identifier.

Why?

Because distributed systems can retry operations.

If the same request reaches the server twice, the system needs a way to recognize that they may represent the same message.

This is where concepts such as idempotency and unique message IDs become important.

2. The Message Is Encrypted

WhatsApp uses end-to-end encryption for personal messages.

The basic idea is:

Sender
   ↓
Encrypt
   ↓
Encrypted Message
   ↓
Server
   ↓
Encrypted Message
   ↓
Recipient
   ↓
Decrypt
Enter fullscreen mode Exit fullscreen mode

The important concept is that the message is protected between the communicating endpoints.

WhatsApp's messaging security is based on the Signal Protocol, with WhatsApp-specific implementation and multi-device mechanisms.

This is different from simply using HTTPS.

HTTPS 

Client → Encrypted Connection → Server
Enter fullscreen mode Exit fullscreen mode

The server terminates the connection.

End-to-End Encryption 

Sender → Encrypted Message → Recipient
Enter fullscreen mode Exit fullscreen mode

The message content is intended to remain protected from the service while it is being transported.

3. The Message Travels Through the Internet

Your phone doesn't directly connect to your friend's phone.

The message travels through networks:

Phone
  ↓
Wi-Fi / Mobile Network
  ↓
ISP / Carrier
  ↓
Internet
  ↓
Messaging Infrastructure
Enter fullscreen mode Exit fullscreen mode

The internet is a packet-switched network.

Data is divided into packets that travel across interconnected networks before reaching their destination.

This introduces a fundamental problem:

Networks are unreliable.

Packets can be delayed.

Connections can disappear.

Devices can go offline.

Servers can fail.

A messaging system therefore needs mechanisms to handle these failures.

4. The Message Reaches Distributed Infrastructure

A service like WhatsApp cannot depend on one server.

Imagine billions of users sending messages.

A simplified architecture might look like:

                 Users
                   ↓
             Load Balancer
                   ↓
        ┌──────────┼──────────┐
        ↓          ↓          ↓
     Server A   Server B   Server C
        │          │          │
        └──────────┼──────────┘
                   ↓
            Message System
Enter fullscreen mode Exit fullscreen mode

This is a distributed system.

Instead of one machine doing everything, many machines work together.

This provides:

  • Scalability
  • Fault tolerance
  • High availability
  • Load distribution

If one machine fails, other machines can continue handling traffic.

5. The System Routes the Message

Once the message reaches the messaging infrastructure, it needs to be delivered to the correct recipient.

Conceptually:

Sender
   ↓
Message
   ↓
Routing
   ↓
Recipient
Enter fullscreen mode Exit fullscreen mode

But the recipient may not be online.

And this creates one of the most important problems in messaging systems.

6. What If the Recipient Is Offline?

Suppose your friend has no internet connection.

You send:

"Are you free tonight?"
Enter fullscreen mode Exit fullscreen mode

The recipient cannot receive it immediately.

The system therefore needs a mechanism to retain the message temporarily until delivery becomes possible.

Conceptually:

Sender
   ↓
Server
   ↓
Temporary Message Storage
   ↓
Recipient Offline
Enter fullscreen mode Exit fullscreen mode

Later:

Recipient Comes Online
        ↓
Pending Message
        ↓
Recipient Device
Enter fullscreen mode Exit fullscreen mode

This is why messaging systems are closely related to concepts such as queues, buffering, persistence, and asynchronous communication.

The sender shouldn't have to wait for the recipient to be online.

7. Messaging Is Asynchronous

This is one of the most important ideas.

A synchronous system might look like:

Sender → Recipient
         ↓
       Response
Enter fullscreen mode Exit fullscreen mode

The sender waits for the recipient.

Messaging systems generally work differently.

Sender
   ↓
Send Message
   ↓
Messaging Infrastructure
   ↓
Recipient
Enter fullscreen mode Exit fullscreen mode

The sender and recipient don't need to be online at exactly the same moment.

This is called asynchronous communication.

It is one of the fundamental ideas behind modern distributed systems.

8. How Does WhatsApp Know the Message Was Delivered?

The system needs acknowledgements.

A simplified flow is:

Sender
   │
   │ Message
   ▼
Server
   │
   │ Deliver
   ▼
Recipient
   │
   │ ACK
   ▼
Server
   │
   │ Status
   ▼
Sender
Enter fullscreen mode Exit fullscreen mode

An ACK (acknowledgement) tells the system that an operation reached a particular stage.

This concept appears throughout distributed systems.

For example:

Client → Server
       ← ACK

Producer → Queue
         ← ACK
Enter fullscreen mode Exit fullscreen mode

Messaging applications use similar ideas to track delivery state.

9. Why Are There Different Message States?

A message doesn't simply have two states:

Sent
Received
Enter fullscreen mode Exit fullscreen mode

There can be multiple stages.

Conceptually:

Created
   ↓
Sent
   ↓
Delivered
   ↓
Read
Enter fullscreen mode Exit fullscreen mode

These states represent different events.

For example:

Sent
The message has been submitted for delivery.

Delivered
The recipient's device has received it.

Read
The recipient has opened or viewed the message, subject to the relevant settings and chat type.

The important system-design concept is that these are state transitions.

10. What Happens When You Send a Photo?

Text messages are tiny compared with videos and images.

A messaging system therefore needs to treat media differently.

Conceptually:

Photo
  ↓
Encrypt / Prepare
  ↓
Upload
  ↓
Media Storage
  ↓
Message Contains Media Reference
  ↓
Recipient Downloads Media
  ↓
Decrypt
  ↓
Display
Enter fullscreen mode Exit fullscreen mode

This introduces another major system-design concept:

Object storage and large-file delivery.

Instead of putting a large video directly inside a normal database record, systems typically use specialized storage infrastructure for large files.

11. What About Multiple Devices?

Today, one account can be associated with multiple devices.

For example:

              User
               │
       ┌───────┼───────┐
       ↓       ↓       ↓
     Phone   Laptop   Tablet
Enter fullscreen mode Exit fullscreen mode

Now the system has another problem:

How do we keep multiple devices synchronized?

The system needs to manage:

  • Device identities
  • Message synchronization
  • Delivery state
  • Encryption keys
  • Connection state

This makes multi-device messaging significantly more complex than simple phone-to-phone communication.

12. What Happens When the Network Fails?

Imagine:

Send
 ↓
Network Lost
 ↓
Retry
 ↓
Network Available
 ↓
Send Again
Enter fullscreen mode Exit fullscreen mode

Distributed systems must assume that failures will happen.

The system therefore needs mechanisms for:

  • Retries
  • Timeouts
  • Acknowledgements
  • Duplicate detection
  • Reconnection
  • State recovery

This leads to an important principle:

Distributed systems are designed around failure, not around the assumption that everything works perfectly.

13. Scaling to Millions of Messages

Now imagine millions of people sending messages simultaneously.

The system needs to distribute work across many machines.

A simplified architecture:

                    Users
                      ↓
                Load Balancers
                      ↓
          ┌───────────┼───────────┐
          ↓           ↓           ↓
       Servers      Servers      Servers
          │           │           │
          └───────────┼───────────┘
                      ↓
               Message Services
                      ↓
            Storage / Delivery
                      ↓
                  Devices
Enter fullscreen mode Exit fullscreen mode

This architecture allows the workload to scale horizontally.

Instead of buying one extremely powerful machine, the system can add more machines as demand grows.

That's horizontal scaling.

14. The Complete Journey

Putting everything together:

              You
               ↓
          Type Message
               ↓
            Encrypt
               ↓
          Internet
               ↓
       Load Balancing
               ↓
       Message Routing
               ↓
      ┌────────┴────────┐
      ↓                 ↓
 Recipient Online   Recipient Offline
      ↓                 ↓
   Deliver          Temporary Storage
      ↓                 ↓
      └────────┬────────┘
               ↓
       Recipient Device
               ↓
            Decrypt
               ↓
        Display Message
               ↓
        Delivery / Read
          Acknowledgement
               ↓
             Sender
Enter fullscreen mode Exit fullscreen mode

What looks like:

"Hey!"
Enter fullscreen mode Exit fullscreen mode

is actually a journey through multiple distributed-system components.

The System Design Lessons

WhatsApp is a great real-world example of several important concepts:

Asynchronous Communication

The sender and recipient don't need to be online simultaneously.

End-to-End Encryption

Message content is protected between communicating endpoints.

Distributed Systems

Many machines cooperate to handle global traffic.

Message Queuing

Messages can wait for recipients who are temporarily unavailable.

Acknowledgements

The system tracks different delivery states.

Idempotency

Retries shouldn't accidentally create duplicate messages.

Horizontal Scaling

More servers can be added to handle increasing traffic.

Fault Tolerance

The system must continue operating despite network and server failures.

Object Storage

Large media files require specialized storage and delivery mechanisms.

Synchronization

Multiple devices need to maintain consistent message state.

Final Takeaway

Sending a WhatsApp message looks like a simple operation:

Type → Send → Receive
Enter fullscreen mode Exit fullscreen mode

But the underlying system is closer to:

Message
   ↓
Encryption
   ↓
Network
   ↓
Distributed Infrastructure
   ↓
Routing
   ↓
Queue / Temporary Storage
   ↓
Delivery
   ↓
Acknowledgement
   ↓
Synchronization
   ↓
Recipient
Enter fullscreen mode Exit fullscreen mode

The fascinating part isn't the Send button.

It's everything that has to happen after you press it.

A modern messaging application has to deliver data securely and reliably despite unreliable networks, offline users, massive traffic, multiple devices, and constantly changing system state.

One tiny message is a distributed system in action.

Top comments (0)