WhatsApp System Design

5. Message Communication [5 mins]

It is crucial to understand the communication between client and server when implementing a chat application. This understanding forms the foundation for establishing real-time, bi-directional data exchange, enabling seamless interaction between users through instant messaging. Establishing a connection between clients and servers involves several methods:

1. TCP Handshake

TCP handshake is a process where a client and server establish a connection by exchanging synchronization (SYN) and acknowledgment (ACK) packets to ensure reliable data transmission.

1. SYN (Synchronize): Client sends a SYN segment to the server to initiate a connection request.
2. SYN-ACK (Synchronize-Acknowledgment): Server responds with SYN-ACK to acknowledge the request and signal readiness to establish a connection.
3. ACK (Acknowledgment): Client sends an ACK segment to acknowledge the server's response, completing the TCP handshake and establishing a reliable connection.

2. SSL/TLS Handshake

Once the TCP connection is established, the SSL/TLS handshake begins. The SSL/TLS handshake is a process that allows a client and server to establish a secure encrypted connection. Here’s a simplified explanation of the handshake flow:

1. ClientHello: The client initiates the handshake by sending its supported SSL/TLS version, cipher suites, and other parameters.
2. ServerHello: The server responds with its chosen SSL/TLS version, cipher suite, and other parameters.
3. Certificate (Optional): The server sends its digital certificate for authentication.
4. ServerKeyExchange (Optional): The server sends necessary data for key exchange (e.g., parameters for Diffie-Hellman).
5. CertificateRequest (Optional): The server requests the client's certificate for mutual authentication.
6. ServerHelloDone: The server signals that it has completed its part of the handshake.
7. ClientKeyExchange: The client sends data for key exchange.
8. ChangeCipherSpec: Both client and server signal readiness to begin encrypted communication.
9. Finished: Both parties verify the integrity of the handshake and establish secure communication.

3. HTTPS Communication

After the TCP handshake and SSL/TLS handshake have successfully established a connection, HTTPS communication involves the secure exchange of HTTP messages between the client and the server. Here’s a breakdown of what happens:

1. HTTPS Request: The client sends an encrypted HTTP request to the server, specifying what resource it wants.
2. Server Processing: The server decrypts the request, processes it (e.g., fetches a webpage, handles form data), and prepares a response.
3. HTTPS Response: The server sends an encrypted HTTP response back to the client, containing the requested resource or indicating an error.
4. Secure Transmission: All communication (requests and responses) is encrypted, ensuring data confidentiality and integrity.
5. Connection Maintenance: The TCP and SSL/TLS connections remain open for efficient subsequent requests, reducing overhead.

Message Communication Methods

Now that we understand how connections are established between clients and servers, let's delve into the communication methods used for data exchange:

1. HTTP(S) Requests

Fundamental for sending and receiving messages, initiated by clients like mobile apps or web browsers using HTTP POST requests to transmit message content to servers.

2. Polling

Polling means that clients ask the server every now and then if there are new messages or updates. When the server gets a request, it checks if there's something new to send back. This method works well when getting updates right away isn't crucial, or when it's hard to keep a continuous connection like with Websockets.

3. Long Polling

Long polling is like asking the server to keep the line open until it has something new to say or until a timeout happens. This helps reduce the delay in getting updates compared to regular checking. It's good for apps that need updates quickly but can't stay connected all the time, like when messages come in occasionally.

4. Websockets

Websockets keep a constant connection open between clients and servers, allowing them to send messages back and forth without delay. This is different from methods that repeatedly check for updates. Websockets are crucial for apps like chat platforms (e.g., WhatsApp) where getting messages instantly, seeing when someone is typing, and knowing when a message is read are very important. They make sure updates happen right away, reduce waiting times, and handle many connections smoothly on different devices and platforms.

HTTPS to WebSocket Upgrade Process

1. Establish HTTPS Connection: Client initiates a standard HTTPS connection to the server.
2. Upgrade Request (WebSocket): Client sends an HTTP request to upgrade the connection to WebSocket.
3. Upgrade Response (WebSocket): Server responds to the upgrade request confirming the switch to WebSocket protocol.
4. Bi-directional WebSocket Communication Established: Both client and server can now communicate bi-directionally in real-time using WebSocket.

6. Deep Dive [10-12 mins]

Let's carefully plan out WhatsApp's system architecture to ensure we build features that meet all our needs. Going step by step helps us avoid mistakes and ensures the system is reliable and can grow smoothly over time.

1. Users

Users are the end-users of the chat application, using smartphones to send messages, share media, and get notifications. Their active participation and interaction are crucial to the app's success.

2. Load Balancer

Load balancer distributes incoming requests from users across multiple instances of the API Gateway for better performance and availability.

3. API Gateway

API Gateway serves as the single entry point for all client requests to appropriate backend services like User Service, Message Service, and Media Service. It manages authentication, authorization, and traffic flow, centralizing request handling to simplify service interactions and enhance security across the system.

Key functionalities include:

• /POST Message: Directs the request to send a new message.
• /GET Messages: Routes the request to retrieve messages for the user.
• /POST Group: Handles the action of creating a new group chat.
• /POST Online Status: Handles updating the user's online status.
• /POST Media: Manages the request to send media within a message.

The API Gateway abstracts the complexity of the backend services from the clients and provides a unified interface.

4. User Service

The User Service handles user-related operations, managing user data including IDs, names, and status information such as last seen. It handles user authentication, profile management, and configuration settings, ensuring seamless user experiences and maintaining user data integrity across the platform.

5. User Database

User Database stores comprehensive user profiles and associated data necessary for user management within the chat application. It provides a reliable source for user-related information, supporting authentication processes, personalized interactions, and user-specific services.

6. Message Service

Message Service manages message delivery in the app, ensuring messages reach recipients promptly based on conversations or user IDs. It supports real-time communication, updates conversation details, and confirms message delivery, enhancing user engagement and maintaining message integrity.

7. Conversation Database

Conversation Database stores conversation IDs, names, and participants (users and groups), serving as a core data repository for the Conversation Service. It facilitates efficient retrieval of conversation details and management of group memberships and communication dynamics in the chat application.

8. User Conversation Database

User Conversation Database maintains associations between users and their respective conversations or group chats within the chat application. It stores records linking user IDs with conversation IDs, facilitating efficient retrieval of conversation details, management of group memberships, and targeted communication among users participating in specific conversations. This database supports personalized user experiences and streamlined communication dynamics within group settings.

9. Media Service

Responsible for managing media-related operations, the Media Service processes uploads, stores media files in the Object Store, and updates the Message Database with URLs linking to stored media. It ensures efficient management and retrieval of media content, supporting multimedia messaging capabilities within the chat application.

10. Media Storage

Serving as a dedicated repository, the Object Store securely stores media files uploaded by users within the chat application. It efficiently manages large volumes of media data and integrates with the Media Service for seamless upload, storage, and retrieval of media files associated with messages exchanged between users.

11. Message Database

Message Database stores message content, metadata, and media URLs, serving as a centralized repository for managing message details within the messaging application.

12. Group Database

Group Database stores metadata essential for managing groups within the chat application, including group names, creators, and settings. It also maintains associations between group IDs and conversation IDs, enabling efficient retrieval of group-specific conversations and facilitating seamless communication and membership management among group participants.

13. Notification Service

The Notification Service sends push notifications to users' devices based on events such as new messages or updates in conversation status, enhancing user engagement by keeping users informed in real-time.

High level architecture of WhatsApp

---

7. Futher Optimizations [2 - 5 mins]

1. Caching

Caching is crucial for a messaging service like WhatsApp. It enhances the service's performance by storing frequently accessed data, such as user profiles, chat histories, and media thumbnails, in memory. This allows for quick retrieval, significantly reducing the load on the primary database servers. As a result, WhatsApp can handle a large number of simultaneous users efficiently.

Moreover, caching ensures the service remains reliable even during peak usage times or temporary network issues. By keeping essential data readily available, caching helps maintain a smooth and uninterrupted user experience. Overall, caching makes WhatsApp faster, more efficient, and more dependable for millions of users worldwide.

Cache systems like Redis, Memcached, AWS ElastiCache, Microsoft Azure Cache for Redis, and Google Cloud Memorystore store data using key-value pairs efficiently. They offer a range of features and integrations, addressing diverse caching requirements from high-performance in-memory caching to managed cloud services that ensure scalability and reliability.

Data Stored in Cache

  {
      "key": "string",
      "value": "string"
  }

I. User Cache

User cache stores frequently accessed user details such as username, profile picture, status, and last seen timestamp to minimize database queries. It also includes contact lists and user-specific settings.

Example User Cache

  [
      {
          "key": "e193c87b2fd6a181c04cc8a4b97238ce",
          "value": {
              "user_id": "e193c87b2fd6a181c04cc8a4b97238ce",
              "phone_number": "+1234567890",
              "name": "Test User",
              "profile_picture_url": "https://example.com/profiles/alice.jpg",
              "created_at": "2012-05-02 11:59:25"
          }
      },
      {
           ...
      },
  ]

II. Conversation Cache

Conversation cache holds metadata about conversations, including participants, the last message ID, and the last message timestamp. It also tracks the unread message count for each conversation.

Example Conversation Cache

  [
      {
          "key": "b30f706b8764cdb3ef733fae29bfef81",
          "value": {
              "conversation_id": b30f706b8764cdb3ef733fae29bfef81",
              "conversation_name": "Design Discussion",
              "participants": [
                  {
                      "user_id": "1234",
                      "is_admin": true
                  },
                  {
                      ...
                  },
              ],
              "created_at": "2017-02-04 08:33:46"
          }
      },
      {
           ...
      },
  ]

III. User Conversation Cache

User conversation cache lists all conversations a user is part of, including pinned and archived conversations for quick access. It helps in rapidly loading a user's conversation history.

Example User Conversation Cache

  [
      {
          "key": "7a39f348a90ca9973a9af26fdb5b0387",
          "value": {
              "conversation_id": "b30f706b8764cdb3ef733fae29bfef81",
              "user_id": "e193c87b2fd6a181c04cc8a4b97238ce",
          }
      },
      {
           ...
      },
  ]

IV. Message Cache

Message cache stores individual messages with details like message ID, conversation ID, sender ID, timestamp, content, and status. This enables quick retrieval and display of messages within conversations.

Example Message Cache

  [
      {
          "key": "651c6a4488742276767202af02c9a3a4",
          "value": {
              "sender_id": "1234",
              "recipient_id": "3456",
              "content": "Hello There!",
              "timestamp": "2024-06-28T09:15:00Z",
              "status": "read",
          }
      },
      {
           ...
      },
  ]

V. Group Cache

Group Cache stores essential metadata related to groups within the chat application, such as group names, creators, and settings. It optimizes group-related operations by caching frequently accessed group data, enhancing performance in group management tasks and facilitating quick retrieval of group details.

Example Group Cache

  [
      {
          "key": "group:9876",
          "value": {
              "group_name": "We Rock Designs",
              "created_by": "1234",
              "members": [
                  {
                      "user_id": "1234",
                      "is_admin": true
                  },
                  {
                      ...
                  },
              ],
              "group_profile_picture_url": "string",
              "created_at": "2023-12-20 13:34:12",
              "status": "active"
          }
      },
      {
           ...
      },
  ]

2. CDN (Content Delivery Network)

The CDN optimizes media content distribution by storing and delivering images, videos, and other media files from geographically distributed servers closer to users. This geographical proximity reduces latency and accelerates content delivery, enhancing user experience by ensuring fast and reliable access to multimedia content across devices.

I. Push CDN
Push CDNs proactively distribute pre-cached content from origin servers to edge servers globally, optimizing availability and reducing latency for static content like images and videos.

II. Pull CDN
Pull CDNs fetch content from origin servers on demand, checking edge server caches first and dynamically caching new or updated content, ideal for dynamic websites needing real-time updates and flexibility in content delivery.

High level architecture of WhatsApp after Optimizations

---

8. Data Flow [5-8 mins]

It's important to describe how data moves through the entire system, ensuring everyone understands clearly. According to our estimates and discussions, the system's non-functional requirements focus on handling high numbers of users efficiently, implementing strong data security, and expanding the infrastructure quickly as needed.

Sending a Message:

• User sends a message through their device over the internet.
• Request is routed through the Load Balancer and API Gateway.
• Message Service processes the message and updates the Conversation Database with new message details and stores message content and metadata in the Message Database.
• Notification Service is triggered to notify message recipients.

Receiving Messages:

• User requests messages using a GET /message endpoint.
• Message Service fetches relevant data from the Message Database and the User Conversation Database retrieves message content, metadata, and media URLs, fetches user details for group messages and updates the Conversation Database with any new message details fetched.

Media Handling:

• User selects an image to send through their device.
• Image upload request is routed through the API Gateway to the Media Service.
• Media Service processes the media and stores it in the Media Storage (Object Store) and updates the Message Database with the media URL.
• CDN efficiently delivers the image URL to other users for viewing.

Last Seen Update:

• User updates their last seen status, indicating when they were last active.
• Request is sent through the API Gateway to the User Service.
• User Service updates the User Database with the new last seen timestamp (/POST updateLastSeen).

Don't forget to explain the end to end flow of your design!

This architecture is designed to be scalable, resilient, and efficient, ensuring that the platform can handle a high volume of user interactions and data processing with minimal latency and high availability.