Video recommendation system in HLD - System Design Exercise

Design: Video Recommendation System

Design covers user interaction, recommendation engine, data storage, and API delivery. Does not cover video storage, streaming infrastructure, or content creation.

Functional Requirements

FR1: Provide personalized video recommendations to users based on their watch history and preferences

FR2: Support at least 10 million active users with concurrent access

FR3: Update recommendations in near real-time as users interact with videos

FR4: Allow users to rate videos and provide feedback to improve recommendations

FR5: Support trending and popular video recommendations globally and regionally

FR6: Ensure recommendations are relevant and diverse to keep users engaged

Non-Functional Requirements

NFR1: System should handle 10 million active users with 1 million concurrent requests

NFR2: API response latency for recommendations should be under 200ms (p99)

NFR3: System availability should be at least 99.9% uptime

NFR4: Data freshness for recommendations should be within 5 minutes

NFR5: Scalable to handle growth in users and video content

Think Before You Design

Questions to Ask

❓ Question 1

❓ Question 2

❓ Question 3

❓ Question 4

❓ Question 5

❓ Question 6

Key Components

User profile service

Video metadata store

Watch history database

Recommendation engine

Real-time event processing pipeline

API gateway for serving recommendations

Cache layer for fast response

Analytics and feedback processing

Design Patterns

Batch and real-time hybrid processing

Microservices architecture

Event-driven architecture

Caching strategies (LRU, TTL)

Data partitioning and sharding

Load balancing and rate limiting

Reference Architecture

                    +---------------------+
                    |   User Devices      |
                    +----------+----------+
                               |
                               v
                    +----------+----------+
                    |     API Gateway     |
                    +----------+----------+
                               |
          +--------------------+--------------------+
          |                                         |
+---------v---------+                     +---------v---------+
| Recommendation    |                     | User Profile &    |
| Engine Service    |                     | Watch History DB  |
+---------+---------+                     +---------+---------+
          |                                         |
          |                                         |
+---------v---------+                     +---------v---------+
| Video Metadata DB |                     | Event Processing  |
+-------------------+                     | Pipeline (Kafka)  |
                                          +---------+---------+
                                                    |
                                          +---------v---------+
                                          | Feedback & Rating |
                                          | Processing Service|
                                          +-------------------+

Components

API Gateway

Nginx or Envoy

Handles incoming user requests and routes them to appropriate services

Recommendation Engine Service

Python/Java microservice with ML models

Generates personalized video recommendations using hybrid algorithms

User Profile & Watch History DB

NoSQL database like Cassandra or DynamoDB

Stores user preferences, watch history, and interaction data

Video Metadata DB

Relational DB like PostgreSQL or NoSQL like MongoDB

Stores video details such as title, category, tags, and popularity

Event Processing Pipeline

Apache Kafka

Processes real-time user events to update watch history and trigger recommendation updates

Feedback & Rating Processing Service

Microservice with batch and stream processing

Ingests user feedback and ratings to improve recommendation quality

Cache Layer

Redis or Memcached

Caches popular and personalized recommendations for low latency

Request Flow

1. User sends request for video recommendations via API Gateway.

2. API Gateway forwards request to Recommendation Engine Service.

3. Recommendation Engine queries User Profile & Watch History DB and Video Metadata DB.

4. Recommendation Engine generates personalized recommendations using ML models.

5. Recommendations are cached in Redis for quick future access.

6. User watches or interacts with videos; events are sent to Event Processing Pipeline.

7. Event Processing updates User Profile & Watch History DB asynchronously.

8. Feedback & Rating Processing Service consumes events to refine recommendation models.

9. Updated recommendations are refreshed in cache within 5 minutes.

Database Schema

Entities: - User: user_id (PK), name, preferences, region - Video: video_id (PK), title, category, tags, upload_date, popularity_score - WatchHistory: user_id (FK), video_id (FK), watch_timestamp - Feedback: user_id (FK), video_id (FK), rating, comment, feedback_timestamp Relationships: - User to WatchHistory: 1 to many - Video to WatchHistory: 1 to many - User to Feedback: 1 to many - Video to Feedback: 1 to many

Scaling Discussion

Bottlenecks

Recommendation Engine CPU and memory limits when generating recommendations for millions of users

Database read/write throughput for user profiles and watch history

Cache invalidation and freshness for personalized recommendations

Event processing pipeline lag under high user activity

API Gateway handling large concurrent request volume

Solutions

Use distributed recommendation engine with model partitioning and horizontal scaling

Partition and shard databases by user region or user ID to distribute load

Implement smart cache invalidation with TTL and partial updates

Scale Kafka clusters and use multiple consumer groups for event processing

Deploy multiple API Gateway instances behind load balancers with autoscaling

Interview Tips

Time: Spend 10 minutes clarifying requirements and constraints, 20 minutes designing architecture and data flow, 10 minutes discussing scaling and trade-offs, 5 minutes summarizing.

Clarify personalization goals and data availability

Explain choice of hybrid recommendation algorithms

Describe how real-time and batch processing complement each other

Discuss caching strategies to meet latency targets

Highlight database design for scalability and consistency

Address bottlenecks and scaling solutions clearly

Practice

1. What is the primary goal of a video recommendation system?

easy

A. To store all videos in a single database

B. To delete unpopular videos automatically

C. To compress videos for faster streaming

D. To personalize video content to increase user engagement

Solution

1. Step 1: Understand the purpose of recommendation systems

   Recommendation systems aim to suggest content that matches user preferences to keep them engaged.

2. Step 2: Identify the main goal in video platforms

   Personalizing video content helps users find videos they like, increasing engagement and satisfaction.

3. Final Answer:

   To personalize video content to increase user engagement -> Option D

4. Quick Check:

   Personalization = Engagement [OK]

Hint: Focus on user benefit and engagement goals [OK]

Common Mistakes:

• Confusing storage with recommendation
• Thinking compression is the main goal
• Assuming deletion is automatic

2. Which component is essential for real-time video recommendations?

easy

A. Real-time data streaming and processing

B. Offline video transcoding

C. Batch processing system only

D. Static video metadata storage

Solution

1. Step 1: Identify real-time needs in recommendations

   Real-time recommendations require processing fresh user interactions quickly.

2. Step 2: Match components to real-time processing

   Data streaming and processing systems handle live data to update recommendations instantly.

3. Final Answer:

   Real-time data streaming and processing -> Option A

4. Quick Check:

   Real-time = Streaming & Processing [OK]

Hint: Real-time means instant data handling, not batch [OK]

Common Mistakes:

• Choosing batch processing for real-time needs
• Confusing transcoding with recommendation
• Ignoring dynamic data updates

3. Consider a system where user watch history is updated every hour, but recommendations are generated in real-time. What is the likely output when a user watches a new video?

medium

A. The new video immediately influences recommendations

B. Recommendations update only after the next hourly batch

C. Recommendations never change after initial setup

D. The system crashes due to conflicting updates

Solution

1. Step 1: Understand real-time recommendation generation

   Real-time generation means recommendations can change instantly based on new data.

2. Step 2: Analyze watch history update frequency

   Even if watch history updates hourly, real-time components can use streaming data to update recommendations immediately.

3. Final Answer:

   The new video immediately influences recommendations -> Option A

4. Quick Check:

   Real-time generation = Immediate update [OK]

Hint: Real-time generation overrides batch delay [OK]

Common Mistakes:

• Assuming batch update controls recommendation timing
• Thinking system crashes on data conflict
• Believing recommendations are static

4. A video recommendation system is showing outdated videos despite recent user activity. What is the most likely cause?

medium

A. User profiles are deleted frequently

B. Real-time data pipeline is broken or delayed

C. Video metadata is missing thumbnails

D. Batch processing runs too frequently

Solution

1. Step 1: Identify the symptom - outdated recommendations

   Outdated videos suggest the system is not processing recent user actions timely.

2. Step 2: Check real-time data pipeline status

   If the real-time pipeline is broken or delayed, fresh user data won't update recommendations promptly.

3. Final Answer:

   Real-time data pipeline is broken or delayed -> Option B

4. Quick Check:

   Outdated = Pipeline delay [OK]

Hint: Outdated results often mean broken real-time updates [OK]

Common Mistakes:

• Blaming user profile deletion
• Confusing metadata issues with recommendation freshness
• Assuming batch runs cause outdated data

5. To scale a video recommendation system for millions of users, which design choice best balances freshness and computational cost?

hard

A. Generate recommendations on-demand without caching

B. Only use batch processing with daily updates

C. Use a hybrid approach combining batch model training with real-time feature updates

D. Store all user data in a single monolithic database

Solution

1. Step 1: Understand scalability challenges

   Millions of users require efficient computation and timely recommendations without overload.

2. Step 2: Evaluate design options for freshness and cost

   Hybrid systems use batch training for accuracy and real-time updates for freshness, balancing cost and performance.

3. Final Answer:

   Use a hybrid approach combining batch model training with real-time feature updates -> Option C

4. Quick Check:

   Hybrid approach = Freshness + Cost balance [OK]

Hint: Hybrid systems combine batch and real-time strengths [OK]

Common Mistakes:

• Relying only on batch causes stale data
• On-demand without caching is costly
• Monolithic DB limits scalability