Back to Explore
GuideVibeFix editorialUpdated Nov 20, 2026

Stop Nagging Them One by One: Notification Digests That Get Opened

A digest is triage, not a backlog dump: what must go out now, what waits, grouping by subject, stripping what is already read, and a subject line that names the one thing worth opening — with a worked funnel.

A hand holding a phone showing an e-mail inbox, with a cup of coffee on the table (real photo)

One thing up front: this article is only about “notification digests” — the dozens of notifications a day produces are not thrown at the user one by one, but gathered by rule and sent once a day or once a week, so the user can read everything and deal with everything in one go. Notification preference settings (which notifications are on and which are off) are covered in the Notification Preferences guide; the onboarding email sequence is the Lifecycle Email Sequence guide’s territory; what the in-app notification center looks like is covered in the In-App Notification Center guide; how to write content emails is the Newsletter guide’s job. This one is only about the digest’s trade-offs: what goes into a digest, what must be sent immediately, how often to send, how to order it, and how to tell whether it works. The example product in this article, “Lighthouse Community” (a creator community app), and the people who appear in it, “Xiao Man” and “Lao Zhou”, are fictional examples used to make the points concrete — not a real product or real users.

Many vibe projects start their notification system the same way: “when something new happens, push one message.” When users are few and messages are few, that works fine. Once users grow, the problems arrive: Xiao Man follows twenty creators and gets fourteen pushes in one morning — three people liked her post, two replied to her comment, someone @-mentioned her in a group, and the system told her there were five new articles. Not one of the fourteen was fake, but after reading two she turned off notification permissions entirely, and the remaining twelve — along with every genuinely important message afterwards — could never reach her again. The problem isn’t notifications themselves; it’s that the builder equated “notification” with “interruption”. A notification is supposed to help the user miss nothing important. But when important and unimportant things arrive in the same way, at the same volume, the user’s only self-defence is to switch everything off. A digest exists to resolve that contradiction: important things are said at once, unimportant things are gathered and said once, so the user finds a place where they can stay long-term between “knowing” and “quiet”.

1. Split first: what must go out immediately, and what can wait for the digest

The first step of building a digest isn’t writing the digest email — it’s splitting notifications into streams. The only yardstick is: if the user learns about this a few hours late, will they suffer a real loss? If yes, send it immediately; if no, it goes into the digest. The immediate list is actually short: someone @-mentioned you, someone sent you a private message, a security alert on your account, an order status change, a failed payment. If these arrive hours late, the user misses a conversation, misses the window to act, or loses money outright. The digest list is long: who liked you, who followed you, new posts from people you follow, new discussions in a group, new features. Learning about these a few hours late changes nothing — the user just sees them a little later.

Write the split down, and write it into the product — not just into the builder’s head. The way to do it is to tag every notification type with an urgency level: immediate, digest, or silent. Immediate ones go out at once, digest ones go into the digest pool, silent ones only appear in the in-app notification center and never enter a digest at all. Lao Zhou is an admin at Lighthouse Community. He tagged “someone reported content” as immediate, “your post was liked” as digest, and “system changelog” as silent. Once the three categories were clear, the fourteen pushes in the morning became three immediate messages plus one digest, and user complaints halved within a week. Once the splitting rules are set, every time a new notification type is added, ask first “which category does it belong to” — don’t default to sending everything immediately. Defaulting to immediate is the easiest approach, and the fastest way to drive users away.

One grey area needs separate handling: things the user has explicitly said they want to know at once. If Xiao Man is waiting for a reply from a collaborator and sets “private messages” to immediate, that’s fine. But if she also sets “likes” to immediate, that is her own choice, and the system should respect it. The split rules are defaults; the user’s preference settings can override them. Who wins, rules or preferences? Preferences. The digest system is only responsible for giving notifications the user hasn’t spoken about a sensible default destination — not for deciding on their behalf what matters.

2. The digest window: once a day, or once a week

How often a digest goes out is the second number to fix. The two most common choices are daily and weekly, and which one fits depends on the content’s “shelf life”. Community activity, likes, and replies have a shelf life measured in days: a discussion from today feels half cold tomorrow, so once a day fits. Industry news, creator weeklies, and data summaries have a shelf life measured in weeks: you need a whole week to gather enough for a substantial email, so once a week fits. Don’t do both — one daily email plus one weekly email means more than thirty digests a month, and the digest itself becomes new noise.

For a daily digest, when it is sent matters more than how often. Send it at 8am and the user flips through it on the commute; send it at noon and they scan it over lunch; send it at 9pm and they have time to read it slowly. Which moment to pick depends on when your users are free — not on when your scheduled job is convenient to run. And mind time zones: a user in Beijing gets the digest at 8am Beijing time; if they move to Tokyo, the digest moves to 8am Tokyo time. Store the digest time in the user’s own time zone — don’t apply server time across the board. Lighthouse Community first sent its digest at 3am server time. Users woke up to an email that had arrived in the middle of the night, and the open rate was only 9%. After switching to 8am in each user’s time zone, the open rate rose to 31%. The same email — only the send time changed.

For a weekly digest, which weekday matters too. Send it on Monday and users have just started work and don’t feel like reading community updates; send it on Friday and they are thinking about the weekend and swipe it away; send it on Wednesday or Thursday and their work has found its rhythm, so they actually have time to flip through it. That is experience, not a law: the best approach is to send for four weeks, trying Tuesday, Wednesday, Thursday, and Friday, see which day opens best, and then fix it. A digest’s send time isn’t decided by gut feel — it’s found by testing.

3. What goes inside: group by subject, don’t list by time

The most common flaw in a digest is writing it as a running log: “10:02 someone liked your post, 10:15 someone replied to your comment, 10:31 someone followed you…” The user closes it after three lines. A digest is not a courier for notifications — it has to aggregate: combine notifications about the same thing into one line. Five people liked the same post? The digest says one line: “Lao Zhou and 4 others liked your ‘Beginner’s Village Guide’” — not five lines of like records. One person replied to you three times? The digest says one line: “Xiao Man replied to you 3 times under ‘Beginner’s Village Guide’” — not three repeated lines. After aggregating, a digest usually has five to eight lines, each one a “thing”, not a “blip”.

After aggregating, order matters: the important stuff goes first. The order isn’t by time — it’s by how close the relationship is and how weighty the action is. Direct @-mentions and replies to you go before likes and follows; new posts from people you follow go before activity from strangers; new replies in discussions you’ve joined go before discussions you haven’t. The ordering rules don’t need to be written in the digest, but the user can feel them: the first thing they see when they open it is the two or three lines they most likely care about. If the first glance shows nothing they care about, they won’t open it a second time.

Every line in a digest also needs a clear action. The like line: one tap jumps to the liked post. The reply line: one tap jumps to the reply — ideally scrolled straight to that reply. The follow line: one tap jumps to that person’s profile. Don’t make the user tap into the digest and then hunt around on their own. Every line should be a “door” — recognisable at a glance, open with one tap. What’s behind the door doesn’t matter; what matters is that the door is easy to spot and easy to push open.

4. Filter before sending: never send what the user already knows

The easiest mistake a digest can make is re-sending something the user has already dealt with. Xiao Man already read that reply in the app in the morning and answered it — if the evening digest says “Xiao Man replied to you” again, she’ll conclude the digest is blind. The right approach: at the moment the digest is generated, strip out anything in the pool the user has already read or handled. The rule is simple: notifications the user has opened, replied to, or liked in the app don’t go into the digest; likes and replies on a post the user has already opened don’t go in either. A digest only covers “things the user hasn’t seen yet” — that is the digest’s bottom line.

Filtering has a subtler version too: don’t split an ongoing conversation. Two people have gone back and forth for ten messages — the digest should carry only the latest one, with a note like “you’ve exchanged 10 messages”, and one tap jumps into the conversation. Splitting ten messages into ten digest lines means the user reads the first line, realises the next nine are the same conversation, and taps none of them. The unit of a digest is “conversations” and “events”, not “message count”.

If the digest is empty after filtering, don’t send it. An empty digest damages open rates more than anything: a user opens a “no new activity today” email, and the next time they see your digest subject line, their first thought is “there’s nothing worth reading anyway”. Not sending when there’s nothing beats sending an empty email. Users won’t forget you because you sent one fewer email; they will stop opening your emails because you sent one useless one.

5. Subject lines and counts: a digest’s open rate comes down to these two things

A digest’s subject line can’t be a platitude like “Your daily digest”. It has to tell the user the single most worthwhile thing inside. “Lao Zhou replied to your post, plus 4 more updates” tells the user at a glance whether there’s something in this email they want. There’s a simple formula: the single most important item, plus a total. Don’t cram three items into the subject to make it look busy — the more the subject holds, the less the user knows what the email is actually about.

Subject lines are worth testing on their own. Split one batch of users into two groups: one gets “Lao Zhou replied to your post, plus 4 more updates”, the other gets “Your daily digest”, and see which group opens more. Test for two weeks, keep whichever wins, then try a new wording every month or two. There is no forever version of a subject line — users’ tastes change, and the community’s content changes, so the wording has to change with them. When testing subject lines, change one variable at a time: either the wording or the send time, never both together — otherwise, when the open rate moves, you won’t know which change did it.

Counts need a cap too. Five to eight lines per digest feels best; past ten, users give up halfway. What if there’s more than the cap? Two options: cut by importance, send only the top eight, and add a line saying “12 more updates — see them in the app”; or split into two emails, one “about you” and one “new from people you follow”. Either works — but don’t cram a dozen-plus lines into one email. A digest exists to save the user time, not to lay out the day’s messages in a different place.

Last is unsubscribing. The bottom of a digest email must have an unsubscribe link that works with one tap — no login, no second confirmation. Unsubscribing from the digest is not unsubscribing from all notifications: the user who drops the daily digest still gets immediate notifications; if they want total quiet, they go to preference settings. The smoother the unsubscribe path, the less likely a user is to shut off all notification permissions because of one annoying digest. Leave a small exit, and users won’t brick up the whole door.

6. The funnel: a thousand notifications — how many actually get used

The numbers below are a fictional sample, used to lay out the losses along the notification-digest chain: suppose Lighthouse Community generates 1,000 notification events in a day. Of them, 780 enter the digest candidate pool (78%; the other 220 are @-mentions, private messages, and security alerts that must go out immediately), 610 are included in that period’s digest (78.2% of the candidates, 61% of the total; the 170 removed are ones the user has already read or handled), 470 are opened by the user inside the digest (77.0% of those included, 47% of the total), and 310 lead the user to actually do something after opening — reply, like, or tap into a post to keep reading (66.0% of those opened, 31% of the total). Walking the whole chain, only 310 of 1,000 notifications actually turn into user action. Every step’s loss can be counted: 220 go out immediately and never enter the digest, 170 are removed because they were already read or handled, 140 are included in the digest but never opened (610−470), and 160 are opened but lead to no action (470−310). The biggest leaks are in the last two steps: never opened plus opened-but-no-action add up to 300 — 43.5% of all 690 losses. So once the digest is built, don’t rush to tune the splitting rules first — look at the digest itself: does the subject line name the single most worthwhile thing, do the first eight lines hold something the user genuinely cares about, and does one tap take them straight there? The first two lines of a digest decide whether the user opens it; the first screen after opening decides whether they act.

Notification digest funnel: 1,000 notification events, 310 turn into user action

7. Before launch, walk through this checklist

First, every notification type has an urgency tag — immediate, digest, or silent — and new notifications default to the digest, never to immediate. Second, the digest has only one frequency: once a day or once a week, never both. Third, the send time lives in the user’s own time zone, at 8am local time. Fourth, the digest aggregates by subject: five people liking the same post is one line. Fifth, at the moment the digest is generated, already-read and already-handled items are stripped out, and an empty digest is never sent. Sixth, one digest has five to eight lines, and the subject line names the most important item plus a total. Seventh, every line is one tap away from its destination, and unsubscribing takes one tap. Eighth, check the numbers every week: candidate rate, inclusion rate, open rate, and action rate. If any one of them drops, look at the digest’s subject line and first eight lines first — not at the send frequency. Ninth, in the first month after launch, pull ten real users’ digests every week and check whether any of them contain something already read, an empty digest, or a dead link — the open rate a machine calculates can lie, but the email in a user’s hands cannot. A digest has no magic. It is won in the unglamorous trade-offs: which line goes out at once, which one waits, which one is never written at all. Get those trade-offs right, and the user gets one email a day yet feels they missed nothing — and “missed nothing, without feeling nagged” is what getting a digest right looks like.

Views 5Comments 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