How would you design a real-time chat system supporting group chats, typing indicators, and message history?

Architecture

Client → WebSocket Gateway → Message Service → Message DB (MongoDB)
              ↓                    ↓
         Presence Service     Push Notification Service
              ↓
         Redis (online status)

WebSocket Connection

// Server
const connections = new Map<string, WebSocket>(); // userId → socket

wss.on("connection", (ws, req) => {
  const userId = authenticate(req);
  connections.set(userId, ws);

  // Set online status
  await redis.set(online:${userId}, "1", "EX", 300);

  ws.on("message", async (data) => {
    const msg = JSON.parse(data);

    switch (msg.type) {
      case "chat":
        // Save to DB
        await db.message.create({ data: msg.payload });
        // Deliver to recipients
        for (const recipientId of msg.payload.recipientIds) {
          const recipientWs = connections.get(recipientId);
          if (recipientWs) {
            recipientWs.send(JSON.stringify(msg));
          } else {
            // Offline → push notification
            await sendPushNotification(recipientId, msg.payload);
          }
        }
        break;

      case "typing":
        // Broadcast to chat members (don't persist)
        broadcastToChat(msg.chatId, { type: "typing", userId });
        break;
    }
  });
});

Key Design Decisions

FeatureApproach

Message deliveryWebSocket with push notification fallback
Typing indicatorsDon't persist — broadcast only, debounce 3s
Online statusRedis with 5min TTL, heartbeat every 2min
Message historyMongoDB with pagination, index on { chatId, createdAt }
Group chatsFan-out on write (send to each member's connection)
Read receiptsStore per-message, batch update

Scaling

ComponentStrategy

WebSocket serversHorizontal + Redis pub/sub for cross-server messaging
Message storageMongoDB sharded by chatId
PresenceRedis cluster
File attachmentsPre-signed S3 URLs, not through WebSocket