Design a Real-time Chat Application

Problem Statement

Design a real-time chat application that allows users to send and receive messages instantly. The system should support one-to-one messaging as well as group chats while handling millions of concurrent users efficiently.

Asked In Companies

Meta Microsoft Google Amazon Atlassian LinkedIn Twitter Uber Salesforce Adobe Oracle PayPal Flipkart

---

Functional Requirements

• Users should be able to send and receive messages in real time
• Support one-to-one chat between users
• Support group chats with multiple participants
• Messages should be delivered only to active chat participants
• The system should maintain chat history
• Users should be able to join and leave group chats

---

Objects Required

• User
• Message
• Chat (abstract)
• PrivateChat
• GroupChat
• ChatService
• MessageStatus

---

MessageStatus Enum

public enum MessageStatus {
    SENT,
    DELIVERED,
    READ
}

This enum keeps track of the state of a message as it moves through the system. A message starts as sent and can later be delivered or read depending on user activity.

---

User Class

import java.util.*;

public class User {

    private String userId;
    private String name;
    private boolean isOnline;

    public User(String userId, String name) {
        this.userId = userId;
        this.name = name;
        this.isOnline = true;
    }

    public void goOffline() {
        isOnline = false;
    }

    public void goOnline() {
        isOnline = true;
    }

    public boolean isOnline() {
        return isOnline;
    }

    public String getName() {
        return name;
    }
}

The constructor initializes a user with a unique id and name, and by default the user is marked online.

The goOffline() method updates the user status when they disconnect from the chat system.

The goOnline() method brings the user back into active state so they can receive messages again.

The isOnline() method helps the system decide whether messages should be delivered instantly or stored for later.

---

Message Class

import java.time.LocalDateTime;

public class Message {

    private String messageId;
    private User sender;
    private String content;
    private LocalDateTime timestamp;
    private MessageStatus status;

    public Message(String messageId, User sender, String content) {
        this.messageId = messageId;
        this.sender = sender;
        this.content = content;
        this.timestamp = LocalDateTime.now();
        this.status = MessageStatus.SENT;
    }

    public void markDelivered() {
        status = MessageStatus.DELIVERED;
    }

    public void markRead() {
        status = MessageStatus.READ;
    }

    public String getContent() {
        return content;
    }
}

The constructor creates a message with sender information and captures the exact time it was created. Every message starts in SENT state.

The markDelivered() method updates the message when it reaches the receiver’s device. This helps track delivery status in real time.

The markRead() method is used when the receiver actually opens and reads the message. This is useful for read receipts.

The getContent() method allows other components to access message text without exposing internal fields directly.

---

Chat (Abstract Class)

import java.util.*;

public abstract class Chat {

    protected String chatId;
    protected List participants;
    protected List messages;

    public Chat(String chatId) {
        this.chatId = chatId;
        this.participants = new ArrayList<>();
        this.messages = new ArrayList<>();
    }

    public void addUser(User user) {
        participants.add(user);
    }

    public void removeUser(User user) {
        participants.remove(user);
    }

    public void addMessage(Message message) {
        messages.add(message);
    }

    public List getMessages() {
        return messages;
    }
}

The constructor sets up a new chat with empty participants and message history.

The addUser() method allows a user to join a chat, whether it is private or group-based.

The removeUser() method removes a participant when they leave the chat.

The addMessage() method stores messages in the chat history so that the conversation can be retrieved later.

The getMessages() method returns the full chat history for display or debugging purposes.

---

PrivateChat Class

public class PrivateChat extends Chat {

    public PrivateChat(String chatId) {
        super(chatId);
    }

    public void sendMessage(Message message) {
        addMessage(message);
    }
}

The constructor simply initializes a one-to-one chat using the base Chat class.

The sendMessage() method adds a message directly to the chat. Since this is a private chat, there is no extra routing logic involved.

---

GroupChat Class

public class GroupChat extends Chat {

    private String groupName;

    public GroupChat(String chatId, String groupName) {
        super(chatId);
        this.groupName = groupName;
    }

    public void sendMessage(Message message) {
        addMessage(message);
    }

    public String getGroupName() {
        return groupName;
    }
}

The constructor initializes a group chat with a name and chat id.

The sendMessage() method adds a message to the group conversation so that all participants can access it.

The getGroupName() method returns the name of the group for display purposes in UI or logs.

---

ChatService Class

import java.util.*;

public class ChatService {

    private List chats;

    public ChatService() {
        this.chats = new ArrayList<>();
    }

    public Chat createPrivateChat(User u1, User u2) {

        Chat chat = new PrivateChat(UUID.randomUUID().toString());

        chat.addUser(u1);
        chat.addUser(u2);

        chats.add(chat);

        return chat;
    }

    public GroupChat createGroupChat(String name, List users) {

        GroupChat group = new GroupChat(UUID.randomUUID().toString(), name);

        for (User user : users) {
            group.addUser(user);
        }

        chats.add(group);

        return group;
    }

    public void sendMessage(Chat chat, Message message) {
        chat.addMessage(message);
    }
}

The constructor initializes the system with an empty list of chats.

The createPrivateChat() method creates a one-to-one chat between two users and registers it inside the system.

The createGroupChat() method creates a group, adds all users, and stores it in the chat list so it can be tracked later.

The sendMessage() method routes a message into the correct chat. In a real system, this is where WebSocket or push notification logic would sit.

---

Main Class

import java.util.*;

public class Main {

    public static void main(String[] args) {

        User u1 = new User("U1", "Alice");
        User u2 = new User("U2", "Bob");
        User u3 = new User("U3", "Charlie");

        ChatService service = new ChatService();

        Chat privateChat = service.createPrivateChat(u1, u2);

        GroupChat groupChat = service.createGroupChat(
                "Dev Group",
                Arrays.asList(u1, u2, u3)
        );

        Message m1 = new Message("M1", u1, "Hey Bob!");

        service.sendMessage(privateChat, m1);

        Message m2 = new Message("M2", u2, "Hello everyone");

        service.sendMessage(groupChat, m2);

        System.out.println("Messages sent successfully");
    }
}

The main method simulates a simple flow where users are created and added into private and group chats.

Messages are then sent through the ChatService which handles routing into the correct chat instance.

This gives a basic but realistic view of how a chat system would behave at a high level.

---

Class Diagram

Also See

• Most Commonly Asked Low Level Design Interview Questions
• Top 10 Low Level Design Interview Questions