Design a Content Delivery for Redfin

Question

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

Codemia · Accepted Answer

### Functional Requirements
1. **User Interaction**: Users can search for properties, view details, and retrieve images/videos related to listings.
2. **Geo-Location Support**: Content delivery should be optimized based on the user's geographic location to minimize latency.
3. **Real-Time Updates**: The system should reflect real-time changes in property listings and availability.
4. **Personalization**: The system should deliver personalized content based on user behavior and preferences.
5. **Content Types**: Support for various content types including images, videos, and property details.

### Non-Functional Requirements
1. **Scalability**: Must handle millions of concurrent requests during peak times (e.g., weekends).
2. **Availability**: 99.99% uptime to ensure users have consistent access to property listings.
3. **Performance**: Response time under 200ms for 95% of requests.
4. **Security**: All user data must be encrypted in transit and at rest; ensure secure authentication for users.
5. **Monitoring and Alerting**: Implement robust monitoring for system performance and alerts for failure scenarios.

### Capacity Estimation
1. **User Base**: Assume Redfin has about 5 million active users.
2. **Peak Concurrent Users**: During peak periods, assume 10% of users are concurrently active, leading to 500,000 concurrent users.
3. **Requests per User**: Estimate that each user makes about 10 requests per minute. 
4. **Total Requests Per Second (QPS)**: 
   - Total requests = 500,000 users * 10 requests/minute = 5,000,000 requests/minute.
   - QPS = 5,000,000 / 60 = ~83,333 requests/second.
5. **Storage Requirements**: If each property listing has an average size of 1MB (including images and metadata), and assuming there are 100,000 properties:
   - Total storage = 100,000 properties * 1MB = 100GB.
   - With additional caching for images, assume 5x for CDN caching needs, totaling approximately 500GB.

### High-Level Architecture
- **Clients**: Web and mobile applications.
- **Load Balancer**: AWS Elastic Load Balancer (ELB) to distribute incoming requests.
- **Application Servers**: Microservices deployed on AWS ECS (Elastic Container Service) for handling business logic and API requests.
- **Caching Layer**: 
  - **Local Caching**: In-memory caching using Redis on each application server for frequently accessed data.
  - **Distributed Caching**: AWS ElastiCache for shared cache across different instances.
  - **CDN**: CloudFront as a CDN to serve static content (images/videos) globally with low latency.
- **Database**: 
  - **Primary Database**: Amazon RDS (PostgreSQL) for structured property data.
  - **Search Index**: Elasticsearch for quick property search capabilities.
- **Monitoring**: AWS CloudWatch for logging and monitoring system performance.

### Data Model
1. **Properties Table**: 
   - `property_id` (PK, UUID)  
   - `title` (VARCHAR)  
   - `description` (TEXT)  
   - `price` (FLOAT)  
   - `location` (GEOGRAPHY)  
   - `images` (JSON)  
   - `created_at` (TIMESTAMP)  
   - `updated_at` (TIMESTAMP)

2. **Users Table**: 
   - `user_id` (PK, UUID)  
   - `name` (VARCHAR)  
   - `email` (VARCHAR, UNIQUE)  
   - `preferences` (JSON)  
   - `created_at` (TIMESTAMP)  
   - `updated_at` (TIMESTAMP)

3. **User Activity Table**: 
   - `activity_id` (PK, UUID)  
   - `user_id` (FK, UUID)  
   - `property_id` (FK, UUID)  
   - `action` (ENUM) (e.g., 'viewed', 'saved')  
   - `timestamp` (TIMESTAMP)

### Access Patterns 
- Frequent reads for property listings and searches, necessitating efficient indexing and caching strategies.

### Key Trade-offs
1. **Consistency vs. Availability**: 
   - Opting for eventual consistency with caching strategies to maintain high availability and performance, especially during peak traffic.
   - Using read replicas in RDS for scaling reads but accepting some delay in data propagation.

2. **Caching Strategy**: 
   - Using a layered caching strategy (local and distributed) to balance speed and resource consumption. Local caching minimizes latency, while distributed caching ensures data is shared across application instances.

3. **Database vs. NoSQL**: 
   - Choosing RDS over NoSQL for structured data to leverage ACID properties, but recognizing the potential need for horizontal scaling and exploring NoSQL solutions like DynamoDB for specific use cases (e.g., user activity logs).

4. **Cost vs. Performance**: 
   - Utilizing AWS services (like CloudFront and ElastiCache) incurs additional costs, but they significantly enhance performance and provide a better user experience, which is vital for user retention.

Design a Content Delivery for Redfin

Redfin

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

Capacity Estimation

Submit Your Answer

Redfin 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