How do notifications work system design?

Notifications are a critical feature of most modern applications and websites. They allow users to receive timely updates and information without having to constantly check the app. Building a robust and scalable notification system requires solid software architecture and engineering.

Overview of Notification Systems

At a high level, notification systems typically involve three key components:

• Notification producer – The module responsible for generating and queuing notifications when certain events occur. This could be a server application, cloud function, etc.
• Notification delivery channels – The mediums used to deliver notifications to users. Common channels include push notifications, SMS, and email.
• User devices – The user’s phone, computer, etc. where they receive and interact with notifications.

The general flow is:

1. A notification triggering event occurs, such as a new chat message being received.
2. The notification producer detects the event and generates a notification object/payload with relevant data like the content and recipient(s).
3. The notification gets put on a queue or sent directly to delivery channels like FCM (Firebase Cloud Messaging) for android push notifications.
4. The user’s device receives the notification via the channel and displays it to the user.
5. The user can tap/click on the notification to open the app and take an action like reading the new message.

Scaling and Performance Considerations

For systems with large user bases, notifications can pose some scaling challenges. Here are some key considerations:

• Queue Size – A queue should be used to buffer notifications before sending to delivery channels. Need to size queue appropriately so producers are not blocked while waiting for consumers.
• Queue Partitioning – Partition the queue by notification type or user segment to support higher throughput and isolation.
• Rate Limiting – Limit how frequently notifications can be sent to prevent overwhelming users and delivery channels.
• Message Batching – Batch multiple notifications in a single request to delivery channels to reduce overhead.
• Coalescing – Coalesce similar pending notifications to further reduce duplicates.
• Backpressure – Apply backpressure between producers, queue, and consumers when any stage becomes overloaded.

Caching and asynchronous processing can also help improve throughput and reduce latency for high scale notification pipelines.

Push Notifications

Push notifications are commonly used for mobile and web apps. Here are some design considerations for implementing push notification functionality:

• Choose a vendor like Firebase Cloud Messaging (FCM) or Apple Push Notification Service (APNS). They handle queuing, delivery retries, advanced routing logic, analytics, etc.
• Implement client SDKs provided by the vendor in the mobile/web clients to receive notifications.
• When user authenticates, register their device token with your backend.
• When an event occurs, fetch the target users’ device tokens and send notification payload to the vendor API.
• Authentication tokens can expire so refresh tokens periodically.
• Handle failed notifications and remote token refreshes gracefully.

Some other best practices for push notifications:

• Make notifications relevant and contextual.
• Allow users to customize notification settings.
• Follow platform guidelines for notification content.
• Use a certificate pinning strategy to prevent MITM attacks.

Email Notifications

For email notifications, key components include:

• Email template management – Easy editing of templates, support for localization, A/B testing, etc.
• Email service provider – Transactional email delivery services like SendGrid, Mailgun, etc.
• Queues and background workers – To decouple sending from request flow.
• Rate limiting – Prevent too frequent emails to same user.
• unsubscribe management – Honor unsubscribe requests.

Tips for optimizing email notifications:

• Personalize subject lines when possible.
• Segment users for targeted content.
• Make sure emails are mobile friendly.
• A/B test different templates.
• Follow best practices like permission reminders, physical mailing address, etc.

SMS Notifications

SMS requires managing a pool of local or toll-free numbers, along with an SMS provider gateway. Considerations include:

• Cost optimization – Minimize costs based on traffic patterns, message types, etc.
• Two-factor authentication – Specialized 2FA workflow for verification codes.
• Compliance – Adhere to regional regulations for promotional vs transactional messages.
• Character limits – SMS only allows limited message length.

Best practices for SMS notifications:

• Only send high priority, time-sensitive alerts.
• Minimize promotional messages.
• Give user controls over opt-in and frequency.
• Have clear unsubscribe mechanism.
• Don’t include sensitive personal information.

In-App Notifications

In-app notifications refer to messages that appear within the user interface of a mobile or web app, such as:

• Badges
• Banners
• Popups/modals
• In-line messages

Some tips for in-app notification design:

• Use judiciously – don’t oversaturate users.
• Allow easy dismiss.
• Make actionable.
• Use animations/color to attract attention.
• Personalize with user context when possible.
• Allow opt-out or throttling.

Notification Storage and Analytics

It’s useful to store metadata about notifications sent for purposes like analytics, auditing, and debugging. Options include:

• Database – Store notification objects directly in a database table.
• Data warehouse – Use ELT pipelines to load notification data into a warehouse for analysis.
• Logging – Log notifications to file or tool like Datadog.

Analytics that can be performed on notification data include:

• Delivery success/failure rates.
• End-to-end latency.
• Notification volumes by type, user, channel, etc.
• User engagement rates.
• Conversion rates of notifications leading to app opens, purchases, etc.

These insights help understand notification system performance, tune processes, and optimize user experiences.

Testing and Monitoring

Thorough testing and monitoring helps catch issues early and validate that the notification system meets requirements, especially under load. Strategies include:

• Unit testing – Test notification generation, queuing, channel integration logic, etc.
• Integration testing – End-to-end tests verifying notifications sent through actual channels.
• Load testing – Simulate heavy user loads and notification volumes.
• Monitoring – Monitor queue depth, channel latency, errors, throughput, etc.
• Alerting – Get notified for performance issues or system failures.

Proper logging at each stage is crucial for debugging and investigating errors.

Conclusion

Building notification capabilities involves many architectural, infrastructure, and operations considerations. The system needs to deliver notifications reliably and at scale while providing a smooth user experience. Following design principles around performance, robustness, and scalability goes a long way in addressing the challenges with notifications.

At a high level, the main takeaways are:

• Decouple notification logic from business logic using queues and workers.
• Choose appropriate delivery channels based on use case.
• Store and analyze notification data for debugging and optimization.
• Implement mechanisms to handle throttling, coalescing, and errors gracefully.
• Conduct rigorous testing and monitoring.

Notifications continue to be an essential component of modern applications. Investing in a solid technical foundation pays dividends through improved customer experiences and engagement.