Back to Blog
Mobile

Push Notifications Done Right: Strategies for 2026

Master push notification strategies that engage users without annoying them, driving retention and re-engagement.

Chris Martinez
Chris Martinez
Author
10 January 2026
17 min read
Push Notifications Done Right: Strategies for 2026
# Push Notifications: Engagement Without Annoyance

Push notifications are powerful but easily misused. Here's how to do them right.

Why Push Notifications Matter

#

The Impact
  • 88% higher app retention
    • 3-10x increase in engagement
      • Direct communication channel
        • Real-time updates
          • Personalized experiences

            #

            The Risk

            • 60% of users disable notifications
              • Poor notifications lead to uninstalls
                • Privacy concerns
                  • Notification fatigue

                    Types of Push Notifications

                    #

                    1. Transactional

                    • Order confirmations
                      • Shipping updates
                        • Payment receipts
                          • Account changes

                            Example: ``` πŸ“¦ Your order has shipped! Arrives tomorrow by 8 PM Track: bit.ly/abc123 ```

                            #

                            2. Promotional

                            • Sales and discounts
                              • New features
                                • Limited-time offers
                                  • Product launches

                                    Example: ``` πŸŽ‰ Flash Sale: 30% Off! 24 hours only. Shop your favorites. ```

                                    #

                                    3. Engagement

                                    • Content updates
                                      • Social interactions
                                        • Milestone celebrations
                                          • Reminders

                                            Example: ``` πŸ‘‹ We miss you! Check out what's new since your last visit. ```

                                            #

                                            4. Geolocation

                                            • Nearby offers
                                              • Location reminders
                                                • Event notifications
                                                  • Local content

                                                    Example: ``` πŸ“ You're near our store! Stop by for an exclusive in-store offer. ```

                                                    Implementation

                                                    #

                                                    Firebase Cloud Messaging (FCM)

                                                    Setup: ```javascript import messaging from '@react-native-firebase/messaging';

                                                    // Request permission const requestPermission = async () => { const authStatus = await messaging().requestPermission(); const enabled = authStatus === messaging.AuthorizationStatus.AUTHORIZED || authStatus === messaging.AuthorizationStatus.PROVISIONAL;

                                                    if (enabled) { console.log('Authorization status:', authStatus); const token = await messaging().getToken(); // Send token to your backend await saveTokenToDatabase(token); } };

                                                    // Handle foreground messages messaging().onMessage(async remoteMessage => { console.log('Foreground message:', remoteMessage); // Display custom in-app notification showInAppNotification(remoteMessage); });

                                                    // Handle background messages messaging().setBackgroundMessageHandler(async remoteMessage => { console.log('Background message:', remoteMessage); });

                                                    // Handle notification open messaging().onNotificationOpenedApp(remoteMessage => { console.log('Notification opened:', remoteMessage); // Navigate to relevant screen navigateToScreen(remoteMessage.data); }); ```

                                                    #

                                                    OneSignal

                                                    ```javascript import OneSignal from 'react-native-onesignal';

                                                    OneSignal.setAppId('YOUR_APP_ID');

                                                    // Prompt for permission OneSignal.promptForPushNotificationsWithUserResponse(response => { console.log('Prompt response:', response); });

                                                    // Handle notification received OneSignal.setNotificationWillShowInForegroundHandler( notificationReceivedEvent => { const notification = notificationReceivedEvent.getNotification(); notificationReceivedEvent.complete(notification); } );

                                                    // Handle notification opened OneSignal.setNotificationOpenedHandler(notification => { console.log('Notification opened:', notification); }); ```

                                                    Best Practices

                                                    #

                                                    1. Timing is Everything

                                                    Good Times:

                                                    • After user completes meaningful action
                                                      • During active usage hours
                                                        • Based on user timezone
                                                          • When value is immediate

                                                            Bad Times:

                                                            • Late night/early morning
                                                              • During work hours (context-dependent)
                                                                • Too frequently
                                                                  • Right after app install

                                                                    #

                                                                    2. Personalization

                                                                    ```javascript // User segmentation const sendPersonalizedNotification = async (user) => { const message = { notification: { title: `Hey ${user.firstName}!`, body: getPersonalizedMessage(user.preferences) }, data: { type: 'personalized', category: user.favoriteCategory }, token: user.fcmToken }; await messaging().send(message); }; ```

                                                                    #

                                                                    3. Relevance

                                                                    ```javascript // Context-aware notifications const shouldSendNotification = (user, notification) => { // Check user preferences if (!user.notifications[notification.category]) { return false; } // Check frequency limits if (getNotificationCount(user.id, 'today') >= 3) { return false; } // Check time zone const userHour = getUserLocalHour(user.timezone); if (userHour < 8 || userHour > 21) { return false; } return true; }; ```

                                                                    #

                                                                    4. Value-First Content

                                                                    Bad: ``` ❌ "Open our app!" ❌ "We have an update" ❌ "Hey there!" ```

                                                                    Good: ``` βœ… "Your package arrives today at 3 PM" βœ… "Sarah liked your photo" βœ… "$50 off your favorite item" ```

                                                                    #

                                                                    5. Clear CTAs

                                                                    ```javascript // iOS action buttons const notification = { title: 'New message from Sarah', body: 'Hey, are we still meeting today?', category: 'message', actions: [ { id: 'reply', title: 'Reply', options: { foreground: true } }, { id: 'view', title: 'View', options: { foreground: true } } ] }; ```

                                                                    Advanced Strategies

                                                                    #

                                                                    1. Rich Notifications

                                                                    ```javascript // With image const richNotification = { notification: { title: 'New Product Launch', body: 'Check out our latest collection', imageUrl: 'https://example.com/product.jpg' }, data: { product_id: '123', deep_link: 'app://products/123' } }; ```

                                                                    #

                                                                    2. Notification Channels (Android)

                                                                    ```javascript import notifee from '@notifee/react-native';

                                                                    // Create channel await notifee.createChannel({ id: 'promotions', name: 'Promotions', importance: AndroidImportance.DEFAULT, sound: 'custom_sound' });

                                                                    // Send to channel await notifee.displayNotification({ title: 'Sale Alert', body: '50% off today only!', android: { channelId: 'promotions' } }); ```

                                                                    #

                                                                    3. Smart Scheduling

                                                                    ```javascript const scheduleOptimalTime = async (userId, notification) => { // Analyze user's typical active hours const activeHours = await getActiveHours(userId); // Find best time in next 24 hours const optimalTime = activeHours .filter(hour => hour > new Date().getHours()) .sort((a, b) => b.engagement - a.engagement)[0]; // Schedule notification await scheduleNotification(notification, optimalTime); }; ```

                                                                    #

                                                                    4. A/B Testing

                                                                    ```javascript const testNotification = async (users) => { const variants = [ { title: 'Special Offer', emoji: '🎁' }, { title: 'Limited Time Deal', emoji: '⏰' }, { title: 'Exclusive Sale', emoji: '✨' } ]; for (const user of users) { const variant = variants[user.id % variants.length]; await sendNotification(user, variant); await trackVariant(user.id, variant); } }; ```

                                                                    User Preferences

                                                                    #

                                                                    Opt-In Best Practices

                                                                    ```javascript const requestNotificationPermission = async () => { // Show value proposition first const userWantsNotifications = await showNotificationPrompt({ title: 'Stay Updated', message: 'Get notified about order status, exclusive deals, and more', benefits: [ 'Order tracking updates', 'Exclusive early access', 'Personalized recommendations' ] }); if (userWantsNotifications) { const permission = await requestSystemPermission(); return permission; } return false; }; ```

                                                                    #

                                                                    Granular Control

                                                                    ```javascript // Let users choose const notificationPreferences = { orderUpdates: true, promotions: false, newFeatures: true, socialInteractions: true, weeklyDigest: false };

                                                                    await savePreferences(userId, notificationPreferences); ```

                                                                    Measuring Success

                                                                    #

                                                                    Key Metrics

                                                                    1. Opt-in Rate: % of users who enable notifications 2. Open Rate: % of notifications opened 3. Conversion Rate: % leading to desired action 4. Opt-out Rate: % of users who disable 5. Uninstall Rate: After notification

                                                                    #

                                                                    Analytics

                                                                    ```javascript const trackNotification = async (notificationId, event) => { await analytics.track(`notification_${event}`, { notification_id: notificationId, type: notification.type, timestamp: Date.now() }); };

                                                                    // Track delivery trackNotification(id, 'delivered');

                                                                    // Track open trackNotification(id, 'opened');

                                                                    // Track conversion trackNotification(id, 'converted'); ```

                                                                    Common Mistakes

                                                                    ❌ Asking for permission immediately ❌ Sending too many notifications ❌ Generic, non-personalized content ❌ No value in messages ❌ Bad timing ❌ No way to customize preferences ❌ Not testing different approaches ❌ Ignoring opt-out signals

                                                                    Checklist

                                                                    βœ… Clear value proposition βœ… Permission at right time βœ… Personalized content βœ… Respect frequency limits βœ… Consider timing βœ… Provide granular control βœ… Track metrics βœ… A/B test messages βœ… Rich content when appropriate βœ… Clear call-to-action βœ… Handle opt-outs gracefully

                                                                    Tools

                                                                    - Firebase Cloud Messaging: Free, reliable

                                                                    • OneSignal: Feature-rich, great free tier
                                                                      • Airship: Enterprise solution
                                                                        • Braze: Marketing automation
                                                                          • CleverTap: User engagement

                                                                            The Golden Rule

                                                                            Treat notifications like you treat email: would you want to receive this message? If not, don't send it.

                                                                            Conclusion

                                                                            Great push notifications:

                                                                            • Add value
                                                                              • Are timely and relevant
                                                                                • Respect user preferences
                                                                                  • Drive meaningful engagement

                                                                                    Poor push notifications:

                                                                                    • Feel like spam
                                                                                      • Interrupt without purpose
                                                                                        • Lead to app uninstalls

                                                                                          Use this power wisely. Your usersβ€”and your metricsβ€”will thank you.

Share this article

Stay Updated

Subscribe to our newsletter for the latest insights and updates.

Website packages from R5,500
Special offer

Website packages from R5,500

Launch-ready business websites with hosting and support included.