Notification System LLD

Design Intent

What your code is doing

Strategy Pattern

NotificationStrategy gives Email, SMS, and WhatsApp the same send contract. New channels can be added without changing the caller.

Observer Pattern

MessageSubject broadcasts a new message to all registered observers. Each observer then sends through the user preferred channels.

Thread-Friendly Collections

CopyOnWriteArrayList keeps observer iteration safe while observers are added or removed.

Design Principles

How SOLID appears in this design

Single Responsibility

Channel classes only send messages, subject manages subscribers, observer maps preferences to channels, and service coordinates direct send.

Open/Closed

To add Push Notification, create another strategy and register it in the strategy map.

Dependency Inversion

MessageService depends on NotificationStrategy, not concrete channel classes.

Broadcast Fan-Out

The subject does not know how each user receives notifications. Observers own user-specific delivery preferences.

Request Flow

How direct and broadcast notifications move

Direct Send

MessageService sends through one selected strategy

The client chooses the concrete channel and passes it as a strategy. The service calls the interface method.

MessageService m1 = new MessageService("ID01", "Hello", new Email());
m1.sendNotification();

Interview answer

This is Strategy Pattern: the sending algorithm is swappable at runtime.

Broadcast Send

Subject notifies all registered observers

When the subject message changes, every observer receives the update and sends through that user preferred channels.

subject.add(ob1);
subject.add(ob2);
subject.setMessage("Broadcast: System Maintenance at 10PM");

Runtime path

SubjectObserverUser PreferencesStrategy MapChannels

Code Walkthrough

Explain each important snippet like an interview answer

Channel Contract

One interface for every notification type

Every channel implements the same send method.

interface NotificationStrategy {
    boolean send(String message, String id);
}

Pattern

This is Strategy Pattern. Email, SMS, WhatsApp are separate algorithms behind one contract.

Direct Service

MessageService delegates sending

The service stores message, user id, and selected strategy.

class MessageService {
    private NotificationStrategy strategy;

    public void sendNotification() {
        strategy.send(Message, UserId);
    }
}

Design principle

This follows Dependency Inversion because the service talks to an interface.

Subject

Broadcast message source

The subject keeps observers and calls update when a new message is published.

public void setMessage(String message) {
    this.message = message;
    Notify();
}

Pattern

This is Observer Pattern. A state change triggers updates to all subscribers.

Observer

User preferences decide delivery channels

The observer reads user preferences and uses the strategy map.

for (NotificationTypes type : user.getPreferredNotificationTypes()) {
    NotificationStrategy strategy = strategyMap.get(type);
    if (strategy != null) {
        strategy.send(msg, user.getId());
    }
}

Interview answer

User-specific fan-out is outside the subject, so the subject stays loosely coupled.

Run The Code

Read it here, run it in the embedded Java compiler

Java Source

Compiler-friendly version: no package line and runnable class is Main. It runs direct-send plus broadcast automatically.

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

enum NotificationTypes {
    EMAIL, SMS, WHATSAPP
}

class User {
    private String userName;
    private String id;
    private List<NotificationTypes> preferredNotificationTypes;

    public User(String name, String id, List<NotificationTypes> preferredNotificationTypes) {
        this.userName = name;
        this.id = id;
        this.preferredNotificationTypes = preferredNotificationTypes;
    }

    public String getId() { return this.id; }
    public String getUserName() { return this.userName; }
    public List<NotificationTypes> getPreferredNotificationTypes() { return preferredNotificationTypes; }
}

interface NotificationStrategy {
    boolean send(String message, String id);
}

class Email implements NotificationStrategy {
    public boolean send(String message, String id) {
        System.out.println("EMAIL : " + message + " to : " + id);
        return true;
    }
}

class WhatsApp implements NotificationStrategy {
    public boolean send(String message, String id) {
        System.out.println("WHATSAPP : " + message + " to : " + id);
        return true;
    }
}

class SMS implements NotificationStrategy {
    public boolean send(String message, String id) {
        System.out.println("SMS : " + message + " to : " + id);
        return true;
    }
}

class MessageService {
    private NotificationStrategy strategy;
    private String message;
    private String userId;

    public MessageService(String id, String message, NotificationStrategy strategy) {
        this.strategy = strategy;
        this.message = message;
        this.userId = id;
    }

    public void sendNotification() {
        this.strategy.send(this.message, this.userId);
    }
}

interface MessageSubject {
    void add(MessageObserver observer);
    void remove(MessageObserver observer);
    void notifyObservers();
    String getMessage();
}

interface MessageObserver {
    void update(MessageSubject subject);
}

class MessageConcreteSubject implements MessageSubject {
    final List<MessageObserver> recipients = new CopyOnWriteArrayList<>();
    private String message;

    public void setMessage(String message) {
        this.message = message;
        notifyObservers();
    }

    public String getMessage() { return message; }
    public void add(MessageObserver observer) { recipients.add(observer); }
    public void remove(MessageObserver observer) { recipients.remove(observer); }

    public void notifyObservers() {
        for (MessageObserver user : recipients) {
            user.update(this);
        }
    }
}

class MessageConcreteObserver implements MessageObserver {
    private final User user;
    private final Map<NotificationTypes, NotificationStrategy> strategyMap;

    public MessageConcreteObserver(User user, Map<NotificationTypes, NotificationStrategy> strategyMap) {
        this.user = user;
        this.strategyMap = strategyMap;
    }

    public void update(MessageSubject subject) {
        String msg = subject.getMessage();
        for (NotificationTypes type : user.getPreferredNotificationTypes()) {
            NotificationStrategy strategy = strategyMap.get(type);
            if (strategy != null) {
                strategy.send(msg, user.getId());
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        User u1 = new User("SAM", "Id01", Arrays.asList(NotificationTypes.SMS, NotificationTypes.EMAIL));
        User u2 = new User("PAM", "Id02", Arrays.asList(NotificationTypes.WHATSAPP, NotificationTypes.EMAIL));

        System.out.println("Direct notifications");
        new MessageService("Id01", "Hello", new Email()).sendNotification();
        new MessageService("Id01", "Hello", new SMS()).sendNotification();
        new MessageService("Id01", "Hello", new WhatsApp()).sendNotification();

        Map<NotificationTypes, NotificationStrategy> strategyMap = new HashMap<>();
        strategyMap.put(NotificationTypes.EMAIL, new Email());
        strategyMap.put(NotificationTypes.SMS, new SMS());
        strategyMap.put(NotificationTypes.WHATSAPP, new WhatsApp());

        MessageConcreteSubject subject = new MessageConcreteSubject();
        subject.add(new MessageConcreteObserver(u1, strategyMap));
        subject.add(new MessageConcreteObserver(u2, strategyMap));

        System.out.println();
        System.out.println("Broadcast notification");
        subject.setMessage("Broadcast: System Maintenance at 10PM");
    }
}

Embedded Compiler

Copy the Java source on the left and paste it into the compiler. It runs immediately with direct and broadcast examples.

Interview Ready

Notes For Interview

How to explain the design

This Notification System LLD separates notification channel selection from broadcast subscription. Direct sending uses `NotificationStrategy`, so Email, SMS, and WhatsApp are interchangeable channels. Broadcast messaging uses Observer Pattern, where a subject keeps subscribers and notifies each observer when a message is published.

Flow Diagram

Client creates message

Choose notification channel

MessageService delegates to strategy

Channel sends direct notification

For broadcast, Subject notifies observers

Subscribers receive update

UML Diagram: IS-A and HAS-A

NotificationStrategy

IS-A

SMS

MessageSubject

IS-A

MessageConcreteSubject

HAS-A

List<MessageObserver>

MessageObserver

IS-A

MessageConcreteObserver

HAS-A

User

MessageService

HAS-A

NotificationStrategy

Core classes

NotificationStrategy: contract for sending a message through a channel.
Email, SMS, WhatsApp: concrete channel strategies.
MessageService: stores message data and delegates sending to a selected strategy.
MessageSubject: manages subscriber registration and broadcast notification.
MessageObserver: receives broadcast updates.

Why these patterns are used

Strategy Pattern is used because the way a notification is delivered changes by channel. Email, SMS, WhatsApp, push notification, and in-app notification all have different providers, payloads, failure behavior, and latency. The service should not contain channel-specific `if-else` logic. By depending on `NotificationStrategy`, the sender can plug in a channel at runtime.

Observer Pattern is used for broadcast use cases. A subject represents the event source, and observers represent subscribers. When a new broadcast message is published, the subject does not need to know each subscriber's internal behavior. It simply calls `update()` on all registered observers. This keeps the publisher loosely coupled from receivers.

Algorithm explanation

Direct notification flow is straightforward: create message data, choose a notification strategy, and call `send`. The selected strategy owns provider-specific delivery behavior. This is a runtime polymorphism example: the same method call behaves differently depending on the concrete strategy object.

Broadcast flow is a fan-out algorithm. The subject stores a list of observers. When a message arrives, it iterates through subscribers and invokes their `update` method. In production, this fan-out should usually be asynchronous through a queue, because one slow or failed subscriber should not block the whole broadcast.

Strong interview answer

"I would use Strategy Pattern for notification channels and Observer Pattern for broadcast. Strategy lets the client choose Email, SMS, or WhatsApp without changing the service. Observer lets many users subscribe to a subject and receive updates when a broadcast event happens."

Production improvements

Add retry policy, dead-letter queue, and failure tracking.
Make sends asynchronous through a queue such as Kafka, SQS, or RabbitMQ.
Add user preferences, quiet hours, and unsubscribe rules.
Add templates, localization, rate limits, and provider fallback.
Track notification delivery states: queued, sent, failed, delivered, read.

Weakness to mention

The in-memory demo shows patterns well, but a production notification system must handle asynchronous delivery, provider failures, retries, idempotency, and user preferences.