Design a scalable Notification System

Question

Design a scalable notification system handling millions of requests. Discuss consistency, availability, and performance trade-offs.

Codemia · Accepted Answer

### Functional Requirements:
1. **User Notification Preferences**: Users can choose their preferred notification channels (e.g., email, SMS, app notifications).
2. **Notification Types**: Support various types of notifications, such as order updates, promotional offers, and alerts for low stock.
3. **Bulk Notifications**: The system should allow sending bulk notifications to users based on segmentation (e.g., all users who opted in for promotional notifications).
4. **Delivery Status Tracking**: Provide feedback on the delivery status of notifications (sent, delivered, opened).

### Non-Functional Requirements:
1. **Scalability**: The system must scale to handle millions of requests per day, especially during peak shopping seasons.
2. **High Availability**: The system should ensure 99.99% uptime to avoid missing critical notifications.
3. **Latency**: Notifications should be delivered within 5 seconds of the triggering event.
4. **Consistency**: Ensure that users receive notifications based on their preferences without sending duplicate messages.

To estimate the capacity needed for the notification system, let's assume:
- **Daily Active Users**: 50 million users.
- **Notification Frequency**: On average, each user receives 2 notifications per day.
- **Peak Times**: During peak events (e.g., Black Friday), the system might see a 10x increase in notifications.

### Calculation:
- **Daily Notifications**: 50 million users * 2 notifications = 100 million notifications/day.
- **Peak Load**: If we consider a peak event, this could rise to 1 billion notifications in one day.
- **Per Second Calculation**: 
  - 1 billion notifications / (24 hours * 60 minutes * 60 seconds) = approximately 11,574 notifications/second during peak.

Thus, the system must handle at least 12,000 notifications/second.

### Component Diagram:
- **Web Server**: Handles incoming API requests for notifications.
- **Notification Service**: The core service responsible for processing and sending notifications.
- **Message Queue (e.g., Kafka)**: Used to decouple the web server from the notification processing service, allowing for scalable and reliable message delivery.
- **Database (e.g., DynamoDB)**: Stores user preferences, notification logs, and delivery statuses.
- **Notification Channels (e.g., Twilio for SMS, SendGrid for email)**: Interfaces with third-party services to send notifications.

### Technology Choices:
- **Web Framework**: Node.js for asynchronous processing of requests.
- **Message Queue**: Apache Kafka for high throughput and low latency.
- **Database**: DynamoDB for scalability and low-latency access patterns.

### Schema Design:
1. **Users Table**:
   - `user_id` (Primary Key)
   - `email`
   - `phone_number`
   - `notification_preferences` (JSON object detailing preferences per channel)

2. **Notifications Table**:
   - `notification_id` (Primary Key)
   - `user_id` (Foreign Key)
   - `notification_type`
   - `message`
   - `status` (e.g., sent, delivered, opened)
   - `timestamp`

### Access Patterns:
- Fast lookups by `user_id` for sending notifications.
- Aggregation by `notification_type` to track delivery performance.

### Architectural Decisions:
1. **Eventual Consistency vs. Strong Consistency**: Choosing an eventually consistent model allows for better performance and availability, especially during peak loads. However, it might lead to temporary discrepancies in notification delivery status.
2. **Message Queue Over Direct Database Writes**: Using Kafka for message queuing introduces a slight delay in processing but provides better scalability and fault tolerance compared to direct database writes.
3. **Database Choice**: Using DynamoDB allows for automatic scaling but comes with a higher cost compared to traditional relational databases. However, the trade-off is justified for performance and scalability requirements.
4. **Delivery Feedback Mechanism**: Implementing feedback tracking can be resource-intensive. Prioritizing the tracking of delivery status over detailed user engagement metrics can reduce load while still providing essential insights.

Design a scalable Notification System

Walmart

How to Approach This

Sharpen Your Skills on Codemia

Sample Answer

Requirements

Functional Requirements:

Capacity Estimation

Submit Your Answer

Walmart 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