How WhatsApp Shows “Typing…” in Real Time

If you’ve ever noticed how WhatsApp shows “Typing…” the moment the other person starts typing, even on slow or flaky networks, you’ve already seen a well-engineered real-time presence system at work.

What looks like a tiny UI feature is backed by:

• Always-on socket connections
• Event-driven messaging
• Ephemeral, non-persistent data flow
• Infrastructure built to handle millions of concurrent users

This article breaks down exactly how it works, from client to server, without hand-wavy explanations.

The Core Idea#

“Typing…” is not a stored state. It is a real-time signal, streamed over persistent connections, delivered instantly and discarded immediately.

No polling. No database writes. No history.

1. Persistent Connections, Not HTTP Requests#

When you open WhatsApp, the app opens a long-lived TCP socket connection to WhatsApp’s backend servers.

Instead of traditional HTTP APIs, WhatsApp relies on MQTT (Message Queuing Telemetry Transport).

Why MQTT?

• Designed for low bandwidth and unstable networks
• Minimal packet overhead
• Supports bidirectional, server-push communication
• Ideal for mobile devices that frequently switch networks

Once this connection is established, it stays alive for the whole session. The server can push events to the client instantly, without waiting for a request.

2. Typing Is an Event, Not a Status#

When a user starts typing, WhatsApp does not:

• Update a database row
• Flip a “typing = true” flag
• Store anything durable

Instead, the client emits a lightweight event over the existing socket.

Conceptually, it looks like this:

EVENT: USER_TYPING
chat_id: X
sender_id: Y

This event goes to the backend immediately.

The server then:

1. Identifies the active participants in the chat
2. Checks which recipients have live socket connections
3. Pushes the event to those sockets
4. Discards the event after delivery

The receiver’s UI listens for this event and renders “Typing…” in real time.

3. Why Typing Indicators Are Ephemeral#

Typing events are intentionally non-persistent.

They:

• Are never written to databases
• Exist only in memory
• Expire immediately after transmission

If the sender:

• Stops typing
• Loses connectivity
• Closes or backgrounds the app

The event stream stops. The receiver gets nothing further, so the UI clears the indicator.

This design prevents:

• Stale presence signals
• Unnecessary storage load
• Complex cleanup logic

Ephemerality is a feature, not a limitation.

4. No Polling, No Refresh Cycles#

A key reason WhatsApp feels instant is that it never polls for typing updates.

Polling would mean:

• Repeated API calls
• Higher latency
• Massive backend load at scale

Instead:

• Every client stays connected
• The server pushes events as they happen
• The UI reacts only to incoming messages

This event-driven model is both faster and cheaper at global scale.

5. Scaling to Millions of Concurrent Typers#

At any moment, millions of users across India, Brazil, Europe and beyond are typing at the same time.

WhatsApp handles this with:

• Highly concurrent Erlang-based backend systems
• Horizontal sharding of connection-handling nodes
• Stateless routing for ephemeral events
• Regional load balancers to minimize latency

Each backend node can hold millions of open socket connections efficiently.

Because typing events are:

• Extremely small
• Short-lived
• Never stored

They scale linearly without becoming a bottleneck.

6. Why This Architecture Works So Well#

The strength of this system lies in what it doesn’t do.

• No database writes for presence
• No retries for lost typing events
• No synchronization guarantees

Typing indicators are best-effort signals, not critical data. If one event is missed, the system simply moves on.

This keeps latency low and infrastructure simple.

The Key Takeaway#

“Typing…” is not magic. It is not a complex backend workflow.

It is:

• A tiny real-time event
• Sent over an always-on socket
• Delivered instantly
• Discarded immediately

This is a textbook example of event-driven system design done right.

Final Thought#

Small UI features often reveal the best system design lessons.

WhatsApp’s typing indicator shows how:

• Ephemeral data should stay ephemeral
• Persistent connections beat polling at scale
• Real-time systems don’t need heavy persistence

If you’re designing chat apps, collaboration tools, multiplayer games or live dashboards, this pattern is worth studying closely.