Design Content Delivery Infrastructure for mobile apps

Question

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

Codemia · Accepted Answer

### Functional Requirements
1. **Real-time Content Delivery**: The system should deliver content (text, images, videos) to mobile apps with minimal latency, ideally under 100ms.
2. **User Personalization**: Content should be personalized based on user preferences and interactions.
3. **Scalable API**: Provide a RESTful API for mobile apps to request content.
4. **Versioning**: Support content versioning to allow rollback and updates without downtime.
5. **Analytics**: Track user engagement metrics on delivered content.

### Non-Functional Requirements
1. **Scalability**: The system should handle millions of requests per second (QPS) and scale horizontally.
2. **Availability**: Aim for 99.99% uptime.
3. **Security**: Implement OAuth2 for user authentication and HTTPS for secure data transmission.
4. **Fault Tolerance**: Ensure the system can recover from failures gracefully without data loss.

### Back-of-Envelope Calculations
1. **User Base**: Assume 10 million active users.
2. **Requests per User**: Average 100 requests per user per day.
3. **Total Daily Requests**: 10 million users * 100 requests = 1 billion requests per day.
4. **QPS Calculation**: 1 billion requests/day = 11,574 requests/second.
5. **Storage Needs**: Assuming an average of 100 KB of content per request, total daily storage = 1 billion requests * 100 KB = 100 TB/day. This can be optimized with caching.
6. **Bandwidth**: If 50% of requests are cache hits and average response size is 50 KB, then:
   - Cache bandwidth: 500 million requests * 50 KB = 25 TB/day.
   - Miss bandwidth: 500 million requests * 100 KB = 50 TB/day.
   - Total bandwidth = 75 TB/day.

### Component Diagram
- **Load Balancer**: Distributes incoming requests across multiple application servers to ensure even load.
- **Content Delivery Network (CDN)**: Caches static content globally to reduce latency and bandwidth usage.
- **API Gateway**: Manages API requests, handles authentication, and forwards requests to appropriate microservices.
- **Microservices**: 
  - **Content Service**: Retrieves, stores, and updates content.
  - **User Service**: Manages user profiles and preferences.
  - **Analytics Service**: Collects and processes user interaction data.
- **Database**: A distributed NoSQL database (e.g., Cassandra) for storing user preferences, content metadata, and analytics data.
- **Cache Layer**: Redis or Memcached for caching frequently accessed content to reduce database load.
- **Monitoring and Alerting**: Use Prometheus and Grafana for performance monitoring and alerting on anomalies.

### Schema Design
1. **User Table**: 
   - `user_id`: UUID (Primary Key)
   - `preferences`: JSON (user-specific content preferences)
   - `last_active`: Timestamp

2. **Content Table**: 
   - `content_id`: UUID (Primary Key)
   - `content_type`: String (text, image, video)
   - `data`: Blob (actual content data)
   - `version`: Integer
   - `created_at`: Timestamp

3. **User Content Interaction Table**: 
   - `interaction_id`: UUID (Primary Key)
   - `user_id`: UUID (Foreign Key)
   - `content_id`: UUID (Foreign Key)
   - `interaction_type`: String (view, click, share)
   - `timestamp`: Timestamp

### Access Patterns
- Frequent reads from the User preferences and Content tables for personalized content delivery.
- Write operations primarily to the User Content Interaction table for analytics.

### Architectural Decisions
1. **Consistency vs. Availability**: Opt for eventual consistency for the Content Service to ensure high availability. This allows for faster reads from the cache and reduces latency for users.
2. **Database Choice**: Choosing a NoSQL database (Cassandra) for its horizontal scalability and high write throughput, trading off complex queries and joins.
3. **Cache Strategy**: Implementing aggressive caching (with a TTL) for content to optimize performance, potentially serving stale data in high-read scenarios.
4. **Load Balancing**: Using round-robin load balancing for simplicity but considering a more sophisticated algorithm (like least connections) if user traffic patterns indicate uneven load distribution.
5. **Security Trade-offs**: Balancing security measures (OAuth2, HTTPS) with performance by caching tokens to reduce authentication overhead while ensuring sensitive data is always protected.

Design Content Delivery Infrastructure for mobile apps

OpenAI

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

OpenAI 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