Design a large-scale Content Delivery Platform

Question

Design a high-throughput content delivery system that handles millions of requests. Discuss trade-offs in consistency, availability, and performance.

Codemia · Accepted Answer

### Functional Requirements:
1. **High Throughput**: The system should handle at least 1 million requests per second (QPS) for content retrieval.
2. **Content Management**: Ability to upload, delete, and update content by users.
3. **Geo-Distribution**: Serve content from edge locations closest to users to reduce latency.
4. **User Authentication**: Ensure secure access to content based on user permissions.
5. **Caching**: Efficiently cache frequently accessed content to improve retrieval times.

### Non-Functional Requirements:
1. **Availability**: The system should have 99.99% uptime.
2. **Scalability**: The system should scale horizontally to accommodate growing user demand.
3. **Latency**: Content should be delivered with a maximum response time of 100ms.
4. **Consistency**: Ensure eventual consistency for content updates while maintaining high availability.

### Back-of-Envelope Calculations:
1. **User Base**: Assuming 10 million active users.
2. **Average Requests per User**: Each user makes an average of 100 requests per day.
3. **Total Requests per Day**: 10 million users * 100 requests = 1 billion requests/day.
4. **Requests per Second (QPS)**: 1 billion requests/day / 86400 seconds/day = ~11,574 QPS.
5. **Peak Load**: Assuming peak traffic is 10x average, we need to handle 115,740 QPS.
6. **Storage Requirements**: If each piece of content is 2MB and we expect to store 10 million pieces of content, total storage = 20 TB.

### Component Diagram:
- **API Gateway**: Routes incoming requests to appropriate services.
- **Content Delivery Network (CDN)**: Uses Google Cloud CDN for edge caching.
- **Load Balancers**: Distribute traffic among multiple application servers.
- **Application Servers**: Handle business logic for content management and authentication (e.g., using Google Kubernetes Engine).
- **Database**: Use Google Cloud Spanner for horizontal scalability and strong consistency guarantees.
- **Caching Layer**: Redis for session management and frequently accessed content caching.
- **Monitoring and Logging**: Use Google Cloud Monitoring and Stackdriver for alerting and analysis.

### Schema Design:
1. **Content Table**:
   - `content_id` (STRING, Primary Key)
   - `user_id` (STRING, Foreign Key)
   - `content_data` (BYTES)
   - `created_at` (TIMESTAMP)
   - `updated_at` (TIMESTAMP)
   - `visibility` (ENUM: PUBLIC, PRIVATE)

2. **User Table**:
   - `user_id` (STRING, Primary Key)
   - `username` (STRING, Unique)
   - `password_hash` (STRING)
   - `email` (STRING)
   - `created_at` (TIMESTAMP)

3. **Access Patterns**:
   - Frequent read operations for content retrieval.
   - Updates primarily for content management. Using Spanner allows for strong consistency during updates.

### Architectural Decisions:
1. **Consistency vs Availability**: Opting for eventual consistency in caching to ensure high availability while using Spanner for strong consistency on the primary data store.
2. **Database Choice**: Google Cloud Spanner was chosen for its scalability and strong consistency, but it introduces complexity in data modeling and potential latency for write-heavy scenarios.
3. **Caching Strategy**: Utilizing Redis for caching improves performance but adds complexity in cache invalidation strategies, especially during updates.
4. **Sharding Strategy**: Implement sharding based on `user_id` to evenly distribute load across multiple database instances, which aids in horizontal scaling but requires careful handling of cross-shard queries.

Design a large-scale Content Delivery Platform

Google

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 Gathering

Functional Requirements:

Capacity Estimation

Back-of-Envelope Calculations:

Submit Your Answer

Google 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