Design a Chat Service

Question

Design a high-throughput chat 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 instantly.
2. **Group Chats**: Support for one-on-one and group conversations with up to 1000 participants.
3. **Message History**: Users should be able to view message history and search through it.
4. **Typing Indicators**: Show when users are typing.
5. **Read Receipts**: Indicate whether messages have been read.
6. **Media Sharing**: Allow users to share images, videos, and files.
7. **Notifications**: Push notifications for new messages.

### Non-Functional Requirements:
1. **Scalability**: The system should handle millions of concurrent users and messages.
2. **Availability**: Aim for 99.99% uptime with minimal delays.
3. **Latency**: Messages should be delivered with less than 200ms latency.
4. **Consistency**: Use eventual consistency for message delivery to balance performance and availability.
5. **Security**: Ensure end-to-end encryption for messages.

### Estimation Calculations:
1. **User Base**: Assume 100 million active users with 10 messages per user per day.
2. **QPS Calculation**: 100 million users * 10 messages/day / 86400 seconds ≈ 1157 QPS.
3. **Storage Estimation**: Assuming average message size is 1KB:
   - Daily storage = 100 million messages * 1KB = ~95.37 GB/day.
4. **Bandwidth Requirement**: With 1157 QPS and each message being 1KB, the bandwidth required would be approximately 1.16 MB/s.

### Component Diagram:
- **Client Applications**: Mobile and web clients for sending and receiving messages.
- **Load Balancer**: Distributes incoming requests to multiple chat servers.
- **Chat Servers**: Handle message processing and manage user sessions (using Node.js).
- **Message Queue**: Kafka for asynchronous message processing to ensure high throughput.
- **Database**: NoSQL database like Cassandra for storing messages and metadata.
- **Cache**: Redis for caching frequently accessed data (e.g., user sessions, message history).
- **Notification Service**: For sending push notifications to users.
- **Monitoring & Logging**: Use Prometheus for monitoring, and ELK stack for logging.

### Schema Design:
1. **Users Table**: Stores user information (user_id, username, last_active).
2. **Messages Table**: Stores messages (message_id, user_id, group_id, content, timestamp).
3. **Groups Table**: Stores group chat details (group_id, group_name, member_ids).
4. **Read Receipts Table**: (message_id, user_id, read_timestamp).
5. **Indexes**: Create indexes on user_id and group_id in the Messages table for efficient querying.

### Architectural Decisions:
1. **Consistency vs. Availability**: Opted for eventual consistency to achieve higher availability and performance, especially for message delivery in a chat context.
2. **Database Choice**: Chose Cassandra for its horizontal scalability and ability to handle large amounts of write-heavy workloads typical in chat applications.
3. **Message Queue**: Using Kafka allows for decoupling the message processing, thus improving system resilience but adds complexity in message delivery guarantees.
4. **Caching**: Redis is chosen for caching frequently accessed data, which reduces load on the database but introduces potential cache invalidation challenges.
5. **Monitoring and Alerting**: Prioritize real-time monitoring to quickly identify and address issues, accepting the trade-off of increased operational complexity.

Design a Chat Service

Meta

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

Estimation Calculations:

Submit Your Answer

Meta 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