Design a Messaging for Twitter/X

Question

Design a low-latency messaging system that handles millions of requests. Discuss trade-offs in consistency, availability, and performance.

Codemia · Accepted Answer

### Functional Requirements
1. **Real-time Messaging**: Users should be able to send and receive messages in real-time with low latency.
2. **Group Messaging**: Support for group chats where multiple users can participate in a conversation.
3. **Message History**: Users should be able to view past messages in a thread.
4. **Typing Indicators**: Show when users are typing.
5. **Notifications**: Users should receive notifications for new messages.

### Non-Functional Requirements
1. **Low Latency**: Messages should be delivered within 100ms under normal conditions.
2. **Scalability**: The system should handle spikes in traffic, accommodating up to 100 million active users.
3. **Availability**: The messaging service should have 99.99% uptime.
4. **Data Consistency**: Messages should be delivered in the order they were sent, ensuring consistent view across clients.
5. **Fault Tolerance**: The system should continue to operate during partial failures.

### Back-of-Envelope Calculations
1. **Active Users**: Assuming 100 million active users on Twitter/X.
2. **Messages per User**: If each user sends an average of 10 messages per day, this results in 1 billion messages per day.
3. **Messages per Second**: Dividing by the number of seconds in a day (86,400), we get approximately 11,574 messages per second (QPS).
4. **Storage Requirements**: Assuming each message is 1 KB, total storage would be around 1 TB for a single day of messages. For a month's worth of messages, this would be about 30 TB. Considering redundancy and backups, we can estimate about 100 TB of storage for a month.

### Component Diagram
1. **Client Applications**: Mobile and web clients that communicate with the backend.
2. **Load Balancers**: Distribute incoming requests across multiple application servers.
3. **Messaging Service**: Handles the core logic for sending, receiving, and storing messages. Built with Node.js for high concurrency.
4. **Database**: Use PostgreSQL for transactional data storage, ensuring ACID properties for message delivery.
5. **Caching Layer**: Redis for caching frequently accessed message data and user sessions to reduce database load.
6. **Notification Service**: Utilizes WebSockets for real-time push notifications to clients.
7. **Analytics Service**: Collects metrics and logs for monitoring and alerting.

### Schema Design
1. **Users Table**: `user_id (PK), username, email, password_hash, created_at`
2. **Messages Table**: `message_id (PK), sender_id (FK), receiver_id (FK, nullable for group messages), group_id (nullable), content, timestamp`
3. **Groups Table**: `group_id (PK), group_name, created_at`
4. **Group_Members Table**: `group_id (FK), user_id (FK)` to manage group memberships.

### Access Patterns
- Retrieval of messages for a user will involve querying the `Messages` table using `receiver_id` or `group_id`. Caching will be utilized for frequently accessed message threads.

### Architectural Decisions
1. **Consistency vs. Availability**: Opted for eventual consistency in group messaging to allow for faster responses and better availability, but ensured that individual message delivery remains strongly consistent.
2. **Caching vs. Real-time Data**: Used Redis for caching but decided that critical data (like unread message counts) will be fetched from the primary database to ensure accuracy at the expense of some performance.
3. **Database Choice**: Chose PostgreSQL for its support for complex queries and transactional integrity, recognizing that it might introduce some latency compared to NoSQL options but prioritizing data consistency.
4. **Scaling Strategy**: Implemented sharding based on user ID to distribute load effectively while maintaining low latency for message delivery.

Design a Messaging for Twitter/X

Twitter/X

What the Interviewer Expects

Key Topics to Cover

How to Approach This

Possible Follow-up Questions

Practice a Similar Problem on Codemia

Sample Answer

Requirements

Functional Requirements

Capacity Estimation

Back-of-Envelope Calculations

Submit Your Answer

Twitter/X Software Engineer Interview Guide

Related Questions

Design a high-throughput Inventory Management System

Design a low-latency Rate Limiting System

Design a fault-tolerant Payment System

Design a fault-tolerant Messaging System

Design Walmart Product Search