Back to Explore
GuideVibeFix editorialUpdated Nov 11, 2026

Don't Build a Second WhatsApp: In-App Messaging for Vibe Projects

In-app messaging is not a notification center. This guide covers four message types and their retention periods, the conversation list, optimistic sending, three lines of defense against harassment, read receipts and recall rules, group chats, and support conversations.

Two hands holding a phone showing a chat conversation with an emoji keyboard

Start with a very specific scene. A-Ye built an interest community called Hive Community — the product and person in this guide are fictional. In the first week after the in-app messaging feature launched, he got three kinds of feedback, and each one gave him a headache. The first: "I sent a private message to an author I like, got no reply for three days, and assumed they had blocked me." The second: "System notifications, transaction reminders, and private messages from strangers are all mixed into one list, and the important transaction reminder got buried." The third: "I just registered and got a dozen harassing private messages asking 'want to add me on WeChat?'"

A-Ye checked the code: not a single message was lost, and sending, receiving, and storage all worked. The problem was not technical, it was product design. In-app messaging is not done by moving a chat box into your product. Users cannot tell which message matters, do not know whether the other person has actually seen it, and have no way to deal with harassment. When in-app messaging is done badly, user trust in the product drops faster than from any feature bug.

Two hands holding a phone showing a chat conversation with an emoji keyboard

1. First, separate them: in-app messaging is not a notification center

In-app messaging and the notification center look alike — both are a little bell or envelope with a red dot — but they are two different things. The notification center is one-way broadcast: the system tells you something, you read it, and that is the end of it; there is nothing to reply to. In-app messaging is two-way conversation: someone is waiting for your reply, and a late reply, a wrong reply, or no reply is felt by a real person on the other end.

This guide only covers the two-way conversation part: how messages are categorized, what the conversation list looks like, what happens when sending fails, how harassment is stopped, how recall and deletion are decided, and how support conversations are handled. How one-way notifications are written is covered by the notification system guide on this site; how notification emails are written is covered by the email templates guide in this same batch; and support workflow automation itself is covered by the customer support automation guide. This guide assumes your message delivery pipeline already works, and solves what comes after: can users tell what is urgent, speak without worry, and do something when harassed?

The test for whether in-app messaging is done well is equally direct: open the message list — can the user find, within ten seconds, the one message that most needs a reply right now? If not, the list has failed, no matter how high the delivery rate is.

2. Define four message types first, and stop stuffing them into one list

The first cut in in-app messaging is categorization. Every message falls into four types, each with different rules, and mixing them together is exactly what produced A-Ye's second kind of complaint.

The first type is system notifications: someone you follow posted something new, your post was liked, an event is starting. These are read-only and cannot be replied to, and they are kept for 90 days, then auto-deleted. Do not put a reply box in the system notification list — if you do, users will talk to the system, their messages will vanish into the void, and the experience is worse than having no reply box at all.

The second type is transaction reminders: order confirmed, payment succeeded, refund arrived, item shipped. These are also read-only, but kept for 365 days — users treat them as receipts for reconciliation, and deleting them early creates support tickets. Transaction reminders get their own entry, separate from system notifications; when users look for a receipt, they do not want to dig through a hundred like-notifications.

The third type is user private messages: one-to-one conversations between users. This is the only genuinely two-way type, kept for 730 days, giving users plenty of time to look back. Read receipts are not shown to strangers by default — only between people who follow each other. That detail comes up again later.

The fourth type is support conversations: questions users raise with support. Kept for 180 days; once a ticket is closed, the conversation is archived — users can still read it but cannot keep sending messages, and must open a new conversation to ask more. The support entry must live somewhere permanent, not buried three menus deep; when users have a problem, they have no patience to hunt for the way in.

These four numbers — 90, 365, 730, 180 — belong in your product's data retention spec. They are not guesses: 90 days is enough for system notifications, any longer is clutter; 365 days covers a full year of reconciliation; 730 days gives private messages two full years; 180 days covers the trace-back window of almost every after-sales dispute.

Retention periods for four in-app message types: system notifications 90 days, transaction reminders 365 days, user private messages 730 days, support conversations 180 days

3. What the conversation list should look like: find the most urgent reply in ten seconds

The conversation list is the face of in-app messaging, and how it looks decides how often users open it each day. Four rules.

The first rule is sorting: newest message first, unread on top, read sinking down. Do not sort by "importance" — importance is the algorithm's guess, time is something users understand on their own. Pinning should exist, but each person may pin at most 3 conversations; pin too many and pinning means nothing.

The second rule is unread counts: each conversation shows its unread count, and anything over 99 shows as 99+. Do not show a real three-digit number — a user who sees "999 unread" will only feel anxious, not open them one by one. Opening a conversation marks everything in it as read; do not make users tap away red dots one message at a time.

The third rule is previews: each conversation shows the first 30 characters of its latest message. Thirty characters are enough to judge "should I reply to this now", without leaking too much content onto the list page. Previews for system notifications and transaction reminders show only the title, never the body — amounts and order numbers should not lie around on the list page.

The fourth rule is status: every message has three states — sent, delivered, read. Read receipts are shown only between people who follow each other, never to strangers. This protects the person receiving the message: they have the right to read something and not reply, without being chased with "you clearly read it, why no reply?" It looks like a small detail, but it is the most important piece of etiquette in in-app messaging.

The fifth rule is search: put a search box at the top of the conversation list, searchable by the other person's name and by message content. Once messages pile up, nobody finds a private message from three months ago by scrolling — only search works. Show results newest first, with the keywords highlighted, so users can land on the exact message at a glance. Do not hide the search box inside a filter menu; it is one of the most-used features in the conversation list and deserves a permanent spot.

4. The sending pipeline: show it first, confirm it later, and let failures be retried

What happens after the user taps send decides the first impression of in-app messaging. Done right, users feel it is "fast"; done wrong, they feel it is "stuck" or "lost".

The right approach is optimistic updates: the moment send is tapped, the message appears in your own dialog immediately, with feedback within 100 milliseconds. Do not wait for the server to respond before showing it — on a weak connection, users stare at a spinning send button for two seconds, then tap again, and two identical messages go out. After the optimistic display, sync in the background: on success, change the state to "delivered"; on failure, hang a "Send failed, tap to retry" button under the message, keeping the original text above the input box so the user does not have to type it again.

Offline writing must work too. In a subway with no signal, users should still be able to type and tap send; messages queue locally and go out automatically when the connection returns, with a light hint once sent. Do not pop up "Send failed" when there is no network — users cannot tell whether the network is down or the product is broken.

One rule that is easy to miss: the same message is stored only once. Client retries, network jitter, and double taps can all send the same message twice. The fix is a unique ID on every message, with the server deduplicating by ID — a retry with the same ID simply returns the stored message instead of storing another copy. Deduplication is the server's job; do not count on the client never slipping.

Message editing needs rules too: a message can be edited within 5 minutes of sending, and an edited message is marked "Edited" so the other side can see the trace. Five minutes is a window for typos, not for changing your story — editing half an hour later, after the other person has already understood the original, only manufactures misunderstanding. Editing without a trace is worse than not allowing edits at all: users lose track of what they actually said.

5. Three lines of defense against harassment: build them before the complaints arrive

Once private messaging exists, harassment is certain. A-Ye's third kind of complaint was not bad luck; it is what every product with private messages runs into. The defenses must be built before the complaints, and there are three of them.

The first line is a quantity limit: a newly registered account may send at most 10 private messages within 24 hours, and no more than 3 of them to people they do not follow. The numbers do not need to be precise — the point is that mass-messaging strangers from a fresh account should be expensive and unrewarding. A normal user cannot send 10 private messages on their first day anyway, so this limit only blocks bulk harassers.

The second line is stranger isolation: the first private message from a stranger does not go straight into the conversation list — it folds into "Message requests", and the sender can only continue after being accepted. Message requests show no read receipts and no online status; before acceptance, the sender cannot tell whether you have seen it. This one defense blocks more harassment than any keyword filter.

The third line is reporting and blocking: every private message needs a report entry next to it, reports must be handled by a human within 24 hours, and the outcome must be told to the reporter. Blocking must take effect immediately, and it must be mutual invisibility: after blocking, the other person cannot see your profile or send you messages, and you cannot see them either. Blocking is not one-sided hiding; it is two people's worlds disconnecting from each other. Many products implement blocking as "you cannot see them, but they can still message you" — that is no blocking at all.

Beyond the three lines, there is one baseline: never let AI decide "this is harassment" and delete the message on its own. AI can only triage — fold the suspicious ones aside and flag them for human review. It must not be the final judge. Deleting one normal message by mistake hurts far more than missing one harassing message.

6. Read receipts, recall, and deletion: write the rules down, leave no grey areas

The easiest place for arguments in in-app messaging is read receipts, recall, and deletion. The rules must be written down — in the help center and in the product's behavior, both saying the same thing.

Read receipts: shown between people who follow each other, never shown to strangers; users can turn off their own read receipts in settings with one switch, and after turning them off they cannot see others' read receipts either. It is a fair exchange: if you do not show others your read status, others do not show you theirs. Write this rule into the settings page copy; do not leave users guessing.

Recall: a message can be recalled within 2 minutes; after recall, the other side sees "The other person recalled a message", without the original text. After 2 minutes, recall is gone — the only option is deleting your own copy. The 2-minute window is for slips of the finger, not for changing your mind: recalling half an hour later, when the other person has long since read it, is self-deception.

Deletion: deleting removes only your own copy; the other side keeps theirs. The only way to remove both sides is recall. The "typing..." indicator disappears after 5 seconds without new input — do not leave "the other person is typing" hanging there, it only makes the waiting person more anxious.

All three rules share one idea: leave users no room to guess "did they see it, did they delete it?" Guessing is the source of all anxiety in in-app messaging; write the rules down, and half the anxiety goes away.

7. Support conversations: one automatic reply first, then talk about humans

Support conversations are the most special type in in-app messaging: users are not here to chat, they are here to solve a problem. The experience standard is completely different from private messages: users do not care how pretty the interface is, only how long until someone answers.

The first rule is a first-response target: a human must reply within 4 working hours. Note "a human replies", not "the problem is solved". A "received, looking into it" within 4 hours lets users wait in peace; 4 hours of silence sends them elsewhere to complain in public. An automatic reply should come first, but it must not pretend to be human: write clearly "This is an automatic reply; support will respond within 4 working hours." Do not write a human-sounding "Hi, how can I help?" — when users discover the other side is a bot, trust drops even faster.

The second rule is a permanent "talk to a human" button. When the bot cannot answer, users must reach a human in one tap — not after five rounds with the bot. When the handoff happens, carry the conversation history along; do not make users repeat the problem. Repeating is the most patience-draining thing there is.

The third rule is to confirm before closing. Do not close a ticket the moment the problem is solved — ask first, "Is this resolved for you?" and close only when the user says yes; if the user does not reply for 48 hours, close it automatically. After closing, offer one rating question, just one: "Did this service help you?" One question is enough — the longer the survey, the fewer people fill it in.

8. Group chats: cap the headcount first, rules before features

Group chat comes only after private messages are solid. A group chat is not "private messages with more people" — it has its own troubles: the more people, the faster messages scroll; the faster they scroll, the more people leave; the more people leave, the faster the group dies. The first rule of group chat is a headcount cap: at most 200 people per group. In a group over 200, the message list is unreadable and no admin can keep up. Needs beyond 200 people should be solved with channels or announcements, not forced into a group chat.

The second rule is to appoint admins when the group is created. Every group needs at least 1 admin, and admins can do exactly three things: remove people, mute people, and edit the group announcement. Do not give admins more power than that — too much power turns a group into a one-person show. Admin actions must leave a record, visible to members: who removed whom, and when. Transparency is what makes authority acceptable.

The third rule is that newcomers cannot see message history — or at most the latest 50 messages. A newcomer who walks into three months of chat history is a privacy problem and a useless experience alike. Fifty recent messages are enough to understand what the group is talking about; more is a burden.

The fourth rule is that @everyone may be used at most once per day. @everyone is the most disruptive feature there is; a group @-ed twice a day starts losing members immediately. This limit must live in the product, not in group rules that rely on goodwill — goodwill is the least reliable defense there is.

The fifth rule is that only 1 announcement may be pinned. The announcement is the face of the group, and there can be only one — more, and nobody reads any of them. An announcement says three things only: what the group is for, what the rules are, and who to contact with problems. When the announcement changes, one light reminder in the group is enough; do not @everyone.

One more easily missed point about group chat: leaving must be quiet. When a user leaves, do not broadcast "So-and-so left the group" to everyone — that only embarrasses the person leaving and makes the rest overthink it. Leaving is leaving; it does not need an announcement to the whole group.

9. Pre-launch checklist

Ten minutes before launch, run through this list: are the four message types separated; are the retention periods 90, 365, 730, and 180 days; is the pin limit 3; do unread counts over 99 show as 99+; do strangers' private messages go into message requests first; is the new-account limit 10 private messages in 24 hours; is someone handling reports within 24 hours; is blocking mutually invisible; is the recall window 2 minutes; can read receipts be turned off with one switch; is there a retry button when sending fails; do offline messages queue; is the support first-response target 4 working hours; is the talk-to-a-human button permanent; and do you ask the user before closing a ticket?

Anti-patterns to fix on sight: all messages mixed into one list; unread counts showing 999; strangers' private messages landing straight in the list with read receipts; waiting for the server before showing a sent message; making users retype after a failed send; blocking that still lets the other person message you; recall with no time limit; bots pretending to be human; tickets closed without asking the user; a support entry buried three menus deep.

One honest note to close: in-app messaging is the most underestimated feature in a vibe project, and the one that most tests product judgment. Anyone can build a chat box; the hard parts are the categories, the harassment defenses, and the hard-written rules on read receipts and recall — not one of them is difficult code, but every one of them answers the same question: how do you want users to treat each other here? Once that question is answered clearly, in-app messaging is done. Merely moving a chat box in builds an empty room; whether anyone lives in it depends on whether the rules hold up.

Views 4Comments 0

Comments (0)

ME
0/1000
Loading comments...
Browse projectsPublish your project

Related articles

Real photo: a laptop, tablet, and phone on a wooden table showing the same green-leaf website, the phone view with navigation in one column, a potted plant nearby
Guide
Squashed on phones? Responsive layout and media queries, explained plainly

One page should stand up on a phone, a tablet, and a computer. This guide follows MDN's Responsive web design, Using media queries, and the viewport meta reference: fluid HTML, the viewport tag, fluid grids and max-width, images that never burst their container, media query syntax, breakpoints set by content, mobile first, responsive type, testing capability instead of width, and a pre-launch checklist.

Mobile AppsDesign ExperienceFrontend Engineering
Real photo: a bank of light gray metal filing cabinets with one drawer pulled open, revealing rows of hanging file folders inside
Guide
A real database inside the browser: IndexedDB local storage, explained plainly

localStorage only stores strings and has no indexes. IndexedDB is a real database in the browser: structured data, far larger capacity, indexes, and transactions. Following MDN's Using IndexedDB, IDBDatabase, and IDBObjectStore: the five-step routine, opening, upgrades, keys, indexes, transactions, add versus put, get, cursors, ranges, and multi-tab upgrades.

Tool TipsData WorkflowsFrontend Engineering
Real photo: hands typing on a MacBook Pro showing JavaScript code that changes HTML content, with a white mouse, papers, and binders on a white desk
Guide
Functions without the confusion: JavaScript functions, parameters, and arrow functions, explained plainly

You already call functions every day; this guide names what you have been doing. Following MDN's Functions, Arrow function expressions, and Rest parameters: declarations versus expressions, parameters and arguments, default values, rest parameters, spread syntax, return values, arrow function shorthand, the this trap, callbacks, and scope.

Tool TipsFrontend EngineeringAI Coding