Design a scalable Content Delivery System

Question

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

Codemia · Accepted Answer

### Functional Requirements
1. **Content Delivery**: The system should deliver static and dynamic content (HTML, CSS, JavaScript, images, videos) to end-users with low latency.
2. **Caching**: Implement caching mechanisms to serve frequently requested content without hitting the origin server.
3. **User Authentication**: Ensure secure access to content based on user roles and permissions.
4. **Analytics**: Capture metrics on user requests, content popularity, and performance for optimization.
5. **Content Management**: Provide an interface for content upload, update, and deletion.

### Non-Functional Requirements
1. **Scalability**: The system should handle millions of requests per second as the user base grows.
2. **Availability**: Aim for 99.99% uptime with automatic failover mechanisms.
3. **Performance**: Latency should be under 100ms for 95% of requests.
4. **Security**: Content should be delivered over HTTPS and protected against common vulnerabilities (e.g., XSS, CSRF).

Assuming Zscaler serves content to approximately 10 million users daily:
- **Requests per second**: 10 million users / 86400 seconds = ~115.7 requests per second.
- Assuming an average of 5 requests per user per day: 10 million users * 5 requests = 50 million total requests per day, or ~578 requests per second.
- To account for peaks, we can assume a peak load of 3-5x that number: 3 * 578 = ~1734 requests per second (peak).
- **Storage Needs**: If we assume an average of 1MB per content item and expect to serve 10,000 items, we need about 10GB of storage, with additional overhead for caching.

### Component Diagram
- **CDN Edge Nodes**: Deploy CDN nodes globally to cache content close to users. Technology: AWS CloudFront or Akamai.
- **Load Balancer**: Distribute incoming requests to edge nodes. Technology: Nginx or AWS Elastic Load Balancing.
- **Cache Layer**: Use Redis or Memcached for caching frequently accessed content at the edge.
- **Origin Server**: A scalable backend server for dynamic content and content management. Technology: Node.js with Express.
- **Database**: A NoSQL database like Amazon DynamoDB for storing content metadata and user information, allowing for flexible querying and scaling.
- **Analytics Service**: Use Apache Kafka for collecting logs and metrics to process asynchronously.

### Schema Design
1. **Content Table** (DynamoDB): 
   - `content_id` (PK): String
   - `content_type`: String (image, video, etc.)
   - `url`: String (location of content)
   - `created_at`: Timestamp
   - `updated_at`: Timestamp

2. **User Table**:
   - `user_id` (PK): String
   - `username`: String
   - `role`: String (admin, user, etc.)
   - `permissions`: List of Strings

3. **Requests Table**: (for analytics)
   - `request_id` (PK): String
   - `content_id`: String (FK)
   - `user_id`: String (FK)
   - `timestamp`: Timestamp
   - `latency`: Number

### Access Patterns
- Frequent reads for content retrieval.
- Write operations for content upload/update and logging analytics.

### Architectural Decisions
1. **Consistency vs. Availability**: Choosing a NoSQL database like DynamoDB allows for eventual consistency, which enhances availability and partition tolerance. This is crucial for a CDN that must serve content quickly to millions of users.
2. **Caching Strategy**: While caching reduces latency, it may serve stale content. Implementing cache invalidation policies based on timestamps can help mitigate this.
3. **Load Balancing**: Using a single load balancer could create a bottleneck; hence, multiple load balancers with health checks should be deployed to ensure high availability.
4. **Security**: Implementing HTTPS and user authentication adds overhead but is necessary for protecting user data and content integrity. This may impact performance slightly but is a critical trade-off for security.

Design a scalable Content Delivery System

Zscaler

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

Submit Your Answer

Zscaler 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