TL;DR: Push notifications are the one channel that can pull a user back into your app without them choosing to open it, which is exactly why most small apps burn it in the first week. My rules: ask for permission after the user has seen value, not on the first screen; send only notifications that are triggered by something the user did or cares about; give every type its own on/off switch; cap the volume per user per day on the server; deep link every notification to the exact screen it talks about; and measure opens and opt-outs per notification type, not in total. A notification the user did not want costs you more than the open it earns, because the next tap is "turn off notifications".
I have shipped push on several mobile apps: LectureNotes AI, the note-taking app I co-founded, Lifemaxxing AI, a self-improvement app built around plans and tracking, and the mobile apps I lead at RAQTS, where live leaderboards make "something just changed" a real event. The stack differed each time, but the mistakes founders want to make with push are always the same. This post is the checklist I now use before a single notification goes out.
Why push is a different channel
Email can be ignored at leisure. An in-app message only reaches people who already opened the app. A push notification lands on the lock screen, next to messages from friends and family. That is its power and its risk.
Two things follow from that:
- Permission is scarce. On iOS you get one system prompt. If the user taps "Don't Allow", the only way back is a trip into Settings that almost nobody makes. On Android 13 and later, notifications are also opt-in through a runtime permission. You are spending a one-time asset.
- The cost of a bad notification is permanent. A user who gets three pointless pings does not just ignore the fourth. They turn notifications off for your app, and sometimes they delete it.
So the question is never "what can we send?". It is "what would this user be glad we told them?".
Ask for permission after value, not on launch
The most common mistake I see is the system permission prompt firing on the very first screen, before the user knows what the app does. They have no reason to say yes, so many say no, and that answer is close to final.
What I do instead:
- Wait for a moment that makes the value obvious. On a note-taking app, that is right after the first summary is ready: "Want a notification when your next set of notes is done?" On a sports app, it is after a first session lands on the leaderboard: "Get told when someone passes your score?" On a plan-and-tracking app, it is when the user sets up their first plan and picks a reminder time.
- Show your own pre-prompt first. A simple in-app screen that explains what you will send, with "Yes, notify me" and "Not now". Only "Yes" triggers the real system prompt. "Not now" costs you nothing, and you can ask again later at a better moment. This one change protects the scarce system prompt from impatient taps.
If you are building with React Native, Flutter or native code, the mechanics are similar. I covered the trade-offs between those stacks in React Native vs Flutter vs native for a startup app, but the permission strategy matters more than the framework.
The only notifications worth sending
I sort every proposed notification into one of four buckets. Only the first three get built.
1. Transactional: something the user started has finished
"Your lecture notes are ready." "Your plan for this week has been generated." "Your booking is confirmed." These are the best notifications you will ever send, because the user is waiting for them. On AI products where processing takes a minute or more, they are close to mandatory: nobody wants to stare at a spinner while a long recording is transcribed and summarized.
2. Reminders the user asked for
"Time for your evening check-in." "Your session starts in 30 minutes." The user chose the time and the topic. Let them change both easily, and respect their time zone, which means storing it on the user record, not guessing from the server clock.
3. Real events about things they care about
"Someone just passed your score on the leaderboard." "Your teammate commented on your session." These need a genuine trigger and a reason the user cares. On the live leaderboard work at RAQTS, the difference between a useful rank-change notification and spam is mostly about thresholds: notify when you drop out of the top three, not every time any rank shifts.
4. Marketing pushes (usually no)
"We miss you!" "Check out our new feature!" "Big sale this weekend!" These are the notifications that make people switch push off. For most small apps I leave this bucket empty, or allow at most a rare product announcement, sent to people who opted into that type specifically. If you want to reach lapsed users, email is a cheaper and less damaging channel.
Build it on the server, not in the app
A push system is mostly backend work. The app registers a device token and handles taps. Everything else belongs on the server:
- A token table, not a token field. One user can have a phone and a tablet, or reinstall and get a new token. Store tokens per device, with platform and last-seen date, and delete the ones the push service reports as invalid. Sending to dead tokens quietly inflates your "sent" numbers and hides real delivery problems.
- One send function. Every notification goes through a single function that checks the user's preferences, quiet hours and daily cap before anything leaves. If marketing, reminders and transactional code each call Firebase Cloud Messaging or APNs directly, you will eventually break all three rules at once.
- A daily cap per user. I usually set a hard cap on non-transactional notifications per user per day, enforced in that send function. Transactional ones the user is waiting for can bypass it.
- Quiet hours by local time. No reminders or event pings overnight in the user's own time zone. Queue them for the morning or drop them if they are stale by then. A leaderboard change from eight hours ago is not news.
- Deduplicate and collapse. If five people pass a user's score in ten minutes, send one notification, not five. Use collapse keys or a short delay window so the latest state wins.
- Log every send. User, type, payload, time, result. When someone says "your app spammed me at 3am", you want to answer in a minute, not guess.
The same discipline applies to secrets: the APNs key and service account for FCM belong in the server's secret store, never in the app bundle. I wrote about that in API keys and secrets on client projects.
Deep link every notification
A notification that opens the home screen is half a notification. "Your notes are ready" should open those notes. "You dropped to fourth" should open the leaderboard, scrolled to the user's row.
Things that make deep links work:
- Every notification carries a route and the IDs it needs in its data payload, not just a title and body.
- Handle all three app states: app in the foreground, in the background, and fully closed (cold start). The cold-start path is the one that breaks most often, because the navigation stack is not ready yet when the tap arrives.
- Handle missing data gracefully. If the note was deleted or the user is logged out, land on a sensible screen with a message, never a crash or a blank page.
- Test on real devices, on both platforms, from a killed app. Simulators and emulators lie about push more than about almost anything else.
When an old app version receives a notification type it does not know, it should fall back to a safe default screen. If you support older builds in the wild, the same thinking from keeping old mobile app versions working applies to notification payloads: add fields, never repurpose existing ones.
Give users real controls
A single "Notifications on/off" toggle forces an all-or-nothing choice, and when one type annoys them, users pick "nothing". A settings screen with one toggle per type (results ready, reminders, leaderboard changes, product news) lets them turn off only the annoying one.
Two more details that pay off:
- Reminder time and frequency in the same screen as the toggle, so adjusting is easier than disabling.
- Sync preferences from the server, so a user who turns something off on their phone does not keep getting it on their tablet.
Measure per type, not in total
"Our push open rate is 6%" tells you nothing useful. What I track, using the same event approach as in product analytics for a small app:
- Permission grant rate, split by where the prompt was shown. This tells you if your pre-prompt timing works.
- Sent, delivered and opened, per notification type. Transactional types should have much higher open rates than everything else. If one type is far below its siblings, it is probably not wanted.
- Opt-outs per type, and app-level notification disables after each type is sent. A type that drives disables is costing you the whole channel.
- Downstream action: did the user who opened "your notes are ready" actually read the notes, or did the reminder lead to a completed check-in? Opens are a proxy. The action is the point.
Review these on a schedule and delete the types that do not earn their place. A small app with three well-tuned notification types beats one with fifteen.
The checklist I use before launch
Before push goes live on an app I am building, I check:
- The system prompt fires only after a value moment, behind an in-app pre-prompt.
- Every notification type is transactional, user-requested or a real event. No filler.
- All sends go through one server function with preferences, a daily cap and quiet hours.
- Tokens are stored per device and cleaned up when invalid.
- Every notification deep links correctly from foreground, background and cold start, on real iOS and Android devices.
- Users can switch off each type separately, and the setting syncs across devices.
- Sends are logged, and opens and opt-outs are measured per type.
- There is a way to stop a notification type instantly without a release. A feature flag or kill switch on each type has saved more than one launch from a bad template going to everyone.
None of this is hard engineering. It is mostly saying no to notifications that serve the business more than the user.
I build mobile apps, AI products and the backends behind them for startups in the US, UK and Europe, including notification systems people actually leave switched on. If you are planning push for a new app, or your current notifications are driving opt-outs instead of opens, read more about my background or book a call.