How WhatsApp delivers 100 billion messages every single day

Building a system that connects billions of people and delivers around 100 billion messages per day is a significant undertaking. The solution isn't limited to simply adding more servers; it is a mission-critical System Design challenge that requires extreme concurrency, global distribution, and uncompromising reliability while operating under the constraints of variable mobile networks. Supporting such scale demands an architecture that is both efficient and resilient.

The rapid growth of WhatsApp users helps illustrate why these engineering challenges are so demanding. The illustrationhttps://www.statista.com/statistics/260819/number-of-monthly-active-whatsapp-users/ below shows user growth by year in billions, providing context for the scale and speed of the decisions needed to support such a global system.

Solving problems at this scale requires pragmatic engineering. The choices made by WhatsApp’s team offer a case study in building for resilience and performance. This article examines the architecture that powers WhatsApp, focusing on the following key areas:

• The custom communication protocol is built for mobile efficiency.

• The core backend technology choice that enables massive concurrency.

• The sharding strategy for horizontal scalability and fault isolation.

• Key optimizations for performance and reliability.

• The foundational end-to-end encryption model.

Let’s begin.

WhatsApp’s global messaging challenge#

WhatsApp promises to provide fast and reliable messaging for everyone. Delivering that experience to more than three billion users who send 100 billion messages each day is a major engineering accomplishment. At this scale, WhatsApp must handle millions of concurrent stateful connections and route messages across continents within milliseconds, while staying efficient on mobile devices. Unlike stateless web traffic, each WhatsApp session is a persistent socket that requires a backend designed for concurrency and fault tolerance.

This scale and the need for instant updates required a communication design that could deliver messages reliably and efficiently across devices. The next section examines how WhatsApp achieves real-time messaging while maintaining device synchronization and efficiency.

Protocol and client architecture for real-time communication#

WhatsApp maintains a persistent connectionhttps://engineering.fb.com/2024/03/06/security/whatsapp-messenger-messaging-interoperability-eu/ to deliver messages in real time and update presence instantly. Standard HTTP was too slow for this purpose, so the team built FunXMPPhttps://en.wikipedia.org/wiki/WhatsApp, a lightweight protocol derived from XMPPExtensible messaging and presence protocol (XMPP) is a communication protocol that uses XML to enable real-time exchange of messages and presence information over the internet. and optimized for mobile efficiency. Over time, this protocol evolved to support WhatsApp’s modern multi-device architecture.

FunXMPP also helps keep messages, read receipts, and session states synchronized across devices, such as phones and desktops, ensuring a consistent experience without draining battery or bandwidth.

The following diagram illustrates this persistent connection model.

With the client-server communication optimized, the next challenge is the backend architecture, which must handle tens of millions of these connections simultaneously.

WhatsApp’s backend architecture#

WhatsApp’s backend has been largely implemented in Erlanghttps://www.erlang-factory.com/sfbay2014/rick-reed using the OTP framework, chosen for its ability to handle large-scale concurrency. Running on the BEAM VMA virtual machine that runs Erlang and Elixir code. It is designed for building highly concurrent, distributed, and fault-tolerant systems, managing millions of lightweight processes with minimal overhead., Erlang’s lightweight process model enables the concurrent execution of vast numbers of isolated session/state processes. This architecture is widely credited as a key reason enabling WhatsApp to support extremely high numbers of concurrent connections per server, while maintaining responsiveness under heavy load.

The global system includes multi-region data centers, load balancers, routing servers, and separate stores for key-value data and media. Erlang’s supervision model further strengthens reliability, where supervisor processes automatically restart failed workers. This “let it crash” approach maintains system stability even when individual components fail.

To better understand why Erlang was chosen, the following table compares its features with other common backend technologies for this specific use case.

Handling millions of users on a single server is a key capability, but a global service requires scaling out across many machines. WhatsApp accomplishes this with its partitioning strategy.

Partitioning, sharding, and scalable message flows#

WhatsApp partitions its backend into independently operating clusters (often referred to as islandshttps://www.erlang-factory.com/static/upload/media/1394350183453526efsf2014whatsappscaling.pdf), each handling specific subsets of data or user sessions. Within those clusters, it uses sharding/fragmentation to distribute load and isolate failures. Users or data are routed into a partition and handled within that partition so that problems within one partition are less likely to impact others.

Within each shard, replication ensures high availability. Backup nodes automatically take over if a primary node fails, restoring connections with minimal delay. This design also improves group messaging efficiency, as each shard includes a dedicated group process that handles fan-out through an internal multicast. This approach minimizes redundant work and ensures messages reach all members quickly. Together, sharding and replication provide scalability, resilience, and high uptime.

Here is a simplified view of how this sharding and message flow works.

While the backend is designed for scale, the system must also account for the inherent constraints of mobile devices and networks.

Optimizing performance for mobile and network constraints#

WhatsApp focuses on optimizing performance for mobile devices with limited battery, slow networks, and varying connectivity. Ensuring fast and reliable messaging under these conditions requires careful engineering at every layer, from the network protocol to client-side processing. Key techniques used to achieve this are mentioned below.

• Binary protocol and persistent sockets: Messages are sent using a lightweight binary protocol over long-lived TCPTransmission control protocol (TCP) is a core Internet protocol that provides reliable, ordered, and error-checked delivery of data between applications over a network. connections with efficient reconnection strategies. This reduces both bandwidth consumption and battery drain compared to standard HTTP requests.

• Platform push notifications: When the app is idle, push services like APNSAPNs (Apple Push Notification service) is Apple’s cloud-based service that delivers push notifications from app servers to iOS, iPadOS, macOS, watchOS, and tvOS devices. and FCMFCM (Firebase Cloud Messaging) is Google’s cross-platform service that enables app developers to send push notifications and messages to Android, iOS, and web applications. wake the device only when a new message arrives. The app reconnects briefly to fetch messages, ensuring timely delivery without keeping sockets open constantly.

• Media compression: Images, videos, and voice notes are compressed on the client before uploading. This reduces the amount of data transferred, making media sharing faster and cheaper for users on limited data plans.

• Batched updates: Status updates and read receipts are grouped into single requests rather than sent individually. This reduces network overhead and helps keep the system responsive even under heavy load.

The infographic below summarizes the key optimizations used to enhance performance across mobile environments.

In addition to performance, a critical feature from a user’s perspective is privacy. This is provided through robust encryption.

End-to-end encryption, key management, and secure message delivery#

WhatsApp employs end-to-end encryption by default, utilizing the Signal Protocolhttps://signal.org/docs/ to secure all communications. This means that only the sender and recipient can read the messages, and WhatsApp itself is unable to decrypt them. The encryption ensures that even if a server is compromised, the message content remains private, as it’s unreadable without the recipient’s decryption key.

Messages are encrypted on the sender’s device and transmitted as a scrambled, unreadable blob, which only the recipient can decrypt locally. Each device has its own key pair, with public keys exchanged to establish a secure session. WhatsApp rotates these keys regularly for forward secrecy, meaning that if one key is ever exposed, it cannot be used to decrypt past conversations.

Ensuring strong security is only one part of WhatsApp’s reliability story. The next section looks at how the system maintains consistent delivery, tolerates failures, and monitors health at a global scale.

Delivery reliability, fault tolerance, and live monitoring#

Reliability is central to WhatsApp’s design. Built on Erlang’s “let it crash” model, processes restart automatically when they fail, keeping the system stable without complex error handling. Automatic clustering and failover ensure that if a node becomes unresponsive, traffic is quickly redirected to healthy replicas. Continuous monitoring of system health and error rates helps detect and resolve issues early.

Intelligent load balancing further protects availability by distributing traffic evenly across servers. When load increases, the system applies back-pressure or temporarily sheds noncritical traffic, ensuring message delivery remains consistent even during global spikes.

The following table breaks down some of the key mechanisms that contribute to WhatsApp’s high uptime:

These reliability and monitoring strategies form the foundation for scaling WhatsApp to billions of users. The next section explores the broader engineering challenges involved in supporting such a massive, global system.

Engineering challenges in designing for scale#

WhatsApp’s architecture reflects a pragmatic engineering culture that values simplicity, reliability, and efficiency over unnecessary complexity. Each component is built to scale smoothly so that performance remains consistent as the platform grows to support billions of users. Yet serving more than three billion people presents ongoing technical challenges and trade-offs that test the limits of large-scale System Design.

Mobile limitations such as restricted battery life, memory, and processing power require careful optimization of every feature to keep the experience fast and seamless. At the same time, the rapid growth in media sharing calls for storage systems that are both scalable and cost-efficient. End-to-end encryption, which protects user privacy, adds further difficulty to data synchronization and backup, as message content cannot be accessed by servers.

The infographic below summarizes these engineering issues, highlighting the key trade-offs in performance, privacy, and scalability.

Understanding these challenges helps explain the design choices that shaped WhatsApp’s architecture. The next section highlights key System Design lessons that engineers can apply when building reliable and resilient large-scale systems.

Key System Design lessons from WhatsApp’s architecture#

WhatsApp’s evolution offers clear lessons for anyone building large-scale systems. Its architecture shows how focused, thoughtful choices and simple design patterns can drive global scale while preserving reliability. The lessons below highlight the core principles behind that success.

• Choose technology that fits the problem: WhatsApp picked Erlang/OTP for its lightweight concurrency and fault-tolerant runtime, perfect for handling millions of live connections.

• Partition for performance and resilience: Sharding and island-based scaling isolate user groups, reducing failure impact and enabling near-linear growth.

• Optimize across the stack: The custom FunXMPP protocol minimizes message size and handshake overhead, improving speed and efficiency on mobile networks.

• Treat security as a core feature: End-to-end encryption was part of the design from day one, proving that privacy and performance can coexist.

• Embrace simplicity as a scaling strategy: By avoiding over-engineering and keeping systems predictable, WhatsApp scales steadily without costly rework.

Applying these lessons reinforces a mindset where scalability comes from purposeful, resilient components that stay aligned with the system’s core mission.

Conclusion#

WhatsApp’s journey shows that scale is a result of clear engineering intent, not luck. Its reliability comes from deliberate choices in selecting the right concurrency model, partitioning effectively, and optimizing for constrained mobile environments. Each decision reflects a deep understanding of the system’s real-world context and constraints.

For engineers and technical leads seeking to go further, our courses explore how to design resilient distributed systems, build efficient messaging protocols, and plan for global-scale reliability.

The next generation of scalable systems will be built by those who combine simplicity with discipline. Start shaping that mindset today.