How to Design a Group Chat System
Design a scalable group chat system: message persistence, sequence numbers, fan-out strategies, and offline backfill.
Expected Interview Answer
A group chat system stores each group's membership and messages durably, fans out new messages to every online member's connection via a messaging service, and gives offline members a way to fetch missed messages on reconnect, all while keeping per-message fan-out cost bounded even for very large groups.
When a member sends a message, it is first persisted to a durable store (partitioned by group ID) and assigned a monotonically increasing sequence number within that group, which lets clients detect gaps and request backfill. The messaging service then fans the message out to every currently connected member by looking up their active WebSocket connections (often via a connection-routing layer since members can be on different servers), while offline members simply catch up by querying messages after their last-seen sequence number when they reconnect. For very large groups (thousands of members), naive fan-out-on-write becomes expensive, so systems often switch strategies above a member-count threshold: small groups get eager push fan-out, while huge groups (or channels) use a pull model where the message is written once and members pull recent messages themselves, trading immediacy for write efficiency. Read receipts and typing indicators are handled as lightweight, ephemeral, non-durable events layered on top of the same connection infrastructure.
- Sequence numbers per group let clients reliably detect and backfill missed messages
- Fan-out is decoupled from durability, so message delivery failures never lose data
- Switching between push and pull fan-out by group size keeps huge groups cost-effective
- Ephemeral signals (typing, read receipts) stay separate from durable message storage
AI Mentor Explanation
A group chat system is like a team's dressing-room announcement board where every message from the captain gets a numbered entry so no one misses one even if they stepped out briefly. The board keeper posts the message once to the durable log (persist), then runs to tell every player currently in the room (fan-out to online members), while players who were on the field simply read the numbered board when they return (offline backfill). For a huge fan club instead of a small squad, posting individually to thousands would be too slow, so the board is simply displayed centrally for anyone to check (pull model for large groups). That numbered-log-plus-fan-out design is exactly how a group chat system delivers messages reliably.
Step-by-Step Explanation
Step 1
Persist the message
A new group message is written durably with a monotonically increasing per-group sequence number.
Step 2
Fan out to online members
The messaging service looks up active connections for each member and pushes the message via WebSocket.
Step 3
Handle offline members via backfill
Offline members query messages after their last-seen sequence number when they reconnect.
Step 4
Switch strategy for very large groups
Above a member-count threshold, switch from eager push fan-out to a pull model to control write amplification.
What Interviewer Expects
- Separates durability (persisting the message) from delivery (fan-out to connections)
- Uses per-group sequence numbers to explain gap detection and backfill for offline members
- Discusses fan-out cost at scale and the push vs pull trade-off for huge groups
- Mentions ephemeral signals (typing, read receipts) as separate from durable message storage
Common Mistakes
- Treating group chat identically to 1:1 chat without addressing fan-out cost at large group sizes
- Not explaining how offline members catch up on missed messages
- Ignoring message ordering guarantees within a group
- Conflating durable message storage with ephemeral presence/typing signals
Best Answer (HR Friendly)
“A group chat system saves every message with an order number so nothing gets lost, then immediately pushes it to whoever is online in the group right now. If you were offline, the app just asks for everything after the last message you saw when you come back. For really huge groups, it may switch to a model where people pull recent messages instead of pushing to everyone individually, to keep things fast.”
Code Example
def send_group_message(group_id, sender_id, text):
seq = increment_sequence(group_id)
message = persist_message(group_id, seq, sender_id, text)
members = get_group_members(group_id)
if len(members) <= FANOUT_THRESHOLD:
for member_id in members:
conn = connection_registry.lookup(member_id)
if conn:
conn.push(message)
# offline members backfill later via last_seen_seq
else:
# large groups: skip eager push, members pull on demand
pass
return message
def backfill(group_id, member_last_seen_seq):
return get_messages_after(group_id, member_last_seen_seq)Follow-up Questions
- How would you guarantee message ordering when multiple servers handle fan-out for the same group?
- How would you design read receipts for a group of thousands without excessive write amplification?
- What happens if a member is added to a group mid-conversation — how far back can they read?
- How would you shard message storage for a platform with millions of active groups?
MCQ Practice
1. Why do group chat systems assign a monotonically increasing sequence number per group?
Sequence numbers give clients a reliable way to know what they have seen and request anything missing.
2. Why might a very large group switch from push fan-out to a pull model?
Pushing every message to every member of a huge group creates massive write amplification; pulling on demand controls that cost.
3. How do offline group members typically catch up on missed messages?
Sequence-number-based backfill lets a reconnecting client fetch exactly what it missed.
Flash Cards
Why use per-group sequence numbers? — To let clients detect gaps and reliably backfill missed messages.
Push vs pull fan-out? — Small groups get eager push to online members; huge groups switch to a pull model to limit write amplification.
How do offline members catch up? — They query messages after their last-seen sequence number when reconnecting.
Where do typing indicators and read receipts live? — As lightweight ephemeral events, separate from durable message storage.