Design a real-time Notification System

Question

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

Codemia · Accepted Answer

### Functional Requirements
1. **Real-time Notifications**: The system must send notifications to users in real-time for various events (e.g., promotions, order updates).
2. **User Preferences**: Users should be able to set preferences for the type of notifications they receive (e.g., email, SMS, in-app).
3. **Scalability**: The system should handle millions of notifications per second during peak shopping hours (e.g., Black Friday).
4. **Delivery Status Tracking**: Users should receive feedback on whether their notifications were delivered successfully.

### Non-Functional Requirements
1. **Low Latency**: Notifications must be delivered within a second of the triggering event.
2. **High Availability**: The system should have a 99.99% uptime to ensure notifications are sent without delay.
3. **Consistency**: Ensure that user preferences are consistently applied to notifications.
4. **Fault Tolerance**: The system should remain operational even if certain components fail.

Assuming Walmart has around 300 million active users:
- **Peak Traffic**: Let's estimate that during peak hours (e.g., holiday sales), 10% of users might trigger notifications, which translates to 30 million notifications.
- **Notification Rate**: If each user triggers notifications at a rate of 1 per second during peak, that's 30 million notifications per second.
- **Data Volume**: Each notification has a payload size of approximately 1 KB. Therefore, the system needs to handle about 30 GB of data per second.
- **Storage Needs**: If we keep logs for 30 days, that amounts to approximately 2.6 TB of data.

The architecture consists of the following components:
1. **Event Producer**: Services that generate notifications (e.g., order service, promotions service).
2. **Message Broker**: Apache Kafka will be used for handling real-time message passing to ensure high throughput and fault tolerance.
3. **Notification Processing Service**: Microservices that subscribe to Kafka topics and handle the business logic of formatting and dispatching notifications.
4. **Notification Delivery Channels**: Services for sending notifications via various channels (e.g., Twilio for SMS, SendGrid for emails, in-app notifications).
5. **User Preferences Database**: A NoSQL database (e.g., MongoDB) to store user preferences, capable of handling schema changes easily.
6. **Monitoring and Analytics**: ELK stack for logging and monitoring system performance and user engagement.

### User Preferences Schema
```json
{
  "userId": "string",
  "notificationPreferences": {
    "email": "boolean",
    "sms": "boolean",
    "inApp": "boolean"
  }
}
```
### Notification Log Schema
```json
{
  "notificationId": "string",
  "userId": "string",
  "type": "string",
  "content": "string",
  "timestamp": "datetime",
  "status": "string"
}
```
### Access Patterns
- Frequent reads/writes for user preferences.
- Bulk inserts for notification logs during peak times.

1. **Eventual Consistency vs. Strong Consistency**: Choosing eventual consistency for notification delivery allows for better performance and availability but may lead to scenarios where users do not receive notifications in the order they expect.
2. **Availability vs. Partition Tolerance**: The system may prioritize availability during peak times, leading to potential delays in delivering some notifications but ensuring that the service remains operational.
3. **Latency vs. Throughput**: By using Kafka, we can achieve high throughput but may introduce slight latency compared to a direct database call, which can be critical for real-time systems.

Design a real-time 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