DEV Community

Shivam Yadav
Shivam Yadav

Posted on

How WhatsApp Works Without Internet: Offline Messaging and Synchronization Explained

#mobile #android

Imagine you're traveling on a flight with airplane mode enabled. You type a message to your friend:

"Hey, I just landed. Will call you soon."

You tap Send, and surprisingly the message immediately appears in your chat window. There is no internet connection, yet the message seems to have been sent.

How is that possible?

The answer lies in a design approach called offline-first architecture, where applications are designed to work even when network connectivity is unavailable. Modern messaging applications such as WhatsApp, Telegram, Signal, and Messenger rely heavily on this concept to provide a smooth user experience.

In this article, we'll explore what happens behind the scenes when you send messages without internet and how those messages eventually reach the recipient once connectivity returns.

Why Messaging Apps Need Offline Support

Internet connectivity is not always reliable.

Users may experience:

  • Airplane mode
  • Weak mobile networks
  • Temporary signal loss
  • Wi-Fi disconnections
  • Underground travel
  • Network congestion

If messaging applications depended entirely on a live internet connection, users would constantly encounter errors and failed actions.

Instead, modern messaging platforms are designed to continue functioning locally and synchronize changes later.

This provides several benefits:

  • Faster user experience
  • Better reliability
  • Reduced frustration
  • Consistent interface behavior
  • Ability to continue using the app even during network interruptions

The goal is simple:

Let users continue their work immediately and handle synchronization in the background.

A Simple Scenario: Sending a Message in Airplane Mode

Let's walk through a real-world example.

Suppose Alice opens WhatsApp while her phone is in airplane mode.

She sends:

"Are we meeting tomorrow?"

Although the device has no internet access, several things happen internally.

Step 1: Message Is Created Locally

The moment Alice presses the send button, the application creates a message object.

It may contain:

  • Message ID
  • Sender ID
  • Chat ID
  • Message content
  • Timestamp
  • Current status

Example:

{
  "id": "msg_101",
  "text": "Are we meeting tomorrow?",
  "sender": "Alice",
  "timestamp": "10:15 AM",
  "status": "pending"
}
Enter fullscreen mode Exit fullscreen mode

At this stage, the message exists only on Alice's device.

The server has not seen it yet.

Step 2: Message Is Stored in Local Storage

The app immediately saves the message in local storage.

This local database could be:

  • SQLite
  • Realm
  • MMKV
  • Core Data (iOS)
  • Room Database (Android)

The purpose is persistence.

Even if:

  • The app crashes
  • The phone restarts
  • The battery dies

the message remains safely stored.

Why Local Storage Is Important

Without local storage:

  1. User sends message
  2. Phone loses power
  3. Message disappears forever

With local storage:

  1. User sends message
  2. Message is saved locally
  3. Device restarts
  4. Message still exists

This creates a reliable experience.

Step 3: Message Appears Instantly in the Chat

This is the part users notice.

The message instantly shows up in the conversation.

Why?

Because the application displays data from local storage rather than waiting for server confirmation.

From the user's perspective:

You: Are we meeting tomorrow?
✓ Sending...
Enter fullscreen mode Exit fullscreen mode

The app is essentially saying:

"I have recorded your message. I'll deliver it when possible."

This creates the illusion of immediate responsiveness.

Message Queueing on the Device

Now the message enters a queue.

A queue is simply a list of pending actions waiting to be processed.

Example:

Queue

1. Message A
2. Message B
3. Message C
Enter fullscreen mode Exit fullscreen mode

Since there is no internet connection, these messages cannot reach the server.

Instead, they wait patiently inside the queue.

Offline Message Queue Lifecycle 

User Sends Message
         |
         v
Saved Locally
         |
         v
Added To Queue
         |
         v
Waiting For Internet
         |
         v
Connection Restored
         |
         v
Sent To Server
         |
         v
Queue Removed
Enter fullscreen mode Exit fullscreen mode

This queue is one of the most important parts of offline messaging systems.

What Happens When Internet Returns?

Eventually Alice reconnects to Wi-Fi.

The app detects connectivity.

A synchronization process begins.

The sync engine:

  1. Reads pending messages
  2. Processes them in order
  3. Sends them to the server
  4. Waits for acknowledgments
  5. Updates message status

This entire process usually happens automatically.

Users often don't even notice it.

Synchronization Flow 

Phone Reconnects
       |
       v
Sync Engine Starts
       |
       v
Read Pending Messages
       |
       v
Send To Server
       |
       v
Receive Confirmation
       |
       v
Update Local Database
Enter fullscreen mode Exit fullscreen mode

The user simply sees status indicators changing.

Understanding Delivery States

Messaging applications use message states to inform users about delivery progress.

These states help answer an important question:

"Has my message reached the other person?"

1. Pending

The message exists only on the sender's device.

Example:

⏳ Sending...
Enter fullscreen mode Exit fullscreen mode

This often happens while offline.

2. Sent

The server has received the message.

✓ Sent
Enter fullscreen mode Exit fullscreen mode

The message successfully left the sender's device.

However, the recipient may not have received it yet.

3. Delivered

The recipient's device has received the message.

✓✓ Delivered
Enter fullscreen mode Exit fullscreen mode

Now the message exists on both devices.

4. Read

The recipient has opened the conversation and viewed the message.

✓✓ Read
Enter fullscreen mode Exit fullscreen mode

This state is usually updated after the recipient's app sends a read acknowledgment.

Message State Transition Diagram 

Pending
   |
   v
Sent
   |
   v
Delivered
   |
   v
Read
Enter fullscreen mode Exit fullscreen mode

Each transition represents successful communication between devices and servers.

Handling Media Uploads While Offline

Text messages are relatively small.

Photos, videos, and documents are different.

A video may be:

  • 20 MB
  • 100 MB
  • 500 MB

Uploading such files requires special handling.

Offline Media Workflow

When a user sends media while offline:

  1. File is stored locally
  2. Upload task is created
  3. Upload enters queue
  4. App waits for connectivity
  5. Upload begins later

Example:

Photo Selected
       |
       v
Saved Locally
       |
       v
Upload Queued
       |
       v
Internet Returns
       |
       v
Upload Starts
Enter fullscreen mode Exit fullscreen mode

Users typically see:

Uploading...
Waiting for connection...
Enter fullscreen mode Exit fullscreen mode

until synchronization occurs.

Conflict Resolution

Offline systems introduce a new challenge.

What if multiple changes happen before synchronization?

Consider this example.

Alice changes a group name while offline.

Bob changes the same group name online.

Now two different versions exist.

Which one should win?

This is called a conflict.

Common Conflict Resolution Strategies

Last Write Wins

The most recent update replaces older versions.

Example:

Alice: Study Group
Bob: Final Project Group
Enter fullscreen mode Exit fullscreen mode

If Bob's change arrived later:

Final Project Group
Enter fullscreen mode Exit fullscreen mode

becomes the final value.

Server Authority

The server decides which update is correct.

Clients accept the server's version.

Merge Strategy

Used in more complex systems.

Both changes are combined when possible.

Messaging apps generally avoid complicated conflicts by keeping operations simple.

Message Ordering

Suppose three messages are sent offline.

Message 1
Message 2
Message 3
Enter fullscreen mode Exit fullscreen mode

When connectivity returns, they should appear in the same order.

Maintaining order is critical because conversations depend on sequence.

Apps typically use:

  • Timestamps
  • Sequence numbers
  • Server ordering mechanisms

to ensure conversations remain readable and consistent.

Eventual Consistency Explained Simply

One important concept behind synchronization systems is eventual consistency.

This means:

Different devices may temporarily show different data, but they will eventually become consistent after synchronization.

Example:

Initially:

Alice Device:
Hello
How are you?

Bob Device:
Hello
Enter fullscreen mode Exit fullscreen mode

After synchronization:

Alice Device:
Hello
How are you?

Bob Device:
Hello
How are you?
Enter fullscreen mode Exit fullscreen mode

Both devices now contain the same information.

The system was temporarily inconsistent but eventually became consistent.

That is why the concept is called eventual consistency.

Why Messages Appear Instantly Even When Offline

Many users assume their message has already reached the server.

In reality, the application is simply showing locally stored data.

The sequence is:

User Sends Message
       |
       v
Stored Locally
       |
       v
Displayed Immediately
       |
       v
Network Sync Happens Later
Enter fullscreen mode Exit fullscreen mode

This approach dramatically improves perceived performance.

Users feel the application is fast because they receive immediate visual feedback.

Reliability vs Real-Time Delivery

There is always a tradeoff.

Prioritizing Real-Time Delivery

Advantages:

  • Faster communication
  • Instant updates

Disadvantages:

  • Fails during connectivity loss
  • Poor user experience

Prioritizing Reliability

Advantages:

  • Works offline
  • Prevents data loss
  • Better user experience

Disadvantages:

  • Synchronization complexity
  • Temporary delays

Modern messaging apps attempt to balance both goals.

How Offline-First Architecture Improves Usability

Offline-first architecture focuses on the user experience rather than the network.

The philosophy is:

Assume the network may fail at any moment.

Benefits include:

  • Faster interface response
  • Better reliability
  • Reduced user frustration
  • Improved battery efficiency
  • Safer data persistence
  • Smooth recovery after disconnections

This is one of the reasons messaging applications feel seamless even in poor network conditions.

Conclusion

When you send a WhatsApp message without internet, the message is not magically transmitted. Instead, the application stores it locally, displays it immediately, and places it inside a queue waiting for connectivity.

Once the internet becomes available, a synchronization engine uploads pending messages, updates delivery states, handles media transfers, and ensures conversations remain consistent across devices.

This approach is known as offline-first architecture and is one of the most important design principles behind modern messaging applications. By combining local storage, message queues, synchronization mechanisms, and eventual consistency, apps can provide a reliable and responsive experience even when networks are unreliable.

The next time you send a message in airplane mode and see it appear instantly, remember that a sophisticated synchronization system is quietly working behind the scenes, waiting for the perfect moment to deliver your message.

Top comments (0)