19. System Design Case Study 3: Real-Time Chat & Notification System (WhatsApp / Slack) • High-Level System Design (HLD): Distributed Systems at Scale • Rishabh Ki Kaksha

High-Level System Design (HLD): Distributed Systems at Scale › 19. System Design Case Study 3: Real-Time Chat & Notification System (WhatsApp / Slack)

60 mins

← Prev Next →

Course Syllabus

Module 1: Distributed Systems Core & Scalability Fundamentals

01. Scalability Dimensions: Vertical Scaling vs Horizontal Scaling & Latency vs Throughput 02. CAP Theorem vs PACELC Theorem: Consistency, Availability & Partition Tolerance Tradeoffs 03. Consistency Models: Strong Consistency, Eventual Consistency, Read-Your-Writes & Monotonic Reads

Module 2: Networking, Load Balancing & Reverse Proxies

04. Layer 4 vs Layer 7 Load Balancing: Round Robin, Weighted, Least Connections & IP Hash 05. High-Availability Load Balancers: Keepalived, VRRP, Anycast DNS & Failover Clustering 06. API Gateway Pattern: Authentication, Rate Limiting, Request Routing & Circuit Breakers

Module 3: Database Scaling: Sharding, Replication & Distributed Transactions

07. Database Replication: Master-Slave vs Multi-Master & Synchronous vs Asynchronous Replication 08. Database Sharding: Horizontal Partitioning, Directory-Based Sharding & Rebalancing Hotspots 09. Distributed Transactions: Two-Phase Commit (2PC) vs Saga Pattern (Choreography vs Orchestration)

Module 4: Caching Architectures, CDN & Consistent Hashing

10. Caching Strategies: Cache-Aside, Read-Through, Write-Through, Write-Around & Write-Back 11. Cache Invalidation Nightmares: Cache Avalanche, Cache Stampede, Thundering Herd & Cache Penetration 12. Consistent Hashing with Virtual Nodes (Solving Cache Clustering & Dynamic Scaling) 13. Content Delivery Networks (CDN): Edge Caching, Dynamic Site Acceleration & Origin Shielding

Module 5: Message Brokers, Event-Driven Architecture & Stream Processing

14. Message Queues vs Event Streams: RabbitMQ vs Apache Kafka (Partitioning, Consumer Groups) 15. Exactly-Once Processing Semantics (EOS), Idempotency Keys & Deduplication Architecture 16. Distributed Unique ID Generators: Twitter Snowflake, UUIDv7 & Database Ticket Servers

Module 6: FAANG Classic HLD Architectural Case Studies

17. System Design Case Study 1: URL Shortener (TinyURL / Bitly) at 100M Daily Requests 18. System Design Case Study 2: Distributed Rate Limiter & Web Application Firewall 19. System Design Case Study 3: Real-Time Chat & Notification System (WhatsApp / Slack) 20. System Design Case Study 4: Social Media News Feed (Twitter/Instagram) with Fan-out on Write/Read 21. System Design Case Study 5: Video Streaming Platform (YouTube / Netflix) Transcoding Architecture 22. System Design Case Study 6: Ride Hailing Geospatial Dispatch Architecture (Uber / Ola)

Interactive Lesson Studio

# 19. System Design Case Study 3: Real-Time Chat & Notification System (WhatsApp / Slack)

> High-Level Design (HLD) Notes by Rishabh - Topic 19

---

### 1. Scale & Requirements 💬

*   **Scale:** 500 Million Daily Active Users (DAU); 50 Billion messages/day.
*   **Protocols:** WebSocket (Persistent bi-directional TCP) + Push Notifications (APNs / FCM fallback when offline).
*   **Features:** 1-on-1 Chat, Group Chat (Up to 1,000 members), Read Receipts (Single/Double/Blue Ticks), Online Presence.

---

### 2. End-to-End Chat Architecture Diagram

```
[ User A ] ===(WebSocket)====> [ Chat Gateway Server 1 ]
                                      ⬇
                               [ Redis Session Map ] (User B is on Server 2)
                                      ⬇
                               [ Kafka Message Bus ("chat-events") ]
                                      ⬇
[ User B ] <===(WebSocket)==== [ Chat Gateway Server 2 ]
```

*   **Offline Storage:** Apache Cassandra / ScyllaDB (LSM-Tree high-write throughput, ordered by `message_id`).
*   **Push Gateway:** Offline users ke liye Apple APNs / Google FCM push triggers.

---

### 3. Interview Ke 3 Sawal Is Topic Se

1. **Massive Group Chat (10,000 members) me WebSocket broadcast storm kaise optimize karte hain?** -> Message fanout ko background worker queue me push karke server-level batching ke sath execute karna.
2. **User Presence (Online/Offline Status) high scale par kaise implement hota hai?** -> Heartbeat mechanism (Clients send ping every 30s) + Redis TTL keys (`SET user:online:123 1 EX 60`).
3. **End-to-End Encryption (E2EE) Signal Protocol me keys kaise manage hoti hain?** -> Public Identity Keys + Pre-Keys uploaded to server; messages client side par AES-256 session keys se encrypt hote hain jisse server raw text inspect nahi kar sakta.

---
**Next Topic:** 20. System Design Case Study 4: Social Media News Feed (Twitter/Instagram) with Fan-out on Write/Read

Loading lesson content...

Python 3.12

Full IDE

Live Execution Terminal

Click "Execute Live" to run code.
                

Lesson Mastery AI Quiz

AI Doubt Solver

CERTIFICATE OF COMPLETION

Rishabh Gehlot

PHP 8+ & Laravel 11 Master Track