Design a Scalable Notification Service

Question

Design a scalable notification service that can handle data ingestion, event processing, and filtering logic while ensuring scalability and extensibility.

Codemia · Accepted Answer

To design a scalable notification service, we first need to identify the core requirements. The service should be able to ingest data from various clients, process events in real-time, filter notifications based on user preferences, and deliver notifications through different channels (e.g., email, SMS, push notifications). Additionally, the system should be designed to scale horizontally to accommodate increasing loads and should be extensible to support new notification types in the future.

The high-level architecture of the notification service can be divided into several key components:

1. **Data Ingestion Layer**: This layer receives incoming notifications from clients. It can utilize message queues (e.g., Kafka or RabbitMQ) to handle bursts of incoming data.
2. **Event Processing Layer**: This layer processes the ingested notifications. It includes filtering logic to determine which notifications should be sent to which users based on their preferences.
3. **Storage Layer**: A database (e.g., PostgreSQL or NoSQL options like MongoDB) is used to store user preferences and notification logs.
4. **Delivery Layer**: This layer is responsible for sending notifications through various channels. It can leverage services like AWS SNS for SMS and push notifications, and SMTP servers for emails.

Event processing is crucial for ensuring that users receive relevant notifications. We can implement a filtering mechanism that checks user preferences against the incoming notifications. For example:

- **Step 1**: Upon receiving a notification, the service checks the user’s preferences stored in the database.
- **Step 2**: Only notifications that match the user’s criteria (e.g., category, urgency) are queued for delivery.
- **Step 3**: We can use a rule engine to manage complex filtering logic, allowing for easy updates and extensions to the filtering criteria.

To ensure scalability, we can adopt a microservices architecture that allows independent scaling of each component. For instance, if the data ingestion layer experiences high traffic, we can deploy additional instances of that service without affecting the event processing or delivery layers. For extensibility, we can design the system to support plugin modules for new notification types, enabling the addition of new features without major overhauls.

Here is a simple Python code snippet that illustrates the event processing logic:

```python
class Notification:
    def __init__(self, user_id, content):
        self.user_id = user_id
        self.content = content

class NotificationService:
    def __init__(self, user_preferences):
        self.user_preferences = user_preferences

def filter_notifications(self, notifications):
        filtered = []
        for notification in notifications:
            if self.user_preferences[notification.user_id] == 'relevant':
                filtered.append(notification)
        return filtered

# Example usage
user_preferences = {1: 'relevant', 2: 'irrelevant'}
service = NotificationService(user_preferences)
notifications = [Notification(1, 'New message'), Notification(2, 'New alert')]
filtered_notifications = service.filter_notifications(notifications)
```
This code demonstrates a basic filtering mechanism based on user preferences.

Design a Scalable Notification Service

Salesforce

What the Interviewer Expects

Key Topics to Cover

How to Approach This

Possible Follow-up Questions

Sharpen Your Skills on Codemia

Sample Answer

Requirements

High-Level Design

Submit Your Answer

Salesforce 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