Design Feed Generation Infrastructure for microservices

Question

Design a fault-tolerant feed generation system that handles millions of requests. Discuss trade-offs in consistency, availability, and performance.

Codemia · Accepted Answer

### Functional Requirements
1. **Feed Generation**: The system must generate personalized feeds based on user preferences and activity across various microservices (e.g., product recommendations, recent views).
2. **Real-time Updates**: The feed must reflect real-time data from multiple sources, updating at least every few seconds.
3. **User Interaction**: Users should be able to interact with the feed, providing feedback that can influence future feed generation.
4. **Multi-Device Support**: The feed must be accessible on various devices (desktop, mobile, etc.).

### Non-Functional Requirements
1. **Scalability**: The system should handle millions of requests per second, scaling horizontally as needed.
2. **Fault Tolerance**: The system must remain operational even during partial failures, ensuring data integrity and availability.
3. **Latency**: The system should serve feeds with a maximum latency of 200 ms under normal load conditions.
4. **Monitoring & Logging**: Implement robust monitoring and logging to trace requests, errors, and performance metrics.

### Estimation of Scale
- **User Base**: Assume 100 million active users.
- **Requests Per Second (QPS)**: If each user requests their feed 10 times per hour:
  - Total requests = 100 million users * 10 requests/hour = 1 billion requests/hour = ~277,778 requests/second.
- **Data Storage**: If each feed contains 50 items and each item takes up 1 KB:
  - Total storage = 100 million users * 50 items * 1 KB = ~4.77 TB of data, with additional space for metadata and logs.
- **Bandwidth**: Assuming an average of 100 KB per feed response, total bandwidth requirement = 277,778 requests/sec * 100 KB = ~27.8 GB/sec.

### Component Diagram
- **API Gateway**: Amazon API Gateway to handle incoming requests, providing rate limiting and request validation.
- **Load Balancer**: Elastic Load Balancer (ELB) to distribute requests across multiple feed generation microservices.
- **Feed Generation Service**: A set of microservices (built with AWS Lambda for scalability) responsible for fetching user data and generating feeds.
- **Caching Layer**: Amazon ElastiCache (Redis) for caching frequently accessed feeds to reduce latency.
- **Data Store**: Amazon DynamoDB as the primary database for storing user preferences and feed data, chosen for its scalability and low latency.
- **Monitoring**: AWS CloudWatch for logging and alerting on performance metrics and potential failures.

### Schema Design
1. **Users Table (DynamoDB)**:
   - `UserID` (PK): String
   - `Preferences`: JSON (user preferences for feed generation)
   - `LastUpdated`: Timestamp

2. **Feeds Table (DynamoDB)**:
   - `FeedID` (PK): String
   - `UserID` (GSI): String
   - `Items`: List of JSON objects (representing feed items)
   - `GeneratedAt`: Timestamp

3. **Interactions Table (DynamoDB)**:
   - `InteractionID` (PK): String
   - `UserID` (GSI): String
   - `Feedback`: JSON (user interactions with the feed)
   - `Timestamp`: Timestamp

### Access Patterns
- Fetch user feed by UserID.
- Update user preferences and interactions.

### Architectural Decisions
1. **Consistency vs Availability**: Choosing DynamoDB provides eventual consistency by default, which is acceptable for feed generation since slight delays in updates are tolerable for users.
2. **Caching Strategy**: Using Redis for caching improves read performance but introduces complexity in cache invalidation when user preferences change. This trade-off favors performance over consistency in real-time feed updates.
3. **Microservices vs Monolith**: Using a microservices architecture allows for better scaling and isolated failures, but it increases the complexity of managing multiple services and potential inter-service communication latency.
4. **Data Partitioning**: Choosing to shard data by UserID in DynamoDB optimizes read/write performance, but requires careful design to ensure even distribution of traffic and data.

Design Feed Generation Infrastructure for microservices

Amazon

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

Estimation of Scale

Submit Your Answer

Amazon 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