Notification system design in HLD - Architecture Diagram

System Overview - Notification system design

This notification system sends messages to users through multiple channels like email, SMS, and push notifications. It must handle high volumes of notifications reliably and deliver them quickly.

Architecture Diagram

User
  |
  v
Load Balancer
  |
  v
API Gateway
  |
  v
Notification Service
  |          |           |
  v          v           v
Message Queue  Cache   User Preferences DB
  |          |           |
  v          v           v
Email Service SMS Service Push Service
  |          |           |
  v          v           v
SMTP Server SMS Gateway Push Notification Provider

Components

User

client

Initiates notification requests

Load Balancer

load_balancer

Distributes incoming requests evenly to API Gateway instances

API Gateway

api_gateway

Handles client requests and routes them to Notification Service

Notification Service

service

Processes notification requests and decides delivery channels

Message Queue

queue

Buffers notification tasks for asynchronous processing

Cache

cache

Stores recent notification statuses and user preferences for fast access

User Preferences DB

database

Stores user notification preferences and contact details

Email Service

service

Sends email notifications via SMTP Server

SMS Service

service

Sends SMS notifications via SMS Gateway

Push Service

service

Sends push notifications via Push Notification Provider

SMTP Server

external_service

Delivers emails to user mailboxes

SMS Gateway

external_service

Delivers SMS messages to mobile networks

Push Notification Provider

external_service

Delivers push notifications to user devices

Request Flow - 15 Hops

User → Load Balancer

Load Balancer → API Gateway

API Gateway → Notification Service

Notification Service → Cache

Notification Service → User Preferences DB

Notification Service → Message Queue

Message Queue → Email Service

Email Service → SMTP Server

Message Queue → SMS Service

SMS Service → SMS Gateway

Message Queue → Push Service

Push Service → Push Notification Provider

Notification Service → Cache

Notification Service → API Gateway

API Gateway → User

Failure Scenario

Component Fails:Message Queue

Impact:Notification tasks cannot be queued, causing delays or loss of notifications

Mitigation:Use a replicated queue system with failover; buffer notifications temporarily in Notification Service memory

Architecture Quiz - 3 Questions

Which component is responsible for distributing incoming user requests evenly?

A API Gateway

B Load Balancer

C Notification Service

D Message Queue

Design Principle

This design uses asynchronous processing with a message queue to handle high notification volumes reliably. Caching user preferences reduces database load and speeds up processing. Load balancing and API gateway ensure scalability and security.

Practice

1. Which component in a notification system is primarily responsible for storing user preferences about how they want to receive notifications?

easy

A. User Management Service

B. Notification Delivery Service

C. Notification Queue

D. Notification Generator

Solution

1. Step 1: Understand user preferences role

   User preferences define how users want to receive notifications (email, SMS, push).

2. Step 2: Identify responsible component

   The User Management Service stores and manages user data including preferences.

3. Final Answer:

   User Management Service -> Option A

4. Quick Check:

   User preferences stored in User Management Service [OK]

Hint: User preferences belong to user data, so User Management Service [OK]

Common Mistakes:

• Confusing Notification Queue as storage for preferences
• Thinking Notification Delivery Service stores preferences
• Assuming Notification Generator manages user data

2. Which of the following is the correct sequence of components involved in sending a notification from creation to delivery?

easy

A. User Management Service -> Notification Delivery Service -> Notification Generator

B. Notification Delivery Service -> Notification Queue -> Notification Generator

C. Notification Queue -> Notification Generator -> Notification Delivery Service

D. Notification Generator -> Notification Queue -> Notification Delivery Service

Solution

1. Step 1: Understand notification flow

   Notifications are created, queued, then delivered.

2. Step 2: Match correct order

   Notification Generator creates, Notification Queue holds, Delivery Service sends.

3. Final Answer:

   Notification Generator -> Notification Queue -> Notification Delivery Service -> Option D

4. Quick Check:

   Creation, queue, delivery order = A [OK]

Hint: Notifications flow: create, queue, then deliver [OK]

Common Mistakes:

• Mixing delivery before queuing
• Starting with delivery service instead of generator
• Ignoring the queue component

3. Consider this simplified flow: A notification is created and placed in a queue. The delivery service fetches notifications from the queue and sends them. If the delivery service crashes after fetching but before sending, what happens to the notification?

medium

A. Notification is lost and never sent

B. Notification is duplicated and sent twice

C. Notification remains in the queue for retry

D. Notification is sent immediately by the generator

Solution

1. Step 1: Analyze delivery service crash timing

   Crash occurs after fetching from queue but before sending notification.

2. Step 2: Understand queue behavior with acknowledgment

   Without acknowledgment, message stays or returns to queue for retry.

3. Final Answer:

   Notification remains in the queue for retry -> Option C

4. Quick Check:

   Unacknowledged messages stay in queue [OK]

Hint: Unsent messages stay in queue until confirmed sent [OK]

Common Mistakes:

• Assuming notification is lost without retry
• Thinking notification is duplicated automatically
• Believing generator sends notification directly

4. A notification system is experiencing delays because the delivery service processes notifications sequentially. Which change will best improve throughput without losing message order?

medium

A. Store notifications only in the database without queue

B. Add multiple delivery service instances with partitioned queues

C. Use a single-threaded delivery service with longer timeouts

D. Remove the queue and send notifications directly

Solution

1. Step 1: Identify bottleneck cause

   Sequential processing limits throughput.

2. Step 2: Apply partitioned queues with multiple instances

   Partitioning allows parallel processing while preserving order per partition.

3. Final Answer:

   Add multiple delivery service instances with partitioned queues -> Option B

4. Quick Check:

   Parallelism with partitioning improves throughput [OK]

Hint: Partition queues to parallelize delivery without breaking order [OK]

Common Mistakes:

• Removing queue loses reliability and order
• Single-threaded service slows throughput
• Storing only in DB delays delivery

5. You need to design a notification system that supports millions of users with different notification preferences and guarantees delivery within seconds. Which architectural approach best meets these requirements?

hard

A. Implement microservices with separate components for user preferences, notification generation, queuing, and delivery with horizontal scaling

B. Use a monolithic service handling all notifications synchronously

C. Store all notifications in a single database table and poll it every minute for delivery

D. Send notifications directly from the user management service without queues

Solution

1. Step 1: Analyze scalability and latency needs

   Millions of users and seconds-level delivery require scalable, decoupled design.

2. Step 2: Choose microservices with separate components and horizontal scaling

   This approach allows independent scaling, fault isolation, and faster processing.

3. Final Answer:

   Implement microservices with separate components for user preferences, notification generation, queuing, and delivery with horizontal scaling -> Option A

4. Quick Check:

   Microservices + scaling = scalable, fast delivery [OK]

Hint: Decouple components and scale horizontally for millions of users [OK]

Common Mistakes:

• Using monolith limits scalability and speed
• Polling DB every minute causes delays
• Skipping queues reduces reliability