Search and recommendation in HLD - System Design Exercise

Design: Search and Recommendation System

Design covers backend architecture for search and recommendation features including data ingestion, indexing, query processing, recommendation engine, and APIs. Frontend UI and detailed machine learning model design are out of scope.

Functional Requirements

FR1: Allow users to search for items using keywords with fast response times

FR2: Provide personalized recommendations based on user behavior and preferences

FR3: Support at least 1 million daily active users

FR4: Search results should be relevant and ranked by relevance score

FR5: Recommendations should update in near real-time as user data changes

FR6: Support filtering and sorting options in search results

FR7: Provide analytics on search queries and recommendation effectiveness

Non-Functional Requirements

NFR1: Search API latency p99 < 200ms

NFR2: Recommendation updates within 5 minutes of user activity

NFR3: System availability 99.9% uptime

NFR4: Handle peak traffic of 10,000 concurrent search requests

NFR5: Data storage must support fast read and write operations

NFR6: Ensure user privacy and data security compliance

Think Before You Design

Questions to Ask

❓ Question 1

❓ Question 2

❓ Question 3

❓ Question 4

❓ Question 5

❓ Question 6

❓ Question 7

Key Components

Search index (e.g., Elasticsearch, Solr)

User behavior tracking and data storage

Recommendation engine (collaborative filtering, content-based)

API gateway and load balancer

Caching layer for frequent queries

Analytics and monitoring tools

Design Patterns

Inverted index for search

Batch and real-time data processing

Personalization with user profiles

Cache-aside pattern for search results

Event-driven architecture for updates

A/B testing for recommendation algorithms

Reference Architecture

Client
  |
  v
API Gateway / Load Balancer
  |
  +-----------------------------+
  |                             |
Search Service             Recommendation Service
  |                             |
Search Index (Elasticsearch)  User Profile DB
  |                             |
Cache Layer (Redis)          Behavior Data Store
  |                             |
Analytics & Monitoring System

Components

API Gateway / Load Balancer

Nginx / AWS ALB

Distribute incoming requests and route to appropriate services

Search Service

Elasticsearch

Process search queries using inverted index and return ranked results

Recommendation Service

Custom microservice with ML models

Generate personalized recommendations based on user data

Cache Layer

Redis

Cache frequent search queries and recommendation results for low latency

User Profile DB

PostgreSQL / NoSQL (e.g., Cassandra)

Store user preferences and profile data for personalization

Behavior Data Store

Kafka + HDFS / Data Lake

Collect and store user activity data for batch and real-time processing

Analytics & Monitoring System

Prometheus + Grafana

Track system health, query patterns, and recommendation effectiveness

Request Flow

1. User sends search query or requests recommendations via client app.

2. API Gateway routes request to Search Service or Recommendation Service.

3. Search Service checks cache for query results; if miss, queries Elasticsearch index.

4. Search results are ranked and returned to client; results cached for future requests.

5. Recommendation Service fetches user profile and recent behavior data.

6. Runs recommendation algorithms to generate personalized item list.

7. Recommendations cached and returned to client.

8. User interactions are logged and sent to Behavior Data Store via event stream.

9. Batch jobs update user profiles and retrain recommendation models periodically.

10. Analytics system collects metrics and logs for monitoring and improvements.

Database Schema

Entities: - User: user_id (PK), name, preferences, demographics - Item: item_id (PK), title, description, category, metadata - SearchIndex: inverted index structure managed by Elasticsearch - UserBehavior: event_id (PK), user_id (FK), item_id (FK), action_type, timestamp - RecommendationModel: model_id (PK), version, parameters, last_trained Relationships: - UserBehavior links User and Item with actions - UserProfile stores preferences linked to User - SearchIndex indexes Item data for fast retrieval

Scaling Discussion

Bottlenecks

Search index query latency under high concurrent load

Recommendation engine compute time for large user base

Cache invalidation and consistency with frequent data updates

Data ingestion pipeline throughput for user behavior events

Database read/write throughput for user profiles

Solutions

Shard and replicate search index to distribute query load

Use approximate nearest neighbor search and model caching for recommendations

Implement cache-aside pattern with TTL and event-driven invalidation

Use scalable message queues (Kafka) and stream processing for data ingestion

Partition user profile DB and use read replicas to scale reads

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 user needs and data freshness requirements

Explain choice of search index and recommendation algorithms

Describe caching strategy to meet latency goals

Discuss data pipeline for user behavior and model updates

Highlight scalability challenges and solutions

Mention monitoring and analytics for continuous improvement