Design a Search Service

Question

Design a high-throughput search system that handles millions of requests. Discuss trade-offs in consistency, availability, and performance.

Codemia · Accepted Answer

### Functional Requirements
1. **Search Functionality**: The system should support keyword searches across various data fields like IP addresses, timestamps, and file hashes.
2. **Filtering and Sorting**: Users must be able to filter results by date ranges and sort them based on relevance or timestamp.
3. **Authentication**: All requests should be authenticated using JWT (JSON Web Tokens) to ensure secure access.
4. **Rate Limiting**: Implement rate limiting per user to prevent abuse and ensure fair usage.

### Non-Functional Requirements
1. **High Availability**: The system must be operational 99.99% of the time.
2. **Low Latency**: Search results should be returned within 200ms for 95% of requests.
3. **Scalability**: The system should handle up to 10 million queries per day with the ability to scale horizontally.
4. **Data Durability**: Ensure that data is replicated and available in case of node failures.

To estimate the capacity, we assume:
- Peak queries per second (QPS): 10,000 (based on 10 million searches per day).
- Average request size: 1 KB.
- Assuming the system runs 24/7, the bandwidth required:
  - Total data processed in a day = 10 million * 1 KB = ~9.54 GB.
  - Peak bandwidth = QPS * Average request size = 10,000 * 1 KB = ~10 MB/s.

### Storage Requirements
- If we assume an average of 10 records returned per search, we will require storage for:
  - Total records = 10 million searches * 10 records = 100 million records.
  - Assuming each record takes approximately 1 KB, total storage = 100 million KB = ~95.37 GB.

### Component Diagram
- **Load Balancer**: Distributes incoming requests evenly across multiple search service instances.
- **Search Service**: Implements the search logic; each instance can handle multiple queries concurrently.
- **Message Queue (e.g., Kafka)**: Handles incoming search requests asynchronously, allowing for decoupling and scalability.
- **Database (e.g., Elasticsearch)**: Stores searchable data and provides high-speed full-text search capabilities.
- **Caching Layer (e.g., Redis)**: Caches frequently accessed search results to reduce load on the database.
- **Monitoring (e.g., Prometheus & Grafana)**: Monitors performance metrics and logs for alerting and troubleshooting.

### Schema Design
- **Search Index** (Elasticsearch)
  - `id`: String (Unique identifier)
  - `ip_address`: String (IP address of the endpoint)
  - `file_hash`: String (Hash of the file)
  - `timestamp`: Date (When the record was created)
  - `metadata`: Object (Additional information about the record)

### Access Patterns
- Searches will primarily be conducted on `ip_address`, `file_hash`, and `timestamp`, so these fields should be indexed to optimize search performance.

### Consistency vs Availability
- **Eventual Consistency**: Given the scale, we might opt for eventual consistency over strict consistency to ensure high availability and low latency. This means that data might not be immediately consistent across all nodes after write operations, but will eventually converge.

### Performance Considerations
- **Caching vs Database Load**: Implementing a caching layer will significantly reduce database load but requires careful management of cache invalidation strategies, especially for frequently updated data.

### Horizontal Scaling vs Complexity
- Scaling horizontally by adding more instances of the search service provides better throughput but increases system complexity. Load balancers and message queues must be managed properly to handle distributed state effectively.

Design a Search Service

SentinelOne

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

Submit Your Answer

SentinelOne Product Manager 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