Architect a event-driven Video Streaming Engine

Question

Design a event-driven video streaming system that handles millions of requests. Discuss trade-offs in consistency, availability, and performance.

Codemia · Accepted Answer

### Functional Requirements
1. **User Authentication**: Users must be able to register and log in to access the video streaming service.
2. **Video Uploading**: Users can upload videos to the platform, which are then processed for streaming.
3. **Video Streaming**: Users can watch videos in real-time with minimal latency.
4. **Event Handling**: The system must handle events like likes, shares, and comments in real-time.
5. **Live Streaming**: Support for live video broadcasting with low latency.

### Non-Functional Requirements
1. **Scalability**: The system should scale horizontally to handle millions of concurrent users.
2. **Availability**: The system must have an uptime of 99.99% to ensure users can stream videos at all times.
3. **Latency**: Video streaming should have a latency of less than 2 seconds.
4. **Data Durability**: Uploaded videos must be stored reliably, ensuring no data loss.
5. **Monitoring and Alerting**: Real-time monitoring of system metrics with alerting for anomalies.

### Back-of-Envelope Calculations
1. **User Base**: Assume 10 million active users.
2. **Requests Per Second (QPS)**: On average, each user generates 1 request per minute for video streaming. Therefore:
   - Total QPS = 10 million users / 60 seconds = ~166,667 requests/second.
3. **Storage Requirements**: Assume average video size is 500MB and each user uploads 1 video per week:
   - Total storage = 10 million users * 1 video/week * 500MB = 5,000 TB per week.
4. **Bandwidth**: If each user streams at 2Mbps:
   - Total bandwidth = 10 million users * 2Mbps = 20,000 Gbps or ~2.5 TB/minute.
5. **Scaling Factor**: Considering peak usage, we can scale by a factor of 3, estimating around 500,000 QPS during peak times.

### Component Diagram
1. **User Service**: Handles user authentication and profile management using **Spring Boot**.
2. **Video Service**: Manages video uploads and processing, built with **Node.js** for non-blocking I/O.
3. **Streaming Service**: Utilizes **Nginx** or **Apache Kafka** for handling video streaming requests and live broadcasting.
4. **Event Processing**: **Apache Kafka** for event handling (likes, comments) to ensure a decoupled architecture.
5. **Storage Layer**: **Amazon S3** for video storage and **DynamoDB** for metadata storage.
6. **Cache Layer**: **Redis** for caching frequently accessed metadata and **CDN (like CloudFront)** for video delivery to reduce latency.
7. **Monitoring**: **Prometheus** and **Grafana** for monitoring system health and performance metrics.

### Schema Design
1. **User Table**: 
   - `user_id (PK)`, `username`, `password_hash`, `email`, `created_at`
2. **Video Table**: 
   - `video_id (PK)`, `user_id (FK)`, `title`, `description`, `url`, `upload_time`, `views`
3. **Comments Table**: 
   - `comment_id (PK)`, `video_id (FK)`, `user_id (FK)`, `comment_text`, `created_at`
4. **Likes Table**: 
   - `like_id (PK)`, `video_id (FK)`, `user_id (FK)`, `created_at`
5. **Event Table**: 
   - `event_id (PK)`, `type`, `target_id`, `user_id (FK)`, `created_at`

### Access Patterns
- Frequent reads for video metadata and user profiles, and occasional writes for uploads, likes, and comments.

### Architectural Decisions
1. **Consistency vs. Availability**: Opting for eventual consistency for likes and comments to enhance availability during high load situations.
2. **Data Partitioning**: Using sharding based on user IDs to distribute the load across multiple instances and improve performance.
3. **Caching Strategy**: Utilizing Redis for caching to reduce database load, acknowledging potential stale data issues but balancing it with the need for speed.
4. **Replication**: Choosing eventual consistency for the database to ensure higher availability and scalability, but accepting potential read inconsistencies during heavy traffic.
5. **Failure Handling**: Implementing retries and circuit breakers in the streaming service to handle temporary network issues, while ensuring that user experience remains optimal.

Architect a event-driven Video Streaming Engine

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

Back-of-Envelope Calculations

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