After having sent well over 1 billion push notifications for a number of apps we have learnt quite a bit about push notifications best practices, and tried a lot of different experiments. This blog post exists to help memorialize some of the learnings and help those just getting started, and should be helpful for both developers and mobile marketers!
Push notifications are a crucial tool for maintaining user engagement and driving business outcomes. Anyone who has developed an app or marketed for an app will know that the push deviverabilty rate is not 100% or anywhere near it. One study* from 2019 mentioned that opt-in rates for Android devices were around 91%, and for iOS, it was 44%. The click through rate (CTR) - the rate where users tap or click on the notification - was around 4% on Android, and 2% on iOS. The study found the overall push notification reaction rate was 8% (which includes dismissing the push).
The stats we should care about are, 1) the delivery rate, 2) the click through rate, the 3) reaction rate (if we can measure it) and the 4) opt in rate. Since the delivery of a push impacts all downstream actions, increasing the delivery rate will have a positive effect on CTR and other reactions.
We break down some of our learnings below:
We've found that notifications have consistently lower delivery rates (30-50% lower) when sent to users outside of their normal active hours. Sending push notifications when users are active is essential for maximizing engagement. In fact even if a push is delivered to a user when they are inactive, do not disturb mode and other user preferences result in a click through rate that is lower than any push sent at a time the user is active. Thus one of the easiest and best ways to increase push deliverability, and click through rate is to simply have the push notifications sent when a user is active.
To do so is not simple. If you have large user base you cannot send notifications individually you need a way to send notifications, that is aware of a user's timezone, and when a user is typically using their phone.
To do this, you need to
- Track Timezones: Ensure notifications are sent at appropriate times for users in different time zones.
- User Activity Monitoring: Utilize a system that sends events when users are most active within the app so you know when to send push.
In Laudspeaker you can do both of these things by using our sdk, which tracks user timezone's out of the box, and then you can create a journey with a time window to send users' messages during their timezone, and / or when they trigger specific events like this:
Not all notifications are received by users, even after delivery attempts. To address this, you need a way to measure if a notification was delivered, if it was opened etc. This code is typically handled in ios in the app delegate (where there are specific handlers needed for different cases) and in the onMesageReceived function in android that tracks what happens when a notification is delivered.
Laudspeaker's SDK provides methods that can be used in these cases to track delivery, and opens. Once you have this base information you can develop fall back options, for example if a push is not registered on a users phone x seconds after it is sent to firebase, resend the notification.
The priority of push notifications can significantly affect their delivery and reception:
Time-to-Live (TTL): Adjust the TTL settings based on the urgency of the message. High-priority messages should have shorter TTLs to ensure timely delivery. This also makes it easier to resend messages if they are not delivered, and avoid accidentally sending your users multiple messages.
Interactive notifications are typically sent as a "data push" notification instead of as a regular notification*. These type of notifications require custom code to be properly rendered on a user's phone. A number of phone manufacturers include optimization code that kills notifications that take tool long to process, ideally your code should process in a few seconds.
For improved reliability, you can complement push notifications with a pull-based approach. This works for notifications that don't need to be delivered instantly.
Essentially the way this works is that there is code in your app that triggers when a user is active, and this code runs intermittently. This code polls a server to check for undelivered push notifications and after communication with the server can send those notifications when a user is active.
Another variant of this is the Notification Center
You can create an in-app notification center where users can access missed messages, ensuring no important notifications are overlooked.
To ensure critical notifications are never missed, you can implement fallback options:
You can schedule a second notification if the first one isn't acknowledged within a set timeframe like mentioned above, or you can use alternative channels like text messages if push notifications fail.
