How would you design a real-time chat / messaging system like WhatsApp or Slack

package com.bank.chat.service;

import java.time.Instant;

public class MessageService {

    private final MessageRepository repository;
    private final SequenceGenerator sequenceGenerator;
    private final DeliveryService deliveryService;

    public MessageService(MessageRepository repository,
                           SequenceGenerator sequenceGenerator,
                           DeliveryService deliveryService) {
        this.repository = repository;
        this.sequenceGenerator = sequenceGenerator;
        this.deliveryService = deliveryService;
    }

    public Message send(String conversationId, String senderId, String text) {
        // Step 1: Assign sequence and persist FIRST
        long seq = sequenceGenerator.next(conversationId);
        Message msg = new Message(conversationId, senderId, text, seq, Instant.now());
        repository.save(msg);

        // Step 2: Deliver (best effort; message is safe in DB)
        deliveryService.pushToRecipients(msg);

        return msg; // Sender sees "sent" = durably stored
    }
}

package com.bank.chat.websocket;

import javax.websocket.OnMessage;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;

@ServerEndpoint("/chat/{conversationId}")
public class ChatEndpoint {

    @OnMessage
    public void onMessage(String messageJson, Session session) {
        // Receive from client, persist, then broadcast to recipients
    }

    public void pushToClient(Session session, String messageJson) {
        session.getAsyncRemote().sendText(messageJson);
    }
}

package com.bank.chat.service;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;

public class SequenceGenerator {

    private final ConcurrentHashMap<String, AtomicLong> sequences =
        new ConcurrentHashMap<>();

    public long next(String conversationId) {
        return sequences
            .computeIfAbsent(conversationId, k -> new AtomicLong(0))
            .incrementAndGet();
    }
}

# Conversation "conv-123":
# Message 1: seq=1 (Rajesh: "Hi Priya")
# Message 2: seq=2 (Priya: "Hello Rajesh")
# Even if seq=2 arrives at the client before seq=1,
# the client renders by sequence: 1, 2.

package com.bank.chat.model;

public class MessageReceipt {
    private String messageId;
    private String recipientId;
    private ReceiptState state; // SENT, DELIVERED, READ
    private long timestamp;

    public enum ReceiptState { SENT, DELIVERED, READ }
}

// Flow:
// 1. Message persisted -> state = SENT (one tick)
// 2. Recipient's device receives -> sends DELIVERED ack -> state = DELIVERED (two ticks)
// 3. Recipient opens conversation -> sends READ ack -> state = READ (blue ticks)

package com.bank.chat.service;

import java.util.List;

public class OfflineDeliveryService {

    private final MessageRepository repository;
    private final PushNotificationService pushService;

    public OfflineDeliveryService(MessageRepository repository,
                                   PushNotificationService pushService) {
        this.repository = repository;
        this.pushService = pushService;
    }

    public void handleOfflineUser(String userId, Message message) {
        // Send push notification
        pushService.sendPush(userId, "New message from " + message.getSenderId());
    }

    public List<Message> replayOnReconnect(String conversationId, long lastSeenSeq) {
        return repository.findAfterSequence(conversationId, lastSeenSeq);
    }
}

package com.bank.chat.pubsub;

public class RedisPubSubBridge {

    // Server B receives a message from Rajesh for Priya.
    // Priya's socket is on Server A.
    // Server B publishes to Redis channel "user:PRIYA"
    public void publish(String userId, String messageJson) {
        redisTemplate.convertAndSend("user:" + userId, messageJson);
    }

    // Server A subscribes to "user:PRIYA" and delivers to local socket
    public void onRedisMessage(String channel, String messageJson) {
        Session priyaSession = localSessions.get(extractUserId(channel));
        if (priyaSession != null) {
            priyaSession.getAsyncRemote().sendText(messageJson);
        }
    }
}

package com.bank.chat.service;

public class DeduplicationService {

    private final MessageRepository repository;

    public boolean isDuplicate(String clientMessageId) {
        return repository.existsByClientMessageId(clientMessageId);
    }

    // Client sends: {clientMessageId: "uuid-abc-123", text: "Hi"}
    // First time: save message, return OK
    // Retry (same clientMessageId): skip, return existing message
}