Notification System

Assumptions:
- 100M users
- 10 notifications per user per day
- 1 billion notifications per day

QPS:
1B / 86,400 ≈ 12,000 notifications/second
Peak: ~30,000/second

                    ┌─────────────────┐
                    │   API Gateway   │
                    └────────┬────────┘
                             │
                    ┌────────▼────────┐
                    │  Notification   │
                    │    Service      │
                    └────────┬────────┘
                             │
                    ┌────────▼────────┐
                    │  Message Queue  │
                    │    (Kafka)      │
                    └────────┬────────┘
                             │
         ┌───────────────────┼───────────────────┐
         │                   │                   │
    ┌────▼────┐        ┌────▼────┐        ┌────▼────┐
    │  Push   │        │   SMS   │        │  Email  │
    │ Worker  │        │ Worker  │        │ Worker  │
    └────┬────┘        └────┬────┘        └────┬────┘
         │                   │                   │
         ▼                   ▼                   ▼
    ┌─────────┐        ┌─────────┐        ┌─────────┐
    │  APNs/  │        │ Twilio  │        │SendGrid │
    │  FCM    │        │         │        │         │
    └─────────┘        └─────────┘        └─────────┘

1. Receive notification request
2. Validate and enrich data
3. Check user preferences
4. Apply rate limiting
5. Queue for delivery

notifications.push
notifications.sms
notifications.email

Partitioned by user_id for ordering

1. Consume from queue
2. Build notification (templates)
3. Call external provider
4. Update delivery status
5. Handle retries

-- User preferences
CREATE TABLE notification_preferences (
    user_id BIGINT PRIMARY KEY,
    push_enabled BOOLEAN DEFAULT true,
    sms_enabled BOOLEAN DEFAULT true,
    email_enabled BOOLEAN DEFAULT true,
    quiet_hours_start TIME,
    quiet_hours_end TIME
);

-- Notification log
CREATE TABLE notifications (
    id UUID PRIMARY KEY,
    user_id BIGINT,
    type VARCHAR(20),
    channel VARCHAR(20),
    content TEXT,
    status VARCHAR(20),
    created_at TIMESTAMP,
    sent_at TIMESTAMP,
    delivered_at TIMESTAMP
);

-- Templates
CREATE TABLE notification_templates (
    id VARCHAR(50) PRIMARY KEY,
    channel VARCHAR(20),
    subject TEXT,
    body TEXT
);

POST /api/notifications
{
    "user_id": "123",
    "type": "order_update",
    "channels": ["push", "email"],
    "data": {
        "order_id": "456",
        "status": "shipped"
    }
}

GET /api/users/123/notification-preferences

Response:
{
    "push_enabled": true,
    "sms_enabled": false,
    "email_enabled": true
}

1. Queue message
2. Worker processes
3. On success: ACK message
4. On failure: Retry (message redelivered)

Risk: Duplicate notifications

Store notification ID in cache
Before sending: Check if already sent
TTL: 24 hours

Per user limits:
- Push: 50/hour
- SMS: 5/day
- Email: 10/day

Implementation:
- Redis counters per user per channel
- Check before queueing

Attempt 1: Immediate
Attempt 2: After 1 minute
Attempt 3: After 5 minutes
Attempt 4: After 30 minutes
Attempt 5: After 2 hours

After max retries: Dead letter queue

If provider fails repeatedly:
- Open circuit
- Fail fast
- Queue for later retry