Design a Notification for Snapchat

Question

Design a event-driven notification system that handles millions of requests. Discuss trade-offs in consistency, availability, and performance.

Codemia · Accepted Answer

### Functional Requirements
1. **User Notifications**: The system should send real-time notifications for various events such as snaps received, stories viewed, friend requests, etc.
2. **Personalization**: Users should receive tailored notifications based on their interests and interactions.
3. **Delivery Status**: The system should provide feedback on whether notifications were delivered successfully, opened, or interacted with.
4. **User Preferences**: Allow users to customize their notification settings (e.g., types of notifications, silent mode).

### Non-Functional Requirements
1. **High Availability**: The system should have 99.9% uptime, ensuring that notifications are sent even during peak traffic.
2. **Scalability**: The system should handle spikes during events (like New Year’s) with minimal latency.
3. **Latency**: Notifications should be delivered in under 200ms.
4. **Data Consistency**: Ensure eventual consistency in notification delivery across regions.

Assuming Snapchat has approximately 500 million daily active users (DAUs) and on average, each user generates 10 notifications per day:

1. **Total Notifications**: 500 million users * 10 notifications = 5 billion notifications per day.
2. **Per Second Calculation**: 5 billion notifications / 86400 seconds = ~58,000 notifications per second (NPS).
3. **Peak Load**: During peak hours (say 2 hours), we might see up to 3x the average, leading to ~174,000 NPS.

From this, our system should be designed to handle at least 200,000 notifications per second to accommodate spikes and ensure a buffer.

### Component Diagram
- **Event Producer**: Mobile clients generating events (snaps, friend requests).
- **API Gateway**: Handles incoming requests and routes them to the appropriate services.
- **Message Queue (Kafka)**: Acts as a buffer to decouple event producers from consumers, ensuring reliable delivery.
- **Notification Service**: Processes messages from Kafka, formats notifications, and sends them to users.
- **Database (DynamoDB)**: Stores user preferences and notification metadata.
- **Analytics Service**: Gathers metrics on delivery rates, user interaction, and system health.

### Technology Choices
- **Kafka** for message queuing: High throughput and fault tolerance.
- **DynamoDB**: Scalable NoSQL database for fast reads/writes with high availability.

### Schema Design
1. **User Table**:
   - `user_id (PK)`
   - `preferences (JSON)`
   - `last_notification_time`

2. **Notification Table**:
   - `notification_id (PK)`
   - `user_id (FK)`
   - `event_type`
   - `timestamp`
   - `status` (delivered, opened, etc.)

3. **Event Log Table**:
   - `event_id (PK)`
   - `user_id (FK)`
   - `event_type`
   - `event_data (JSON)`
   - `timestamp`

### Access Patterns
- Frequent writes to the Notification Table during peak hours.
- Read-heavy access to User Table for preferences and last notification time.

### Architectural Decisions
1. **Eventual Consistency vs. Strong Consistency**: Opted for eventual consistency to enhance availability and performance. Notifications might not appear instantaneously but will eventually be consistent across devices.
2. **Message Queue Choice**: Kafka provides reliability and persistence, but introduces latency. We accept this for durability and scalability.
3. **Database Selection**: Chose DynamoDB for its scalability and speed; however, it may incur higher costs compared to traditional SQL databases that could offer stronger consistency guarantees.
4. **Data Sharding**: To maintain performance, we will shard the database by user ID. This adds complexity in managing the shards but allows horizontal scaling.

### Operational Excellence
- **Monitoring**: Implement monitoring using Datadog for real-time performance metrics and alerts on anomalies.
- **SLOs/SLIs**: Define SLOs around notification delivery times and system uptime, with SLIs based on delivery success rates and average latency.
- **Deployment Strategy**: Use blue-green deployments for smooth rollouts and minimize downtime.

Design a Notification for Snapchat

Snapchat

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

Snapchat 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