System requirements

Functional:

A database to store all counts for all videos on the platform.

Functionality to count views of a video on the site.

Ability to detect fraudulent views.

Display the up-to-date counts of views.

The system should be able to distinguish between repeat viewings and unique viewings.

Advanced analytics to track how views change over time.

Non-Functional:

Scalability - the system should support thousands of videos and millions of daily users

Performance - the system should work with minimum latency (milliseconds)

Security - the system should be protected from hackers that try to create fake viewings

Reliability - the view counts displayed to users should be fresh

Capacity estimation

100,000 videos

1,000,000 daily viewers

Average viewer watches 5 videos

Peak period: 10%

5,000,000 views/ day

Views per hour

5M/ 24 = 208,333

Views per peak hour

5M/ 10 = 500,000

Database capacity

60 * 60 = 3600

500,000 / 3600 = 139 writes/sec max

Server capacity

Assuming each server can handle 10,000 requests/ hour

500,000 / 10,000 = 50

208,333/ 10,000 = 20

You would need 50 servers/hour during peak time and 20 servers/hour on average during off-peak.

Latency

We would ideally target response times within 500 ms per request for acceptable user experience.

API design

• POST /api/videos/{videoID}/store_count
  • Description: Register a new video count.
  • Request Body: {"userID": "acbde" }
  • Response: { "message": "View count updated." }

• GET /api/videos/{videoID}/count
  • Description: Get the number of views for a video.
  • Response: { "videoID": "12345", "totalViews": 15000, "uniqueViews": 12000 }

• GET /api/videos/{videoID}/analytics
  • Description: Get a detailed breakdown of views for a video, per month.
  • Response: { [{ "date": int, "totalViews": 15000, "uniqueViews": 12000 } , ...] }

Database design

Key Entities

1. User
   • Attributes:
     • userId (Primary Key) string
     • userName string
     • email string
2. Video
   • Attributes:
     • videoId (Primary Key) string
     • title string
     • description string
     • dateUploaded date
     • totalViews int
     • totalUniqueViews int
3. Views
   • Attributes:
     • viewId (Primary Key) string
     • video_ID string
     • userID string
     • viewDate date
     • sessionId string

High-level design

Key Components:

1. User Interface: Displays the number of total views below the video. (Web/Mobile/App)
2. API Gateway: The single entry point for all requests coming from the User Interface. It routes requests to the appropriate services and handles request validation and rate limiting.
3. Database: Stores the viewer count information.
4. Video View Service: Performs increment of viewer count, view retrieval, and checks viewer validity. Use Python.
5. Analytics Service: Generate analytics for content creators, such as total views, unique views, and trends over time.
6. Notification Service: Send real-time updates to clients regarding view count changes.

Technologies:

1. Real-time Communication: WebSockets for real-time interaction.
2. Backend: Python Flask.
3. Database: Use structured tables for fast reads, and ACID principles.
4. Message Queue: Use asynchronous updates to relieve pressure from system.
5. Load Balancer: To scale and handle traffic.

Request flows

Request Flow Explanation

Scenario 1 - Displaying views

1. GET request: The User Interface sends a GET request for the total number of views for the video.
2. API Gateway: The request is passed via the API Gateway to the VVS.
3. Video View Service: The service grabs the data from the database and sends it back to be displayed.

Scenario 2 - Incrementing views

1. POST request: The User Interface sends a POST request to increment the view count of a specific video.
2. API Gateway: The request is passed via the API Gateway to the VVS.
3. Video View Service: The service grabs the current view count for the video from the Video table, as well as checking if the viewer has seen the video before. It then generates new values based on this info.
4. Database: The new values are stored in the database via a queue.

Detailed component design

Dig deeper into 2-3 components and explain in detail how they work. For example, how well does each component scale? Any relevant algorithm or data structure you like to use for a component? Also you could draw a diagram using the diagramming tool to enhance your design...

Trade offs/Tech choices

1. Database Choice

Trade-off: Choosing between SQL (relational) and NoSQL (non-relational) databases.

Decision: Opted for an SQL database due to the requirement for ACID principles, structure, and fast reads.

2. Asynchronous updates

Trade-off: Choosing between immediately consistent vs eventually consistent updates.

Decision: Opted to use a message queue to alleviate pressure on the database and server. Having data that is slightly inconsistent is acceptable because the information (video views) isn't critical to user experience.

3. LoadBalancer

Trade-off: Choosing between vertical and horizontal scaling.

Decision: The huge volume of users is not practical for a single server: it's unlikely a single server could support the traffic. Even if it could, users expect high availability, so we need to make sure there are multiple failover points. We can also scale up/down during high/low periods to reduce server costs.

Cons:

• Increased complexity in managing service interactions and deployments.
• Requires robust monitoring and logging between services.

Failure scenarios/bottlenecks

1. Database Bottlenecks

• Scenario: High concurrent write requests to the database when many users view videos simultaneously, which can lead to slow response times and timeouts.
• Mitigation Strategies:
  • Database Caching: Use an in-memory caching system (like Redis) to cache frequently requested view counts, reducing the load on the database.
  • Load Sharding: Implement sharding to distribute database write/read loads across multiple database instances.
  • Connection Pooling: Use connection pooling to manage database connections efficiently, minimizing the overhead of establishing new connections.

2. Service Downtime

• Scenario: A single service (like the Video View Service or Analytics Service) goes down, preventing users from viewing counts or accessing analytics.
• Mitigation Strategies:
  • Health Checks and Monitoring: Implement health checks and monitoring to detect downtime quickly and automatically restart failed services.
  • Load Balancing: Distribute traffic across multiple service instances to ensure continued availability.
  • Fallback Mechanisms: Allow the system to serve cached responses if the primary service is unavailable temporarily.

3. Real-Time Updates Failure

• Scenario: A failure in the Notification Service leads to users not receiving real-time updates for view counts.
• Mitigation Strategies:
  • Retry Logic: Implement a retry mechanism for sending update messages when users are not reachable.
  • WebSocket Health Checks: Monitor the WebSocket connections to ensure they remain active, automatically reconnecting clients when necessary.
  • Graceful Degradation: Show a static view count and notify users of temporary unavailability of real-time updates.

4. Network Latency and Throttling

• Scenario: High network latency during peak periods can cause delayed responses for API requests, particularly during view-count updates.
• Mitigation Strategies:
  • Content Delivery Network (CDN): Use a CDN to cache responses geographically closer to users, reducing server load and latency.
  • Optimize APIs: Minimize response payloads by limiting the amount of data sent in API responses.
  • Rate Limiting: Implement rate limiting to prevent abuse and manage server load during spikes in traffic.

5. Data Integrity Issues

• Scenario: Concurrent increments on the view count may lead to race conditions, resulting in inaccurate view counts (e.g., double counting).
• Mitigation Strategies:
  • Atomic Operations: Use atomic operations for incrementing view counts in the database to ensure that each increment is treated as a single transaction.
  • Optimistic Locking: Implement optimistic locking strategies that allow for handling conflicts in a controlled manner.

6. User Session Management

• Scenario: Challenges in managing user sessions might lead to incorrect view counting (e.g., counting views from the same user multiple times).
• Mitigation Strategies:
  • Session Tokenization: Employ session tokens that uniquely identify user sessions to track views accurately.
  • Unique View Tracking: Implement tracking to distinguish between unique and total views, counting only unique views where applicable.

7. Scalability Problems

• Scenario: As user demand increases, the system may struggle to scale and provide acceptable performance levels.
• Mitigation Strategies:
  • Horizontal Scalability: Design services to scale horizontally by adding more instances, particularly for stateless services like the API Gateway and Video View Service.
  • Auto-Scaling: Use cloud provider auto-scaling features to automatically adjust the number of service instances based on traffic load.

Future improvements

1. Scalability Enhancements

• Auto-Scaling: Implement auto-scaling for all services (e.g., Video View Service, Analytics Service) based on real-time traffic metrics to handle unpredictable traffic spikes.
• Database Sharding: For larger datasets, implement sharding strategies to distribute database load and improve read/write performance.

2. Enhanced Analytics

• Detailed User Analytics: Incorporate more granular analytics such as demographic data and user behavior tracking to provide content creators with deeper insights into their audience.
• Real-Time Reporting: Enable real-time reporting dashboards where content creators can see live analytics updates instead of relying on periodic updates.

3. Machine Learning Models

• Content Recommendations: Implement machine learning algorithms to provide personalized video recommendations based on user preferences and viewing history, improving user engagement.
• Fraud Detection: Use machine learning to detect patterns of fraudulent activity quickly, such as fake views, by analyzing viewing patterns and geographic data.

4. Improved User Experience

• Mobile App Development: Create dedicated mobile applications to enhance user interaction and provide a tailored experience, possibly integrating offline view functionalities.
• Real-Time Comments and Interaction: Implement real-time commenting features where viewers can interact during live streams, increasing engagement and community building.

5. Security Improvements

• Enhanced Authentication: Employ multi-factor authentication (MFA) for content creators to secure their accounts against unauthorized access.
• Data Encryption: Ensure all data transactions (including view counts) are encrypted to protect user data and improve overall system security.

6. API Enhancements

• GraphQL Implementation: Consider implementing GraphQL for API endpoints, allowing clients to request only the data they need and reducing over-fetching.
• Versioning Strategy: Adopt a clear versioning strategy for APIs to ensure backward compatibility as features evolve and make it easier to introduce new functionality.

7. Load Testing and Performance Optimization

• Regular Load Testing: Implement regular load testing schedules to identify potential bottlenecks before they become issues in production.
• Performance Optimization: Continuously monitor performance metrics and optimize query responses, particularly for high-traffic operations like fetching view counts.

8. Enhanced Notification System

• Push Notifications: Implement push notifications for mobile apps to alert users about new comments, updates on their videos, or when someone interacts with their content in real-time.
• In-app Notifications: Provide in-app notifications for both users and content creators about key events, analytics, and engagement metrics.

9. User Engagement Features

• Interactive User Features: Introduce features such as polls or Q&A sessions during video streaming to boost interaction.
• Gamification Elements: Implement gamification strategies, like badges and rewards for content creators based on engagement metrics and milestones achieved, improving motivation and retention.