Guide

Tutorial

Product News

Courier Updates

User Experience

Product Management

Integrations

Engineering

Live Streaming

Notifications Landscape

Courier

Thomas Schiavone

Managing integrations shouldn’t feel like guesswork. You should be able to see what’s connected, know if it’s working, and make changes without jumping through hoops.

That’s why we rebuilt the Integrations page.

The new experience gives you a clear, consolidated view of every provider in your system. You can check connection health at a glance, monitor real-time message activity, and tweak settings without getting lost in nested config screens.

It’s a simpler, faster way to stay in control of your providers.

![Courier Intergration Overview](//images.ctfassets.net/z7iqk1q8njt4/21fQXHPj6KNueMhRwkAQXG/d07ec281ecd9bc71af4fa47cac16315d/Courier_Intergration_Overview.png)

---

## See What’s Connected and What Needs Attention

The top of the Integrations page gives you a high-level snapshot of your system’s activity over the past 30 days. A stacked graph shows total message volume by channel, so you can quickly understand how traffic is trending across email, SMS, push, and in-app.

Right above the graph, you’ll see three core metrics that reflect the overall health of your system:
- **Total sent**
- **Delivery rate**
- **Error rate**

Just below that, every connected provider is listed in a table grouped by channel. For each one, you’ll see a summary of how many messages were sent through it, the current error rate, and the last time it was active.

![Courier Integration Detail View](//images.ctfassets.net/z7iqk1q8njt4/12MDuHMzI7ihFiKpKiOESq/69e134d2a6d597541f1d758596015ef4/Courier_Integration_Detail_View.png)

Click on any provider to dive deeper.

The detail panel gives you a focused view of that provider’s recent performance—complete with a 30-day message volume chart and error rate trend. If something’s off, you’ll see it fast. You can also manage settings directly from this view.

---

## Next Up: New Navigation

This is the first in a series of updates focused on improving Courier’s UX.

We started with the Integrations page to make it easier to monitor system health and manage providers. Next, we’re working on a redesigned navigation experience that will simplify navigation throughout the app and make it easier to switch between environments.

Our goal is to make Courier faster, clearer, and more intuitive.

**Stay tuned.**

Integrations - Header

Courier’s new Integrations page makes it easy to monitor activity, check provider health, and manage settings from one streamlined interface.

Smarter Way to Manage Notification Providers

Introducing the New Integrations Page

## Why Multi-Channel Notifications Are Essential for Workforce Management

Email alone won’t reach today’s workforce.

With employees working in-person, remote, hybrid, full-time, hourly, freelance, seasonal, or on contract, workforce management has never been more complex. To connect with such a diverse workforce, you need more than email or app-based notifications. You need to reach people on the channels they actually use and trust.

That’s why multi-channel notifications are essential. They make sure every worker receives the right message, in the right place, at the right time.

- **Email** is best for non-urgent updates, documentation, and detailed communications.
- **Push notifications** reach mobile workers instantly with urgent or time-sensitive alerts.
- **In-app notifications** deliver persistent, contextual messages while workers are active in your platform. [Courier Inbox](https://www.courier.com/inbox) makes it easy to add a web or mobile inbox to your app.
- **SMS** offers a universal and reliable fallback when other channels aren’t available or when workers don’t use smartphones.

In workforce management, multi-channel isn’t optional. It’s the only way to meet workers where they are—whether you’re filling hourly shifts, staying compliant with labor laws, or driving day-to-day engagement. A smart notification strategy is critical to running a connected and responsive workforce.

---

## Multi-channel notifications drive business results

Multi-channel notifications aren’t just a way to improve communication — they’re how workforce management platforms drive measurable outcomes.

When every message reaches the right worker, on the right channel, you can:

- **Reduce no-shows and missed shifts** by making sure reminders and last-minute changes are delivered and seen.
- **Fill open roles faster** by escalating shift offers across channels to maximize reach.
- **Stay compliant** by ensuring that required trainings and certifications are completed on time.
- **Lower manager workload** by automating follow-ups and reducing manual coordination.
- **Improve worker retention and engagement** by communicating in ways that feel timely, relevant, and unobtrusive.

This is why multi-channel isn’t optional. It’s a core part of running an efficient and reliable workforce operation.

[**Bluecrew used Courier to upgrade their communication strategy**](https://www.courier.com/use-cases/bluecrew), resulting in a 55% increase in job application rates. By delivering notifications across push, SMS, and email — and automatically routing messages based on urgency — they streamlined shift fulfillment and improved responsiveness at scale.

With Courier, workforce platforms can design notification strategies that support these kinds of outcomes — sending smarter, more effective messages without adding manual overhead or complexity.

---

## Matching channels to workers and context

When communication breaks down, operations stall. That’s why notification strategy must reflect the reality of your workforce: varied roles, preferences, and availability.

A retail associate working in a store may prefer in-app notifications for shift reminders and daily updates they can check while on break. A restaurant shift lead in the middle of service might need push notifications to catch urgent schedule changes or staffing requests in real time. Seasonal warehouse staff may rely on SMS, especially if they aren’t using your app regularly.

That’s why a flexible notification strategy is essential. To connect with every worker effectively, you need to combine preferences, context, and urgency — and let those factors determine how each message is sent.

Smart notification routing makes this possible. Instead of relying on a single channel or guessing, you can dynamically select the best option:

- Use **in-app notifications** for persistent updates when workers are already engaged in your mobile or web app.
- Send **push notifications** when urgent action is needed and attention must be immediate.
- Fall back to **SMS** if delivery fails or workers are offline.
- Stick with **email** for non-urgent messages or detailed information.

This approach ensures important messages are delivered and seen — without overwhelming workers or relying on blast communications.

---

## How multi-channel notifications solve workforce challenges across industries

From shift coverage to urgent updates, every industry with a distributed workforce relies on notifications to keep operations running smoothly. Multi-channel notifications help solve these challenges — fast and at scale.

### Healthcare

**Challenge**  
Last-minute shift changes and urgent on-call needs require instant communication.

**Solution**  
Push notifications and SMS alerts make sure nurses and doctors get urgent updates wherever they are. In-app notifications provide non-urgent reminders, like upcoming shift confirmations or training deadlines.

**Value**  
Faster responses, reduced coverage gaps, and less reliance on manual coordination.

---

### Logistics

**Challenge**  
Drivers need real-time delivery updates and route changes while on the move.

**Solution**  
Push notifications deliver urgent route changes immediately. In-app notifications keep track of delivery updates and confirmations in one place for easy access during shifts.

**Value**  
Improved delivery accuracy, reduced delays, and easier dispatcher-driver communication.

---

### Hospitality

**Challenge**  
Hotels must quickly fill shifts during peak demand periods.

**Solution**  
Shift offers are sent via push for urgency, in-app notifications for easy reference, and SMS as a backup for seasonal staff without regular app usage.

**Value**  
Faster shift fills, fewer missed shifts, and more targeted outreach to staff based on preferences.

---

### Retail

**Challenge**  
Store associates need regular updates on schedules, policies, and training.

**Solution**  
In-app notifications deliver persistent, non-urgent updates like policy changes or training completions. Push and SMS handle urgent shift changes or schedule adjustments.

**Value**  
Better shift coverage, improved compliance, and reduced no-shows.

---

With a platform like Courier, it’s easy to design multi-channel notification strategies like these — mapping urgency, worker context, and preferences into automated flows that ensure the right message always reaches the right worker.

---

## Courier: Your end-to-end platform for multi-channel notifications

Courier is more than a notification tool — it’s the infrastructure behind a smart, scalable multi-channel strategy.

Whether you're sending a single urgent alert or orchestrating notifications across a workforce of thousands, Courier helps you reach every employee, on the right channel, at the right time.

### ✅ Built for multi-channel, out of the box  
Courier supports **in-app (web and mobile)**, **push**, **SMS**, and **email** — with 50+ provider integrations and a unified API. Manage every channel from one platform without custom integrations or siloed systems.

### 📬 Preference-aware delivery  
Store and apply user preferences automatically. A compliance reminder can be delivered via in-app for one worker, and as a push or SMS for another — without manual decision trees.

### 🔁 Routing logic and failover  
Courier lets you define delivery rules: if a push notification fails, fall back to SMS. If an in-app message goes unseen, follow up with email. Every message gets where it needs to go — no guesswork required.

### 📦 Batching and digest support  
Reduce noise by grouping updates — like schedule changes, training alerts, or shift summaries — into daily or weekly digests. Keep workers informed without overwhelming them.

### 🧰 Developer APIs + drag-and-drop editors  
Courier gives developers a modern API and SDKs to integrate notifications with your platform’s workflows, job queues, and event systems. At the same time, product and ops teams can use Courier’s visual drag-and-drop editor to build and update messages across channels — no engineering help required.

### 📊 Observability and control  
Get full visibility into every message. Courier provides logs, metrics, and delivery tracking across all channels and providers, so you can monitor performance and fine-tune your strategy over time.

Courier brings together the tools you need to deliver notifications that are fast, reliable, personalized — and built to scale. One platform, all your channels, fully under control.

---

## Build for the future

The difference between a missed shift and a filled role often comes down to one thing: communication.

Courier gives you the platform to make sure every message lands — whether it’s a push notification about a schedule change, an in-app alert tied to onboarding, or a digest of compliance reminders sent by email.

You don’t need to build and maintain notification infrastructure in-house. With Courier, you get an end-to-end solution for multi-channel messaging that scales with your workforce, adapts to your needs, and keeps your teams connected.

**Take the first step. [Book a demo →](https://www.courier.com/request-demo)**

Workforce Management Strategy

Reach every worker with the right message. Learn how multi-channel notifications improve shift coverage, compliance, and engagement.

Why Workforce Platforms Need Multi-Channel Notifications

## Why Embedded Editors Exist (And Why You Need More Than Email)

SaaS platforms are in the business of delivering experiences — and communication is a big part of that. From onboarding emails and system alerts to in-app messages and SMS reminders, **SaaS products and platforms rely on notifications** to keep users engaged and informed.

Giving customers control over these notifications is now table stakes. They expect to design and manage messages that reflect their brand and speak directly to their users.

That’s why embedded editors — especially embedded email editors and notification editors — have grown in popularity. They bring notification customization into your product — no more copy-paste handoffs or support tickets to change text or colors. But most embedded editors solve only a small part of the problem.

## Where Traditional Embedded Editors Stop

Most embedded notification editors today share the same story:

- They focus only on email, leaving push, SMS, and in-app notifications disconnected.
- They stop at design — you still have to build and maintain delivery logic.
- They aren’t built for multi-tenant SaaS. Scoped access, per-customer branding, and localization are either manual or nonexistent.

That’s a big gap — and one that often falls on engineering and product teams, especially for SaaS platforms, to fill with internal tools, scripts, and workarounds.

At best, traditional editors solve half the problem. The harder half — delivery, scale, and customer isolation — is still on you.

## Courier Create — Embedded, Multi-Channel, and Connected

![Notifications Designer ](//images.ctfassets.net/z7iqk1q8njt4/7Crcd3FzEWytmwmtm4oeWW/0b5c32efc4f726381c1f962ed12556d3/Notification_Designer.png)

[Courier Create](https://www.courier.com/platform/courier-create) was built to solve the entire problem — from design to delivery. It is a **React-based embedded notification editor** purpose-built for SaaS platforms.

Like others, it’s a drop-in notification designer. But unlike traditional editors, Courier Create was designed to support more than email — and to connect directly to delivery out of the box.

Here’s how it’s different:

- **Multi-channel support** → email, push, SMS, and in-app notifications, all managed from a single multi-channel notification editor.
- **Integrated delivery** → no syncing or handoffs, messages go directly from editor to user.
- **Scoped access** → perfect for SaaS platforms, with per-tenant templates and brand control.
- **Localization and flexibility** → built-in internationalization, test sends, and advanced design blocks.

Courier Create gives your customers the freedom to create and manage notifications — without adding complexity for your team.

<iframe width="800" height="450"
  src="https://www.youtube.com/embed/SRuXIyhqkNg" 
  title="YouTube video player" 
  frameborder="0" 
  allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" 
  allowfullscreen>
</iframe>

## Multi-Channel Messaging — Why It Matters

Most embedded editors were built for email marketers. Courier Create was built for platforms.

In today’s world, notifications aren’t limited to email. Product updates, transactional alerts, and user messages are sent across:

- **Email** → Traditional transactional and marketing messages.
- **Push** → Mobile-first updates and user engagement.
- **SMS** → Urgent, direct alerts.
- **In-app** → Seamless product experiences.

An embedded notification editor should support all of them — and Courier Create does. It lets your customers design and manage messages for every channel, all from one simple, branded interface.

## Integrated Delivery — No More Handoffs

Most embedded email editors stop at design. Once the message looks right, your product team is still responsible for getting it delivered. That means building APIs, writing syncing scripts, and managing delivery across every channel.

Courier Create eliminates all of it. It combines notification design and delivery into a single streamlined platform.

When your customers hit save, the message is instantly connected to Courier’s multi-channel delivery system — ready to send via email, push, SMS, or in-app. Design, save, and deliver — no extra steps or handoffs.

[Explore the Courier Create docs to see how easy it is to embed →](https://www.courier.com/docs/platform/create/intro)

## Scoped for SaaS and Multi-Tenant Platforms

SaaS platforms have unique challenges when it comes to notifications. Your customers expect control over their messages, but you can’t compromise on security, isolation, or branding.

Courier Create was built for exactly this — a **multi-tenant notification editor** designed for SaaS applications.

Every customer gets their own scoped environment — isolated templates, branding, and content that only they can access. There’s no risk of cross-tenant data leaks, no complicated permission systems to build, and no manual work to manage notification ownership.

Whether you support dozens of customers or tens of thousands, Courier Create ensures each one can design and manage notifications safely, securely, and on-brand. Multi-tenancy, done right — and built in from day one.

## Designed for Ease — Simple for Customers, Flexible for You

Courier Create makes notification design effortless for users.

At its core is a simple, intuitive **drag-and-drop email editor and notification designer** that lets your customers create and customize messages without writing a line of code. They can add text, images, and layouts in seconds — and see exactly what their notifications will look like before sending.

For lighter use cases, the Brand Designer makes it even easier. You can offer customers the ability to set logos, colors, and footers — giving them brand control without needing to manage full templates.

Or, combine both. The Notification Designer and Brand Designer work together, so you can choose how much control to give each customer. Offer full template customization or limit to brand styling — it’s up to you and your product.

Whatever the use case, Courier Create keeps notification design simple and seamless — right inside your SaaS app.

## The Next Generation of Embedded Editors

Embedded editors shouldn’t stop at email. A modern notification editor should do more — and be built for today’s SaaS products.

It should:

- Support every channel your platform relies on.
- Connect directly to delivery, not leave it up to you.
- Offer scoped, branded, and localized experiences.
- Live seamlessly inside your product — not feel bolted on.

Courier Create does all of this. It replaces internal tools, sync scripts, and manual workflows — so your team can stay focused on building your product, not maintaining messaging infrastructure.

If you're ready to give your customers real ownership of their notifications — without sacrificing control or adding engineering overhead — it's time to see Courier Create in action.

[Read our docs and get building! →](https://www.courier.com/docs/platform/create/intro)

Courier Create Header

Most embedded email editors stop at design. Courier Create gives SaaS platforms a multi-channel editor with delivery, tenant scoping, and in-app integration.

Courier Create: The Embedded Editor for SaaS (Email, Push, SMS, In-App)

The Modern Embedded Editor: Why SaaS Needs More Than Email

[Courier Create](https://www.courier.com/platform/courier-create) makes it easy to put your customers in control of their notifications—right inside your app. Since launch, we’ve seen huge demand from teams who want to offer a fully branded, self-serve experience without needing to build custom tools or workflows.

But we’re just getting started.

Here’s a look at what’s coming next for Courier Create—and how we’re expanding the power of the editor to make message creation even more flexible, scalable, and user-friendly.

---

### 📬 Expanding Beyond Email

Email was the clear priority when we launched Courier Create. During our beta, it became obvious that this was the channel most teams needed first—and fast.

But notifications don’t stop at email.

In the next two weeks, we’re rolling out support for **push, SMS, and in-app notifications**. This means your customers will soon be able to design and manage their own messages across all major channels—using the same intuitive editor embedded inside your app.

---

### 🌍 Internationalization and Locales

Notifications often need to speak more than one language.

That’s why we’re working on simple, built-in **internationalization**. Soon, your customers will be able to manage translations directly inside the editor—without needing engineering help or complicated workarounds.

They’ll be able to add translated versions of any string for any locale, making it easy to ensure their messages reach global audiences in the right language.

Our goal is to make multi-lingual notifications seamless for everyone—from product teams to end users.

---

### 👀 Preview-Only Mode

Sometimes, your customers don’t need full editing access. They just want to see what a message looks like before it goes out.

Soon, Courier Create will offer a **Preview-Only mode**, allowing you to display read-only versions of notifications directly inside your app.

This is perfect for approval workflows or any scenario where you want to show—but not allow changes to—the final message.

---

### 📲 Test Sends for Email and SMS

Seeing a preview is useful, but there’s no substitute for seeing the real thing on your own device.

That’s why we’re adding support for **test sends**. Soon, your customers will be able to easily send test versions of their emails and SMS messages to themselves before going live.

We’re building this as a fully integrated feature so you can make it part of your app’s native experience—no hacks or workarounds required.

---

### 🧩 More Advanced Email Blocks

Our editor is intentionally simple and streamlined, but we know some customers need more flexibility for complex email layouts.

That’s why we’re planning to introduce new block types, including:

- **Column layouts**  
- **Custom HTML blocks**  
- **Code blocks**  

This will give advanced users more creative freedom while still keeping the core experience easy and approachable.

---

### 💡 Help Shape the Roadmap

Courier Create is just getting started—and your feedback will help guide where we take it next.

If you have ideas, feature requests, or just something you’d love to see in the product, reach out to us at [ideas@courier.com](mailto:ideas@courier.com). We’d love to hear from you.

What's Next for Courier Create - Embeddable Designer

See what’s next for Courier Create.  Design and deliver notifications across email, push, SMS, in-app. Plus new features like internationalization & test sends.

Courier Create Roadmap: Push, SMS, In-App Notifications, I18n & More

What’s Next for Courier Create: Push, SMS, In-App, Internationalization, and More

Embed a customizable notification builder and email editor into your app. Give users control over their templates for email, SMS, push, and in-app messaging.

Courier Create: Embed a Custom Notification Editor in Your App

Mike Miller

_React Native wasn’t enough. Lynx is ByteDance’s answer — and it might be a glimpse of what’s next for mobile development._

---

### Key Takeaways
- ByteDance built Lynx to address performance and flexibility gaps they saw in React Native — not to compete with Flutter.  
- Lynx offers native rendering, background-threaded APIs, and support for multiple JavaScript frameworks, making it especially appealing to web developers.  
- While promising, Lynx is still early. Its long-term success depends on ecosystem growth and broader community adoption.

---

## 1. Why ByteDance Chose to Build, Not Adopt
> **Summary:** ByteDance built Lynx because existing frameworks like React Native didn’t meet their needs — technically or strategically.

If React Native had delivered everything teams needed, ByteDance wouldn’t have built Lynx.

That’s where this starts. ByteDance — the company behind TikTok and dozens of other apps — released its own JavaScript-to-native mobile framework. Not because there weren’t options. React Native and Flutter have been around for years. But neither gave them what they were looking for: the performance of native, the flexibility of the web, and the freedom to choose their own direction.

Lynx wasn’t built to enter the framework wars. It was built to solve a specific set of problems ByteDance saw in their own stack. And that decision says a lot about where cross-platform development is today — and where it’s still falling short.

Looking for a full comparison? Check out our breakdown of [Lynx vs React Native vs Flutter in 2025](https://www.courier.com/blog/cross-platform-development-in-2025-lynx-vs-react-native-vs-flutter).

---

## 2. The Technical Gaps Lynx Is Designed to Fill
> **Summary:** Lynx improves on performance, developer experience, and flexibility with native rendering, background-threaded APIs, and real CSS support.

Lynx is a JavaScript-to-native framework, but the details matter. It’s designed for performance from the ground up. First render times are near-instant. Expensive work is pushed to background threads. It’s built to feel smooth, even before you start optimizing.

But what makes it stand out is how it fits into existing web development workflows. It doesn’t require React. You can use Svelte, Vue, Angular — whatever makes sense for your team. And you can write real CSS, the same way you would on the web. No styled-components or custom abstractions.

That blend — performance like a native app, with tooling and patterns from the web — is what makes Lynx interesting. It doesn’t ask developers to choose between speed and familiarity.

---

## 3. React Native Developers Are the Real Target
> **Summary:** Lynx is best suited for teams already working with React Native or other web frameworks — not Flutter developers.

Lynx often gets mentioned alongside Flutter, but they’re solving different problems.

Flutter has its own rendering engine. It uses Dart. Everything is drawn from scratch — every button, every animation, every pixel. That gives you consistency, but it’s not native in the traditional sense. And if you’re coming from the web, Flutter can feel like learning a new platform entirely.

Lynx is closer to React Native. It renders native components and runs on JavaScript. It fits more naturally into web-centric teams. And if you’re already using React Native, moving to Lynx might not be trivial — but it wouldn’t require rewriting everything from scratch, either.

Flutter tends to make more sense for developers with native or mobile backgrounds. Lynx feels like it was built for the web-first world.

---

## 4. Owning the Framework Means Owning the Future
> **Summary:** By building Lynx in-house, ByteDance gains full control over its mobile stack and long-term roadmap.

React Native is open source, but it’s still driven by Facebook. For a company like ByteDance, that’s a dependency — and maybe an uncomfortable one. Building Lynx wasn’t just about making something faster or more flexible. It was about taking control of a critical part of their stack.

Owning the framework means setting the priorities. Making changes when they’re needed. Building for your own roadmap, not someone else’s. In the long run, that kind of control can be more valuable than any individual technical feature.

It’s not just a framework — it’s infrastructure.

---

## 5. Lynx Has a Solid Core — But It’s Not Ready for Everyone
> **Summary:** The fundamentals are strong, but the surrounding ecosystem is still immature and may slow adoption for now.

Lynx has a lot going for it — but it’s still early.

The fundamentals are solid, but the ecosystem around it — the libraries, tools, community support — will take time to grow. That matters. A good framework isn’t just about architecture. It’s about whether people want to build with it.

Right now, there are tradeoffs. You might need to write more code by hand. AI coding tools like Cursor or GitHub Copilot won’t recognize the APIs yet. Docs will be thinner. You’ll spend more time figuring things out. That’s the cost of being early.

But that’s the tradeoff with anything new. If adoption grows, and the ecosystem catches up, Lynx could be a strong choice — especially for teams that want native performance without leaving behind the web development patterns they know.

It’s not a polished, ready-made replacement just yet. But it’s on a path that makes sense.

---

## 6. What Lynx Tells Us About the State of Mobile Development
> **Summary:** Lynx reflects a broader shift: teams want more from their tools, and they’re willing to build their own when existing options fall short.

Lynx isn’t just a new option. It’s a signal.

It shows us that for some teams — even the ones with all the resources in the world — the existing tools weren’t enough. React Native had limitations. Flutter didn’t fit the workflow. So ByteDance built something else.

That doesn’t mean Lynx will take over. But it raises the bar. It challenges assumptions. And it opens the door for better ways of thinking about performance, flexibility, and ownership in mobile development.

Whether or not it wins, it moves the conversation forward. And that’s always worth paying attention to.

---

## FAQ: Lynx vs React Native vs Flutter

### What is Lynx?
Lynx is a JavaScript-to-native mobile framework created by ByteDance. It allows developers to build native mobile apps using modern JavaScript frameworks like React, Vue, or Svelte — while rendering real native components and prioritizing performance.

### Is Lynx a React Native replacement?
Yes — Lynx directly competes with React Native. Both aim to bridge the gap between web and mobile development using JavaScript. But Lynx differentiates itself with native rendering, background-threaded APIs, and framework-agnostic design.

### How is Lynx different from Flutter?
Flutter uses its own rendering engine and Dart programming language. Lynx, on the other hand, leverages JavaScript and renders native components. Flutter is often preferred by mobile-native teams; Lynx is more approachable for web developers.

### Why did ByteDance build Lynx instead of using React Native?
ByteDance likely wanted more performance, more flexibility, and more control than React Native could offer. Owning the framework means they can steer its roadmap without relying on Facebook’s priorities.

### Should my team consider Lynx?
If you’re starting fresh and already work in the JavaScript ecosystem, Lynx could be a compelling choice. But it’s still early — so be prepared for lighter documentation and fewer community libraries compared to React Native or Flutter.


Why Bytedance Built Lynx Header

ByteDance skipped both React Native and Flutter — and built Lynx instead. Here’s why their new framework exists, what it offers, and where it might be headed.

Why ByteDance Built Lynx Instead of Using React Native or Flutter

Why Bytedance Built Lynx Thumb

Why ByteDance Built Lynx? Because React Native Left a Gap

### **Why Messaging Compliance Starts with Data Residency**

If your product sends notifications—email, SMS, push, or in-app—those messages likely include personal or sensitive information. And that means they’re subject to data protection laws.

What many teams overlook is that compliance isn’t just about how messages are sent—it’s about where the data resides before, during, and after delivery. Countries and regions like the EU, Germany, Australia, and Japan have introduced strict regulations requiring customer data to be stored and processed within local or regional borders. This makes data residency a core requirement for any compliant messaging infrastructure.

If your notification infrastructure doesn’t support regional data controls, you’re not just risking fines—you’re exposing yourself to latency issues, deliverability failures, and trust erosion with users and enterprise buyers.

Courier has you covered. We help product and platform teams solve this from the start. Our infrastructure is designed to keep notification data fully homed within the regions you serve—starting with the US and EU, and expanding into Australia, and beyond. And if you’re operating in multiple markets, Courier supports fully isolated environments across regions—so your teams can stay compliant everywhere without sharing infrastructure.

---

### **What Happens If Your Messaging Platform Ignores Data Residency**

Most teams don’t realize they have a data residency problem until it blocks a deal, triggers a legal review, or worse—causes a regulatory violation.

#### **📉 Regulatory Risk**

Laws like GDPR, HIPAA, Japan’s APPI, and Australia’s Privacy Act impose strict rules around where user data can be stored and processed. If your platform moves or stores message data outside the user’s region—without proper safeguards—you could face investigations, fines, or forced feature rollbacks.

#### **👱️ Poor Performance and Latency**

If your servers are thousands of miles away from your users, your notifications will be slower—sometimes noticeably so. That hurts user experience, especially for time-sensitive messages like password resets, OTPs, or critical system alerts.

#### **❌ Deliverability and Filtering Issues**

Some regions penalize international traffic more heavily. Using out-of-region IPs or SMS routes can hurt your sender reputation, trigger spam filters, or lead to blocked or delayed messages—especially for high-volume or transactional communications.

#### **🤝 Lost Trust and Blocked Deals**

Enterprise buyers (especially in healthcare, finance, and government) often require vendors to keep data within specific jurisdictions. If you can’t meet that requirement, your platform may get disqualified before a proof-of-concept even starts.

---

### **Common Messaging Compliance Challenges for Product Teams**

The path to notification compliance across regions is filled with obstacles. Here are the most common ones:

#### **Routing and Partitioning Data by Region**

Storing and processing notification data in the right region sounds simple—until you have users in 20+ countries. You’ll need to route messages to the correct infrastructure, isolate user records by region, and ensure no cross-region leakage in logs, metadata, or error handling.

#### **Maintaining Performance While Staying Compliant**

Even when infrastructure is isolated, latency becomes a factor. Routing messages through distant regions or providers can slow down time-sensitive notifications (like OTPs or critical alerts).

#### **Lack of Vendor Flexibility**

Many notification providers only operate from a single region (often the US). If they don’t support data residency controls, your options are either to risk non-compliance or build and host your own regional stack.

#### **Enterprise Security and Legal Reviews**

If you're selling to enterprise or regulated sectors (finance, health, government), expect rigorous security, privacy, and compliance reviews. Data residency is a common blocker.

---

### **How Courier Solves Notification Compliance at Scale**

Courier provides the foundation for compliant notification infrastructure.

#### **Regionally Isolated Infrastructure (US, EU, AU)**

Courier operates fully isolated environments in the US and EU today, with expansion into Australia underway. Each environment ensures that all customer data—user profiles, message content, delivery logs—stays entirely within the selected region.

#### **Built on AWS for Global Flexibility**

We leverage AWS’s global footprint to provision new regions quickly and reliably. That means as regulatory requirements evolve—or as our customers expand—we can stand up new, compliant regions fast, without re-architecting the product.

#### **Simple Region Selection, No DevOps Required**

Developers can assign users to a specific region with simple configuration—no need to manage infrastructure, set up routing logic, or build data silos manually.

#### **Designed for Compliance Teams and Developers Alike**

We provide full transparency into how and where your data is handled, making it easier to pass legal and security reviews.

---

### **Operating Across Multiple Regions with Courier**

Courier doesn’t just support a single region—it empowers global scale.

For global businesses, data residency isn’t just about selecting one region—it’s about operating across several while maintaining strict boundaries. Courier supports multi-region architectures by allowing teams to deploy separate, fully isolated instances in each required geography.

This means your team can:

* Serve customers in the EU and US from distinct environments with no cross-region data flow  
* Log into region-specific Courier workspaces, each compliant with local data regulations  
* Maintain independent access controls, logs, and integrations per geography

By spinning up dedicated instances where needed, you can expand into regulated markets like Australia or Japan without legal friction or shared infrastructure risk. Courier gives you the operational flexibility to scale globally while keeping every region’s data compliant and self-contained.

---

### **The Business Value of Regional Notification Infrastructure**

Here’s what regional compliance unlocks for your team and business:

#### **Accelerate Enterprise Sales Cycles**

If you can’t confidently answer “Where is this data stored?”—you may not even make it to the pilot phase. Courier helps customers pass security reviews and meet buyer expectations without delays.

#### **Lower Legal and Engineering Overhead**

Without built-in data residency, every new customer region becomes a legal and technical project. With Courier, you configure the region—Courier handles the rest.

#### **Improve Message Delivery and UX**

Regional infrastructure reduces latency and improves deliverability, particularly for time-sensitive messages like account verification, fraud alerts, or transaction confirmations.

#### **Demonstrate Respect for User Privacy**

Keeping data in-region builds trust and helps customers meet their own compliance obligations. Courier helps you operationalize that trust with infrastructure that matches your audience.

---

### **Global Notification Compliance Requirements You Need to Know**

Understanding regional laws is essential to compliance. Here’s a breakdown of the key frameworks:

#### **🇪🇺 GDPR (European Union)**

Under GDPR, any personal data—names, email addresses, IPs, behavioral triggers—must be protected under strict legal conditions. Notifications often involve these data points, and GDPR explicitly regulates both the content and the location of that data.

**Key considerations:**

* You must have a lawful basis (like consent or contractual necessity) to send a notification.  
* If notification data leaves the EU, you need legal safeguards (like Standard Contractual Clauses).  
* Many EU customers now expect data to stay within the EU—residency builds trust and avoids risk.

#### **🇬🇧 UK GDPR (United Kingdom)**

After Brexit, the UK adopted its own version of GDPR. It mirrors the EU framework but is managed by a separate authority (ICO) and may diverge over time.

**Key considerations:**

* You must comply with UK-specific requirements for consent, data transfers, and user rights.  
* Cross-border data transfers from the UK to non-adequate countries require legal safeguards.  
* UK-based enterprises increasingly request local hosting to simplify procurement and risk reviews.

#### **🇺🇸 HIPAA (United States \- Healthcare)**

If your notifications include protected health information (PHI)—like appointment reminders or test results—HIPAA applies. It sets strict rules for how that data is stored, accessed, and transmitted.

**Key considerations:**

* All systems involved in handling PHI must meet HIPAA technical safeguards: encryption, audit logging, access controls, etc.  
* Data must be stored within the United States unless explicitly authorized.  
* Covered entities often require vendors to sign a Business Associate Agreement (BAA) and verify infrastructure compliance.

#### **🇦🇺 Australia’s Privacy Act**

Australia’s Privacy Act holds businesses accountable for overseas data transfers. While not a strict localization law, it places the burden of proof on organizations to ensure data is protected abroad. In practice, many industries—especially healthcare, government, and financial services—require local hosting as part of their vendor review process.

**Key considerations:**

* You must ensure “comparable protection” if data is sent overseas.  
* Local hosting is often expected to meet public-sector, healthcare, and enterprise procurement standards.

#### **🇯🇵 Japan’s APPI**

Japan’s Act on the Protection of Personal Information (APPI) regulates how personal data is collected and shared. It places particular emphasis on consent and transparency for cross-border transfers.

**Key considerations:**

* You must obtain prior, explicit consent to store or process data outside Japan.  
* Local hosting is often required by enterprise buyers to avoid legal friction.  
* Residency simplifies compliance and signals trustworthiness to Japanese users.

#### **🇨🇦 Canada’s PIPEDA**

Canada’s PIPEDA allows cross-border transfers but requires companies to ensure equivalent protection and inform users.

**Key considerations:**

* Transparency is mandatory when storing or processing data outside Canada.  
* Some provinces (e.g., British Columbia, Nova Scotia) enforce data residency for public-sector and healthcare data.  
* Hosting notifications in-country reduces legal review cycles and procurement friction.

#### **🇸🇬 Singapore’s PDPA**

Singapore’s Personal Data Protection Act permits data transfers abroad, provided the receiving country offers comparable protection.

**Key considerations:**

* You must assess and document the adequacy of data protection in the destination country.  
* Local hosting is preferred by many financial institutions and regulators.

#### **🇧🇷 Brazil’s LGPD**

Brazil’s LGPD applies to any business collecting or processing Brazilian user data. While not a strict localization law, it has GDPR-style transparency, consent, and transfer requirements.

**Key considerations:**

* Transfers outside Brazil require safeguards like standard clauses or adequacy decisions.  
* Customers increasingly expect infrastructure that supports local data handling.  
* Regional data hosting signals compliance and builds trust with Brazilian users.

---

### **Summary**

Data residency is no longer a "nice-to-have"—it's a regulatory, operational, and commercial necessity. With strict compliance frameworks like GDPR, HIPAA, and APPI in place globally, companies must ensure their notification infrastructure respects regional data laws. Failing to do so risks legal penalties, performance issues, and lost customer trust. Courier solves this by offering fully isolated regional infrastructure, giving you compliance without sacrificing speed or developer velocity. From the US and EU to Australia and beyond, Courier helps you deliver notifications where your users are—and where their data is legally required to stay.

---

### **Frequently Asked Questions (FAQ)**

#### **What is data residency in the context of notifications?**

Data residency refers to storing and processing user data—including notification content and logs—within a specific geographic region, often due to legal or regulatory requirements.

#### **Why does data residency matter for email, SMS, or push notifications?**

These messages often include personal information and fall under data protection laws. Storing or routing them outside the user's region can violate laws like GDPR or HIPAA.

#### **Which laws require data residency?**

Key frameworks include:

* GDPR (EU)  
* UK GDPR  
* HIPAA (US Healthcare)  
* Australia Privacy Act  
* Japan APPI  
* Canada PIPEDA (in some provinces)  
* Singapore PDPA  
* Brazil LGPD

#### **Does Courier support data residency?**

Yes. Courier offers fully isolated infrastructure in the US and EU today, with Australia launching soon. Customer data can be fully homed in-region.

#### **Can I control where my data is stored with Courier?**

Yes. You can assign users and notifications to a specific region during configuration—Courier ensures that data remains fully isolated within that environment.

#### **How does data residency impact notification performance?**

Regional infrastructure reduces latency, improves deliverability, and provides better user experiences—especially for time-sensitive messages like OTPs or system alerts.

#### **Is data residency required by law?**

Not always, but it's increasingly expected—especially in enterprise deals and regulated industries. It also simplifies legal review, procurement, and compliance documentation.


Why Data Residency is Crucial for Customer Notifications - Header

Data residency is critical for messaging compliance. Learn how Courier helps you meet regional laws like GDPR, HIPAA, and APPI with isolated infrastructure.

Why Data Residency Matters for Notifications – And How Courier Solves It

Why Data Residency is Crucial for Customer Notifications - Thumb

Why Data Residency is Crucial for Customer Notifications

We’ve just released version 5.7.3 of the Courier iOS SDK — a major update for teams using **Courier Inbox** to power in-app notifications on iOS.

📘 [View on GitHub](https://github.com/trycourier/courier-ios)

This release improves performance, reliability, and gives you more flexibility to build the experience you want.

---

### Highlights

**Stronger socket connection handling**  
Real-time delivery is now more reliable when switching between foreground and background — ideal for mobile apps with dynamic in-app messaging.

**New threading model with `CourierActor`**  
All `Courier.shared` functionality now runs on a dedicated thread called `CourierActor`. This keeps SDK work off the main thread and improves performance across the board.

**Fully rebuilt inbox datastore**  
We’ve rebuilt how messages and events are stored and managed — all now handled exclusively within the `CourierActor`. This ensures greater reliability and data accuracy.

**Simplified listener events**  
Listening for inbox updates is easier than ever. The new `onMessageEvent` callback lets you respond to message-level events — giving you the tools to build custom UIs without added complexity.

**More tests, more confidence**  
We added new unit and integration tests to back these updates and support future releases.

📘 [View on GitHub](https://github.com/trycourier/courier-ios)


ios sdk update header

Courier iOS SDK 5.7.3 adds better socket handling, a rebuilt inbox datastore, and a new event listener for custom in-app notification UIs.

Courier Inbox iOS SDK 5.7.3 – Improved Reliability and New Listener API

ios sdk update thumb

Search is evolving—and fast. At Courier, we’ve started to see a shift in how users are finding us.

Google still dominates product discovery. It remains the primary starting point for most users—and for most products, the largest source of referral traffic.

But something new is happening.

Over the past six months, ChatGPT has become a meaningful source of inbound traffic. It has already overtaken DuckDuckGo in our referral data and, at its current pace, will surpass Bing this year.

Perplexity showed early promise and gained traction among technical users, but its growth has since plateaued. We’ll come back to that.

Other tools, like Anthropic’s Claude, have recently introduced web search capabilities, but they barely register in our data. This shift isn’t about AI in general—it’s about a very specific change in behavior: people are using ChatGPT to find and access products directly.

And that’s starting to show up in the numbers. Here’s a breakdown of referral traffic from AI chat tools compared to DuckDuckGo, our lowest-performing search engine.

![AI Assistant Traffic Referral Sources](//images.ctfassets.net/z7iqk1q8njt4/7mYKFgX13UVN9lrCkWYbZX/d420fc706619aff362725ecd0286ec7e/AI_Assistant_Traffic_Source_1.png)

---

## ChatGPT Is Becoming a Discovery Surface

When traffic from ChatGPT first appeared, it was a novelty. But since late 2024, that trickle has turned into a steady, measurable trend.

Month over month, ChatGPT has grown faster than any other non-Google source.

Today, it’s not just outpacing DuckDuckGo—it’s catching up to Bing. And this isn’t the result of a one-time spike. It reflects a real shift in how users are finding products.

This isn’t something to watch passively. It’s time to treat ChatGPT the way you treat search engines. The mechanics are different, but the effect is the same: visibility matters. The more clearly and authoritatively your product shows up in AI-generated answers, the more likely it is users will click through and engage.

---

## ChatGPT vs. Bing: The Gap Is Closing

Bing has been a steady, if modest, source of referral traffic for years. But ChatGPT is closing in—fast. If trends hold, it will overtake Bing within the next six months.

That said, our data may reflect the nature of our product. Courier is built for developers and product teams—audiences who are often ahead of the curve in adopting new tools like ChatGPT. Our content also aligns well with the kinds of queries AI tools can answer today: implementation questions, comparisons, integration how-tos.

That might not be true yet for other products... yet. As search models improve and user behavior shifts, we expect this pattern to extend well beyond technical categories.

---

## Perplexity: Early Traction, Then a Plateau

Perplexity was one of the first AI tools we saw show up in our referral data. It gained traction quickly and briefly looked like it could become a meaningful channel.

But since then, growth has stalled. Traffic from Perplexity has remained flat, even as ChatGPT continues to climb.

The most likely reason comes down to brand and distribution. ChatGPT benefits from massive exposure and widely regarded as the default AI interface. Perplexity, while respected in certain circles, doesn’t have the same reach or default presence.

It still appears in our data—but it’s not growing. That’s not a good sign for Perplexity’s long-term relevance as a discovery surface.

---

## Claude: Present in the Market, Absent in the Data

Anthropic’s Claude has been in the market a while but it’s the lowest by far among the AI assistants we track (we're giving Grok a pass for now). 

This isn’t surprising. The dominant way Claude is used today is through its API, not its user interface. That may change over time. But today, Claude simply isn't showing up as part of the product discovery journey—not in any meaningful volume.

---

## Google Still Dominates—But It’s No Longer Alone

Google continues to drive the majority of our discovery traffic. That hasn’t changed.

But the landscape around it is shifting. ChatGPT is now a serious alternative. And even Google is adapting. Gemini—Google’s own AI assistant—has started to appear in our referral data. It’s still small, but it’s growing. AI-assisted search is clearly becoming a core part of Google’s future.

For now, Google remains dominant. However, AI assistants are no longer a novelty—they’re becoming the new front door to the internet.


AI Is Changing How Users Discover Products Header

ChatGPT is becoming a real source of traffic. It’s already passed DuckDuckGo—and it’s on track to overtake Bing. Here’s what we’re seeing.

AI Is Changing How Users Discover Products

AI Is Changing How Users Discover Products Thumb

Jon, one of our sales engineers, got a request during a customer implementation: could we customize Inbox, Courier's in-app messaging product, to look and feel like an email client? A two-pane layout—message list on the left, selected content on the right.

That’s a little different from Courier’s default Inbox UI, which is more of a pop-over notification center. But that’s not a problem. Courier was built to be customized. With our React Hooks SDK, teams can take full control—layout, styling, behavior—without rebuilding core logic from scratch.

Jon could’ve spent a few hours wiring things up. Instead, he tried something faster. He dropped our SDK docs and a short prompt into **ChatGPT**, and 15 minutes later, had a fully working prototype.

This post is about how AI helped solve a real-world implementation challenge—fast—and how Courier makes it easy to build custom in-app messaging experiences.

---

## Courier Inbox: Flexible by Design

Out of the box, Courier Inbox gives teams a clean, brandable notification center they can drop into their app with just a few lines of code. It supports all the essentials—mark as read, archive, unread counts, real-time updates—and looks great with minimal setup.

But not every product wants the same thing. Some teams want a slide-out drawer. Others want a modal. And in this case, the request was for a full two-pane layout that matched the customer’s existing design system.

That’s exactly what our [React Hooks SDK](https://www.courier.com/docs/sdk-libraries/client-sdks/react-sdk) was made for. It gives developers access to the full inbox state and methods—without forcing them to use our UI. You get the power of Courier, and complete control over how it's presented.

---

## Customizing Courier to Meet Your Needs

The request was clear: build an in-app notification inbox that looked and worked like email. Message list on the left, content pane on the right. Something that felt native to their app—not tacked on.

Jon knew Courier’s default UI wouldn’t be the right fit here. But with the Hooks SDK, he had everything he needed: access to messages, preferences, state management, and all the methods—mark as read, unread, archive, delete—already built and tested.

The only thing missing was the UI itself. That’s where **AI** came in.

Instead of manually piecing together a React app from scratch, Jon tried something new. He gave **ChatGPT** a prompt describing the layout, pasted in the Hooks SDK README, and hit enter.

---

## Using ChatGPT to Build a Custom Inbox Fast 

The goal was to get a working prototype that he could hand over to the customer as a starting point. Jon wrote a short prompt:

![ChatGPT+Courier Prompt](//images.ctfassets.net/z7iqk1q8njt4/42dzjwgGbCMQovBtzXxAXI/efd6a207128594c0c6106aa4db03575a/ChatGPT_Courier.png)

Along with that, he pasted in the README from the React Hooks SDK. That was it.

**ChatGPT** responded with step-by-step instructions:
- Set up a new React project
- Install the necessary Courier packages
- Use the inbox hooks to fetch messages and state
- Build a layout with a sidebar list and message content pane
- Add logic for selecting messages and marking them as read
- Deploy to GitHub Pages

The first version worked. In 15 minutes, Jon had a custom inbox UI that looked and behaved the way the customer wanted—backed by live data from Courier.

He made a few small tweaks to clean up the layout, but most of the work was already done. And the code was readable enough that any front-end engineer could pick it up and make it production-ready with minimal effort.

![Email Inbox Prototype](//images.ctfassets.net/z7iqk1q8njt4/6XbrlBSoj6dE0FUJzF2WQ6/224c0c8d9eca44a73c8e065f16e2ab45/Email_Inbox_Prototype.png)

---

## From Proof of Concept to Production-Ready

This wasn’t just a cool experiment with AI—it was a glimpse at how fast teams can move when the right tools are in place.

Courier’s Hooks SDK already exposes everything a developer needs—message state, preferences, real-time events, and inbox methods. With **ChatGPT’s help**, Jon turned that API surface into a functional UI in minutes.

That’s a big unlock for sales engineers. But it’s just as useful for product teams and platform engineers. If you want to:
- Match your app’s UX and brand
- Embed a notification system directly into your layout
- Build features like search, filters, swipe actions, or pinned messages

You don’t have to start from scratch. With Courier and AI, you can move fast, prototype faster, and still keep full control of the user experience.

---

## Brainstorming with AI

After shipping the prototype, Jon asked ChatGPT a follow-up:

> “What are some creative UI applications of these hooks that we might not be thinking of yet?”

It came back with a list of UI ideas for in-app messaging:
- Drag-and-drop notifications
- Swipable cards for mobile
- Persistent side drawers
- Timeline view
- Custom filtering and search
- Dark mode and dynamic theming

None of these ideas required modifying Courier’s backend. The SDK already exposes everything. All you need to do is bring your UI to life—something **AI tools like ChatGPT** are surprisingly good at helping with.

---

## From Docs to Working UI in Minutes with AI

This was a real implementation request. And thanks to Courier and ChatGPT, it turned into a working solution in 15 minutes.

Courier gives you the foundation: powerful SDKs, real-time infrastructure, and control over every part of the notification experience. **AI tools like ChatGPT** help you move faster—turning docs into working code, bridging the gap between idea and implementation.

Jon didn’t write much code. He didn’t need to. Courier handled the backend. ChatGPT handled the boilerplate. All he had to do was tweak the layout and ship the link.

If you're building a custom notification experience—something that fits your app, your users, your brand—Courier makes it easy. And now, with AI in the loop, it’s faster than ever.

---

## Resources

- [Courier React SDK Documentation](https://www.courier.com/docs/sdk-libraries/client-sdks/react-sdk)
- [GitHub – Courier React Hooks](https://github.com/trycourier/courier-react/tree/main/packages/react-hooks)
- [Getting Started with Inbox](https://www.courier.com/docs/inbox/overview/)
- [How to Customize Inbox with React Hooks](https://www.courier.com/docs/platform/inbox/web/react-sdk#react-hooks)

## FAQ: Building Custom In-App Notifications with Courier and ChatGPT

### What is Courier and how does it help with in-app notifications?

Courier is a notification infrastructure platform that lets developers send messages across multiple channels—email, SMS, push, chat, and in-app. With [Courier Inbox](https://www.courier.com/docs/platform/inbox/intro), you can add a notification center to your app in minutes. It works out of the box or can be fully customized using the React Hooks SDK.

---

### Can I build a custom in-app notification UI with Courier?

Yes. Courier’s [React Hooks SDK](https://www.courier.com/docs/sdk-libraries/client-sdks/react-sdk) gives you full control over your notification UI. You can build any layout using your own components and styles, while still taking advantage of Courier’s backend logic—like message delivery, unread states, and user preferences.

---

### How does ChatGPT help with building in-app notifications?

ChatGPT can accelerate development by converting documentation and prompts into working React code. In this case, a sales engineer used ChatGPT to build a two-pane inbox layout using Courier’s SDK. With just a short prompt and a copy of the SDK README, ChatGPT generated a fully functional prototype—including layout, logic, and live data handling.

---

### Is it possible to create a Gmail-style inbox using Courier?

Yes. You can use Courier’s Hooks SDK to build a Gmail-style two-pane layout:
- Messages list on the left  
- Selected message content on the right  
- All backed by Courier’s real-time infrastructure

This layout was built in under 15 minutes using React and ChatGPT.

---

### Do I need a backend to use Courier Inbox?

No. Courier provides the backend infrastructure for notification delivery and state management. The React SDK lets you build fully custom frontends without needing to build or maintain your own backend notification system.

---

### What are the benefits of using Courier and ChatGPT together?

Combining Courier’s developer-friendly SDKs with generative AI tools like ChatGPT allows teams to:
- Rapidly prototype custom notification centers  
- Generate React components using natural language  
- Speed up implementation and reduce boilerplate  
- Deliver working UIs backed by live data in minutes

---

### Can ChatGPT generate production-ready code using Courier?

ChatGPT can generate well-structured, readable React code using Courier’s SDKs—especially when given a good prompt and documentation. While the output is great for prototyping, it should be reviewed and tested before using in production.

---

### What kinds of custom notification UIs can I build with Courier?

Courier supports nearly any notification UI pattern you can think of, including:
- Two-pane layouts (like Gmail or Outlook)  
- Slide-in drawers and side panels  
- Full-screen inboxes with filtering and search  
- Mobile-first designs with swipe actions  
- Timelines, pinning, and priority inboxes  
- Theme-aware dark mode UIs

---

### How long does it take to build a custom notification center?

With Courier and ChatGPT, a working in-app notification center can be built in under **15 minutes**. In the blog example, a sales engineer created a fully functional UI with live data using a single prompt and the React Hooks SDK.

ChatGPT+Courier Header

See how you can use Courier’s React Hooks SDK and ChatGPT to build a custom two-pane in-app messaging UI in just 15 minutes

Build a Custom In-App Inbox in 15 Minutes with Courier and ChatGPT

ChatGPT+Courier Thumb

Build Custom In-App Notifications in 15 Minutes with Courier and ChatGPT

In 2025, developers building cross-platform mobile apps face three main contenders: ByteDance's Lynx, Meta's React Native, and Google's Flutter. Each framework offers a different approach to the same challenge: how to build high-quality apps that work across platforms while keeping development efficient.

Lynx, newly open-sourced by ByteDance in March 2025, emerged from TikTok's performance needs. It features an innovative dual-thread JavaScript engine and embraces web standards with full CSS support. React Native continues to be the go-to solution for JavaScript developers, with its improved architecture and massive ecosystem. Flutter has gained significant traction with its Dart-based approach that ensures consistent visuals across all platforms.

This comparison examines how these frameworks stack up in terms of technical architecture, developer experience, and real-world adoption. For development teams, the best choice depends on your existing skills, performance requirements, and which platforms you're targeting.

While React Native and Flutter dominate with their mature ecosystems, Lynx brings fresh ideas to the table that could change how we approach cross-platform development. Let's explore what makes each framework unique and which might be the right fit for your next project.

We explore this more deeply in [Why ByteDance Built Lynx (Because React Native Left a Gap)](https://www.courier.com/blog/why-bytedance-built-lynx-because-react-native-left-a-gap).

## **Cross-Platform Development Comparison**

| Feature | Lynx | React Native | Flutter |
| :---- | :---- | :---- | :---- |
| **Origin** | ByteDance (TikTok's parent company), open-sourced in 2025 | Facebook (Meta), launched in 2015 | Google, stable since 2018 |
| **Purpose** | Performance-first approach for native apps using web technologies | Unify web and mobile development using JavaScript and React | High-performance UI toolkit for consistent cross-platform UIs using Dart |
| **Technical Architecture** | Dual-thread architecture: PrimJS on main thread (UI), QuickJS in background (logic) | JavaScript bridge (historically), improved with Hermes engine and Fabric architecture | Custom Skia/Impeller rendering engine controlling every pixel |
| **Rendering Approach** | Native UI components by default; also supports custom pixel-perfect rendering mode | Native UI components, ensuring platform look and feel | Custom rendering (controls every pixel) for consistent UIs |
| **Performance Features** | Instant First-Frame Rendering (IFR), Main Thread Script (MTS) for synchronous UI updates, 60fps+ animations | Improved with Hermes engine, requires optimizations like interaction manager for heavy work | GPU-accelerated rendering, JIT/AOT compiled Dart, generally smooth 60fps UI |
| **App Size & Overhead** | Lightweight: QuickJS engine (\~\<1MB) \+ Lynx core | Moderate: requires JS VM and bundle, typically a few MB | Larger: includes Dart runtime and Skia engine, "Hello World" can be 5-10+ MB |
| **Platform Coverage** | Mobile (Android/iOS) and Web officially, with experimental desktop support | Mobile (Android/iOS) officially, Web via React Native Web, unofficial desktop support | Mobile, Web, and Desktop (Windows, macOS, Linux) all officially supported |
| **UI Definition** | JSX/HTML-like syntax with tags and standard CSS/SCSS (including flexbox, grid, animations) | JSX components with limited CSS-like styling | Dart code with widget trees, no HTML/CSS |
| **Styling Capabilities** | Full CSS support including selectors, media queries, animations; can use Tailwind CSS | Limited CSS subset, styling via JavaScript objects | No CSS, UI styled through Dart code and widget properties |
| **Framework Compatibility** | Framework-agnostic with React bindings at launch; plans for Vue and Svelte support | Tied to React framework | Flutter's own framework and widget system |
| **Developer Experience** | Web-like workflow, Chrome DevTools-style debugging, Rspack bundler, fast refresh | Fast Refresh, debugging via Chrome DevTools or Flipper, optionally Expo for easier setup | Hot Reload, comprehensive DevTools, requires learning Dart |
| **Ecosystem & Community** | Limited and nascent; few third-party libraries | Mature with thousands of npm packages, large active community | Strong and growing, official and community packages on pub.dev |
| **Real-world Adoption** | Used in TikTok (Search, Shopping, Live streaming features) | Widely adopted (Instagram, Walmart, UberEats, Bloomberg), \~38% of cross-platform devs | Growing adoption (Alibaba, Google Pay, eBay, BMW), \~42% of cross-platform devs |
| **Integration in Existing Apps** | Designed for incremental adoption, proven in TikTok's hybrid approach | Supports incremental adoption in existing native apps | Add-to-app API but typically heavier integration |
| **Unique Strengths** | • Web-native approach with low learning curve • High-performance UI without sacrificing native components • Flexible rendering options (native or custom) • Full CSS support | • Massive ecosystem and community support • Leverages React knowledge and JS ecosystem • Native look and feel by default • Large talent pool available | • Consistent UI across all platforms • Superior performance for complex graphics • Comprehensive platform support • Strong tooling integration |
| **Best For** | • Web developers building native apps • Apps needing smooth handling of rich dynamic content • Projects targeting Web+Mobile with unified codebase | • Teams already invested in React • Incremental adoption in existing apps • Projects needing native look and feel | • Brand-consistent UIs across platforms • Complex UIs and animations • Projects targeting multiple platforms including desktop |
| **Current Viability** | Promising technically but with uncertain adoption; needs ecosystem growth | Established with ongoing improvements, expected to remain dominant | Actively evolving with Google backing, likely to grow in presence |
| **Future Outlook** | Could remain niche or grow into a serious competitor depending on community adoption and ByteDance's continued investment | Likely to remain a top choice due to Meta backing and extensive community | Expected to expand market presence, possibly overtaking RN in some areas |

## Key Differentiators:

### Lynx:

- **Dual-thread design** separates UI and business logic for smoother performance  
- **Full CSS support** including selectors, media queries, and animations without limitations  
- **Framework agnosticism** allows for different JS frameworks beyond just React  
- **Proven at scale** within TikTok's high-traffic environment  
- **Instant First-Frame Rendering** eliminates blank screens during startup

### React Native:

- **Largest ecosystem** with solutions for almost any functionality  
- **Well-established patterns** and extensive community knowledge  
- **Incremental adoption** path proven at many companies  
- **Deep integration** with the broader React and JavaScript ecosystem

### Flutter:

- **Single language** (Dart) for all platforms  
- **Pixel-perfect consistency** across devices  
- **Comprehensive platform coverage** including official desktop support  
- **High-performance graphics** capabilities without bridging overhead

## Verdict:

Lynx introduces valuable innovations with its dual-thread architecture and web-focused approach, especially appealing to those with strong web development skills. However, its nascent ecosystem and limited adoption outside ByteDance mean it remains a niche solution for now. React Native and Flutter continue to dominate with their mature tooling and communities, with Flutter gaining momentum for new projects requiring consistent UIs across platforms.  


Lynx vs React Native vs Flutter

Lynx, React Native, and Flutter are shaping cross-platform development in 2025. Explore their performance, developer experience, and adoption.

Cross-Platform Development in 2025: Lynx vs. React Native vs. Flutter 

Building a great SaaS product isn’t just about features—it’s about keeping users engaged. You might spend months developing an amazing tool, but if users sign up, explore a few features, and then disappear, all that effort is wasted. Often, it’s not that they dislike your product; they simply forget about it or never realize its full value.

That’s where multichannel notifications come in. Well-timed, personalized messages—delivered via email,  in-app, push, SMS or even Slack—can remind users to complete onboarding, re-engage dormant accounts, and highlight key features.

## Why Notifications Matter for SaaS Retention

Imagine a developer spends months building a powerful SaaS product. Users sign up, and initial metrics look great, but over time, engagement drops. Silent churn begins—not through cancellations, but through inactivity.

Retention determines long-term success. No matter how effective your marketing and onboarding efforts are, if users aren’t consistently reminded of your product’s value, they’ll eventually move on.

## How to Prevent Churn with the Right Notifications

People get busy. Inboxes overflow, apps compete for attention, and important updates get lost.

A well-timed reminder—such as a nudge about an abandoned setup or a heads-up about new features—can pull users back in.

For example, **Workleap**, a workplace solutions platform, keeps employees engaged with timely notifications for performance reviews, feedback cycles, and collaboration updates. These nudges prevent disengagement by keeping users actively involved in their workflows.

But poorly executed notifications can be just as harmful as none at all. Too many generic alerts overwhelm users, while irrelevant messages get ignored. The key is precision—delivering the right message, through the right channel, at the right time.

> “Notifications that strike a balance between user benefit, timing, and relevancy are the most effective in SaaS products. One program I worked with saw increased engagement just by reminding users of the benefits they were receiving through weekly recaps of goals accomplished.” — Alex Ginovski, Head of Product & Engineering, Enhancv

Behavior-driven notifications—highlighting completed tasks, progress milestones, or underutilized features—remind users why they signed up in the first place.

## Why Reminders and Nudges Work

At the core of effective notifications is a simple psychological principle: **FOMO (fear of missing out).** A well-timed nudge reminds users of the value they signed up for.

Take a SaaS analytics tool. If a user hasn’t checked their dashboard in a while, a message like, *“Your traffic spiked 20% this week\! See what’s driving it”* doesn’t just inform—it piques curiosity and motivates action.

For developers, building cross-channel notifications (email, SMS, in-app, push) can be challenging. But done right, these messages drive retention and keep users engaged.

## Why a Single Notification Channel Isn’t Enough

Imagine a SaaS company launches a new feature and sends an email announcement. Days pass, but engagement barely moves—because many users never saw the email.

User churn is often due to disengagement, not dissatisfaction. Inbox overload means critical messages go unnoticed. The challenge isn’t just sending a notification—it’s reaching users where they are most likely to respond.

Look at **Twilio**—they power communications across voice, SMS, and messaging apps, ensuring critical updates aren’t missed. Managing multiple channels can get messy, which is why tools like **Courier’s Unified API** streamline the process, allowing businesses to send messages across email, push, SMS, Slack, and more—all from a single platform.

> “The best SaaS notifications aren’t simply reminders; they are nudges that actually matter. When you blast users with generic messages, you train them to ignore you. The real winners are behavior-based notifications—reminders sparked by what users actually do (or don’t do).” — Garin Hobbs, Martech Expert, InboxArmy

This is where multichannel strategies shine. A Slack alert might be perfect for a work-related reminder, while an in-app notification reinforces an action when a user logs in. The key is not just sending notifications but making them meaningful—aligned with user behavior rather than disruptive.

## Multichannel Notifications: Meeting Users Where They Are

A single channel isn’t enough. Users engage with SaaS products in different ways—some check email religiously, others prefer instant messages, and many ignore notifications unless they’re in the right context. Using multiple channels increases the chances of reaching users when they’re most receptive.

### Different Channels for Different Purposes:

- **Email:** Great for detailed updates, onboarding sequences, and re-engagement. But inboxes are crowded, and open rates can be unpredictable.  
- **SMS:** Perfect for urgent alerts like security warnings or payment failures, but overuse can feel intrusive.  
- **Push \+ In-App Notifications:** Ideal for mobile-first engagement. Push grabs attention immediately, while in-app keeps messages accessible.  
- **Slack & Teams:** Essential for work-related SaaS. A Slack notification about a pending approval or project update is often more effective than an email.

Managing push \+ in-app notifications can be complex. Solutions like **Courier Inbox** simplify this by providing a ready-to-use notification center for web and mobile apps.

## The Risk of Relying on a Single Channel

Imagine relying only on email to notify users of an expiring subscription. If the email lands in spam or is overlooked, that’s lost revenue. But if the user also receives an SMS and an in-app alert, renewal chances increase dramatically.

Similarly, relying only on push notifications can backfire—once dismissed, they vanish. A push \+ in-app strategy ensures users can always catch up on important updates.

## How Top SaaS Companies Use Multichannel Notifications to Boost Retention

SaaS companies thrive when users keep coming back. The best don’t leave engagement to chance—they use smart, multichannel notifications to guide users and reinforce habits.

### How Intercom Boosted Retention:

- **Behavioral Email Campaigns:** Step-by-step guides for users who hadn’t set up chatbots.  
- **Mobile Push for Urgency:** Support agents received push notifications when customers replied to their messages.  
- **In-App Tooltips:** Contextual prompts encouraged users to explore overlooked features.

Using the right channel for the right message helped Intercom boost retention by **15%** without overwhelming users.

### Other SaaS Companies Driving Retention:

- **Figma:** In-app tutorials guide users through complex workflows.  
- **Asana:** Milestone emails reinforce engagement.  
- **Salesforce:** Einstein Analytics sends proactive insights to re-engage users.  
- **GitHub:** Slack notifications keep developers in the workflow.  
- **Vendr:** Multi-channel renewal reminders prevent contract lapses.

## Best Practices for Smart Notifications

1. **Map User Journeys:** Identify key moments and deliver tailored messages.  
2. **Let Users Control Preferences:** Trello lets users mute specific notifications to prevent overload.  
3. **A/B Test Everything:** Grammarly refines subject lines through rigorous A/B testing.  
4. **Segment by Behavior:** Power users get advanced tips; dormant users receive re-engagement offers.

## Building a Notification Strategy That Drives Retention

Multichannel notifications aren’t just a nice-to-have—they’re a strategic necessity. By leveraging personalized onboarding, behavioral triggers, and a multi-channel approach, SaaS companies can keep users engaged and reduce churn.

**Courier** simplifies the process—offering multi-channel routing, dynamic preference management, and precise delivery windows—helping businesses transform notifications into a powerful tool for retention and growth.  


Multichannel Churn Header

Learn how multichannel notifications improve SaaS retention by delivering the right message at the right time via email, SMS, push, Slack, and more.

How Multichannel Notifications Reduce SaaS Churn and Boost Engagement

Multichannel Churn Thumb

## Easily spot issues and debug in seconds  

Good observability helps you understand what’s happening, but our previous logs made it hard to see the full picture. Debugging often meant searching, filtering, and manually piecing together trends. Spotting a spike in failures or a drop in message volume shouldn’t take that much effort.

The new logs histogram makes this easier. Instead of scanning rows of data, you get a real-time visual overview of message activity. Spikes, dips, and failures stand out instantly, so you can quickly diagnose issues and get back to work.

![Histogram for logs](//images.ctfassets.net/z7iqk1q8njt4/3d4LxBQs6Xq6YY3ACsaIee/f178f249094db7fd41b266f1997ea71f/Histograms_for_logs.png)

Now, trends are instantly visible. You can:  
- **Spot spikes and dips at a glance** instead of manually searching for patterns  
- **Jump to a specific time range** to investigate issues without adjusting multiple filters  
- **Quickly diagnose failure patterns** without scrolling through hundreds of log entries  

For example, if you notice a failure spike at **3:14 PM yesterday**, you can zoom into that period, immediately see what happened.

## How It Works  

The histogram provides an overview of message activity over time, making it easy to track volume, identify trends, and spot failures.  

- **Clear visual indicators**  
  - Green bars represent successful messages  
  - Red bars highlight failures  
- **Updates dynamically** – The histogram reflects your selected filters, ensuring you always see relevant data.  
- **Adjustable time ranges** – Quickly zoom in or out to analyze short-term issues or long-term trends.  
- **Drag a custom time range** – Investigate historical issues without manually adjusting filters. Just drag your mouse over the range you want.

![Time range drag](//images.ctfassets.net/z7iqk1q8njt4/57vO0RWy3LDzolzHxra5Vu/d7f541e935d573440c2ab1fc5271744e/Time_range_drag.gif)

Whether you're debugging a real-time incident or reviewing historical trends, the histogram helps you find what you need faster—without searching through raw logs.  

## Try It Now  

The histogram is **live now** in the Courier dashboard. If you’re already using Courier, head to [**Logs**](https://app.courier.com/logs/messages) to explore your message activity with an instant visual overview.  

We’d love to hear your feedback—let us know how the histogram improves your workflow or what you'd like to see next.  

Logs Visualization Header

Gain better observability and debug issues faster with the new logs histogram in Courier. Instantly spot trends, failures, and spikes to troubleshoot with ease.

Better Observability and Faster Debugging with the New Logs Visualization

Logs Visualization Thumbnail

## Introduction
Amazon Simple Email Service (Amazon SES) is widely used for sending emails at scale, but traditional authentication with IAM User credentials can be risky and cumbersome. Now, Courier supports **IAM Role authentication** for Amazon SES, offering a **new, more secure way** to authenticate without long-lived access keys.

This method reduces the risk of credential leakage and simplifies credential management by using **temporary, automatically rotated credentials**. If you’re already using IAM Roles in your AWS infrastructure, this update helps you **align your email authentication** with your existing security practices.

With **IAM Role authentication**, you get the same reliable email delivery from Courier—now with better security and simpler management.

---

## Why IAM Role Authentication?
Using IAM User credentials for Amazon SES has been the go-to method for many teams, but it comes with security risks and operational overhead. Long-lived credentials are **prone to accidental exposure**, and manually rotating keys is tedious and error-prone, increasing the risk of service disruptions.

**IAM Role authentication addresses these challenges by:**  
- **Eliminating the need for long-term access keys:** Courier securely assumes the IAM Role you define, using **temporary credentials** provided by AWS Security Token Service (STS).  
- **Enhancing security:** Temporary credentials are short-lived and automatically rotated, reducing the attack surface and risk of credential leakage.  
- **Simplifying permission management:** If you’re already using IAM Roles for other AWS services, this method lets you **centralize access control**, making administration simpler and more consistent.  

By supporting IAM Role authentication, Courier gives you the flexibility to choose the authentication method that best fits your security requirements and operational practices.

---

## How It Works in Courier
Setting up IAM Role authentication in Courier is **secure and straightforward**:  
1. **Create an IAM Role** – Define an IAM Role in AWS with the necessary permissions for Amazon SES.  
2. **Allow Courier to Assume the Role** – Set up the trust policy to allow Courier to assume the role, enabling temporary credentials through AWS STS.  
3. **Configure Courier** – Link the IAM Role in your Courier account. No long-term keys needed, making this a **keyless and more secure** solution.  

**Key benefits:**  
- **Temporary Credentials**: Courier requests temporary credentials for each email, avoiding the need to store long-term keys.  
- **Automatic Rotation**: AWS handles rotation of these temporary credentials automatically.  
- **Seamless Integration**: Works behind the scenes—your email delivery continues without interruption.  

For detailed setup instructions, visit our **Courier setup instructions** for [AWS SES IAM Role authentication](https://www.courier.com/docs/external-integrations/email/aws-ses#authentication-methods).

---

## Who Should Use This?
IAM Role authentication is ideal for teams that want to:  
- **Improve Security**: Eliminate long-term keys and reduce the risk of exposure.  
- **Simplify Management**: Use AWS-native roles for centralized access control.  
- **Follow Cloud Security Best Practices**: Align with AWS’s recommended security practices.  
- **Scale Efficiently**: Centralized permissions make it easier to manage growing teams and environments.  

This is an **optional** authentication method—you can continue using IAM User credentials if they suit your needs. However, if security and operational efficiency are priorities, IAM Roles are worth considering.

---

## Get Started with IAM Role Authentication
**IAM Role authentication for Amazon SES is now available** in Courier. It enhances security with temporary credentials and simplifies credential management without requiring changes to your existing email templates or workflows.  

**Ready to try it?** Setup is quick and easy. Visit our **Courier setup instructions** for [AWS SES IAM Role authentication](https://www.courier.com/docs/external-integrations/email/aws-ses#authentication-methods).

Amazon SES Header

Improve security with IAM Role authentication for AWS SES in Courier. No long-term keys, automatic credential rotation, and seamless integration.

Secure AWS SES Authentication with IAM Roles | Courier

Amazon SES - Thumbnail

A More Secure Way to Authenticate AWS SES in Courier – IAM Role Support

## **Introduction**

Firebase Dynamic Links (FDL) have long been a go-to solution for developers looking to create seamless deep linking experiences across mobile apps, websites, and multi-channel notifications. Whether through push notifications, SMS, or email, FDL allowed apps to direct users to the right in-app content, even handling complex scenarios like deferred deep linking for new installs.

However, Google has officially announced that **Firebase Dynamic Links will be fully shut down on August 25, 2025**. This means that any links powered by FDL will stop working after that date, potentially causing major disruptions for developers who haven’t migrated to an alternative solution.

In this post, we’ll explore the impact of this deprecation, its consequences for deep linking in notifications, and how developers can transition to new deep linking strategies.

---

## **Why Firebase Dynamic Links Mattered**

FDL was a critical tool for developers because it simplified the deep linking experience across multiple platforms and communication channels. Some of its key benefits included:

* **Seamless Deep Linking**: Whether a user was coming from a push notification, SMS, or email, FDL ensured they were directed to the right in-app content, regardless of whether they had the app installed.  
* **Deferred Deep Linking**: Users who didn’t have the app installed were first sent to the App Store or Play Store. Upon installation, FDL continued the deep link journey, opening the intended content.  
* **Multi-Channel Support**: FDL worked well across push notifications, SMS marketing, and email campaigns, making it a versatile option for user engagement and retention.  
* **Tracking & Analytics**: Firebase provided insights into link performance, user acquisition, and conversion tracking.

The deprecation of FDL means that developers now need to rethink how they handle deep linking across these critical channels.

---

## **The Impact of the Sunset**

The shutdown of Firebase Dynamic Links comes with several major challenges:

* **Existing Links Will Stop Working**: After **August 25, 2025**, all FDL-powered links will **break**, meaning they will no longer open apps or redirect users as expected.  
* **Deep Linking in Notifications at Risk**: Push notifications, SMS, and emails that rely on FDL will fail to direct users correctly, leading to broken experiences and potential drops in engagement.  
* **Google’s Migration Recommendations Have Limitations**: Google suggests transitioning to **Android App Links** and **iOS Universal Links**, but these come with setup complexities and may not fully replace all of FDL’s capabilities.  
* **Impact on Deferred Deep Linking**: Without FDL, developers need alternative solutions to handle deep links when a user installs the app for the first time.

With this in mind, it’s crucial for teams to explore and implement new deep linking strategies before the deadline.

---

## **What’s Next for Deep Linking in Notifications?**

### **Push Notifications**

To ensure deep links continue to work in push notifications:

* Replace FDL with **Android App Links** and **iOS Universal Links**.  
* Update your notification payloads to use these new links.  
* Ensure your app is properly configured to handle incoming deep links.

### **SMS Links**

For SMS-based deep links:

* Use custom short links pointing to your own domain.  
* Implement a redirect service that detects whether the user has the app installed and routes them accordingly.  
* Consider third-party deep linking services that offer better tracking and install attribution.

### **Email & Other Channels**

For email and cross-platform deep linking:

* Utilize **universal deep links** that work across platforms.  
* Ensure web fallback pages are properly set up for users without the app installed.  
* Maintain tracking capabilities using tools like UTM parameters or third-party deep link platforms.

---

## **Alternative Deep Linking Solutions**

As Firebase Dynamic Links are phased out, developers have several alternative deep linking strategies:

### **1\. Apple Universal Links & Android App Links**

These native deep linking mechanisms are **Google’s recommended approach**. However, they require:

* Hosting `apple-app-site-association` and `assetlinks.json` files.  
* Configuring app entitlements and intent filters.  
* Ensuring proper handling within your app’s routing system.

Pros:

* Direct linking without intermediary redirects.  
* Secure and verified deep linking.

Cons:

* No built-in deferred deep linking (unlike FDL).  
* Setup requires changes to both the app and backend infrastructure.

### **2\. Third-Party Deep Linking Platforms**

Many third-party deep linking services offer alternatives to FDL, including:

* <a href="https://branch.io" rel="nofollow">Branch</a>
* <a href="https://www.adjust.com" rel="nofollow">Adjust</a>
* <a href="https://www.appsflyer.com" rel="nofollow">AppsFlyer</a>

Pros:

* Feature-rich platforms with analytics, deferred deep linking, and attribution.  
* More flexibility than Google’s native solution.

Cons:

* Often require paid plans.  
* Vendor lock-in concerns.

### **3\. Building a Custom Deep Linking Infrastructure**

If your use case demands complete control, consider building a self-hosted deep linking system:

* Use URL shortening services with custom tracking parameters.  
* Implement backend logic to detect and route users.  
* Create web-based fallbacks for users without the app.

Pros:

* Full control over deep linking behavior.  
* No reliance on third-party services.

Cons:

* Requires engineering resources.  
* More complex setup and maintenance.

---

## **Conclusion**

Firebase Dynamic Links are shutting down on **August 25, 2025**, and developers need to act now to avoid disruptions. The key takeaways:

* All Firebase Dynamic Links will stop working after the shutdown date.  
* Push notifications, SMS, and email campaigns must transition to alternative deep linking solutions.  
* Google recommends App Links & Universal Links, but third-party services offer additional capabilities.  
* Courier helps developers manage deep linking across multiple notification channels.

To ensure your deep linking strategy remains intact, start planning your transition today. Whether using platform-native links, third-party providers, or a custom solution, taking action before the deadline will prevent broken experiences and lost user engagement.


FDL Shutdown - Big

Firebase Dynamic Links shut down on Aug 25, 2025. Learn how to keep deep linking in push notifications, SMS, and email working with alternative solutions.

Firebase Dynamic Links Are Shutting Down – What’s Next for Notifications?

FDL Shutdown - mini

Firebase Dynamic Links Are Shutting Down – What’s Next for Notifications & Deep Linking?

Notifications are the lifeblood of modern apps. They re-engage users, keep them informed, and build trust. But most apps rely solely on push notifications—without an in-app inbox, critical updates can easily be lost.

Push notifications grab attention in the moment—perfect for a flight delay, an account alert, or a message from a teammate. But they’re fleeting—once dismissed, they’re gone. If a user is busy or distracted, that information is lost, along with the opportunity to engage them.

An in-app inbox solves this. Unlike push notifications, an inbox provides a persistent record—a place users can revisit to see what they missed. It ensures important updates aren’t lost, helps users prioritize, and creates a seamless notification experience: push drives immediacy, while the inbox provides depth and context.

This is a big reason why we built [Courier Inbox](https://www.courier.com/docs/platform/inbox/intro). Let’s look at a few ways that push notifications and in-app notifications (Courier Inbox) can work together.

## 2\. Push and In-App Done Right: How B2C Sets the Standard for B2B

B2C companies have mastered **push notifications and in-app inboxes** to drive engagement and keep users informed. B2B, on the other hand, often treats notifications as transactional, missing opportunities to create seamless, user-friendly experiences.

**Airbnb and Starbucks** show how to do it right—using push to grab attention and in-app inboxes to provide continuity. Their approach offers a playbook for B2B companies looking to improve communication, ensure critical updates are seen, and build better user experiences. 

Let’s look at three ways we can learn from them

### A) Push for Immediate Action

Push notifications drive urgency and encourage quick responses.

**Examples from B2C Products:**

- **Airbnb**: Sends push notifications to alert users about high-demand properties, upcoming trips, or price drops.  
- **Starbucks**: Notifies users about limited-time promotions, double star days, or when their order is ready for pickup.

**How to Apply It for B2B:**  
Push notifications drive critical actions in business workflows:

* **HR & Workforce Management** *(Workday, BambooHR)* → Notify managers when a time-off request needs approval, or remind employees about an upcoming performance review deadline.  
* **Project Management & Collaboration** *(Asana, Jira, Monday.com)* → Alert team members about task assignments, urgent project updates, or approaching deadlines.  
* **Finance & Accounting** *(QuickBooks, Stripe, Expensify)* → Notify users of high-value transactions, failed payments, or invoice due dates.  
* **Procurement & Inventory Management** *(SAP Ariba, Coupa)* → Send alerts when inventory levels are critically low or when a purchase order requires urgent approval.  
* **Developer API Platforms & DevOps** *(Postman, Datadog, CircleCI)* → Push real-time alerts for API failures, security breaches, or system downtime.  
* **Customer Support & Help Desk** *(Zendesk, Intercom)* → Notify agents about high-priority tickets or customer escalations requiring immediate attention.

### B) Providing Organization and Depth

An in-app inbox stores important updates, providing users with a centralized hub to revisit key information.

**Examples from B2C Products:**

* **Airbnb**: Consolidates booking confirmations, itineraries, and host communications in its inbox, so users can access all trip details easily.  
* **Starbucks**: Tracks rewards progress, stores personalized offers, and organizes order history in the inbox, creating a consistent loyalty experience.

**How to Apply It for B2B:**  
A notification center serves as a persistent feed of important updates:

* **HR & Workforce Management** *(Workday, Rippling)* → Store performance reviews, benefits updates, and compliance announcements for easy access.  
* **Developer API Platforms** *(Postman, Auth0)* → Provide a log of API usage alerts, integration failures, and feature updates so developers can track changes over time.  
* **Procurement & Inventory Management** *(SAP Ariba, Coupa)* → Organize order approvals, supplier updates, and low-stock warnings to streamline purchasing workflows.  
* **Security & Compliance** *(OneTrust, Vanta)* → Maintain policy violation alerts, audit logs, and compliance deadlines in a centralized inbox for security teams.  
* **Project Management & Collaboration** *(Asana, Jira)* → Track task assignments, milestone completions, and team mentions in a dedicated notification center, making updates easy to review.

### C) Personalize Your Notifications

Tailored notifications make users feel valued and ensure messages are relevant.

**Examples from B2C Products:**

* **Airbnb**: Recommends properties based on user preferences and past bookings, creating a personalized search experience.  
* **Starbucks**: Sends offers based on users’ favorite drinks, purchase history, and regional promotions.

**How to Apply It for B2B:**  
Personalization in B2B notifications means delivering role-based updates:

* **HR & Workforce Management** *(BambooHR, Workday)* → Notify managers about pending approvals, team performance summaries, and policy updates, while employees receive benefits enrollment reminders and training deadlines relevant to them.  
* **Developer API Platforms** *(Postman, Auth0)* → Deliver alerts on API key expirations, unusual traffic spikes, and new feature availability specific to a developer’s usage patterns.  
* **Project Management & Collaboration** *(Asana, Jira)* → Surface task assignments, due date reminders, and team updates tailored to each user’s role and involvement.  
* **Finance & Accounting** *(QuickBooks, Stripe)* → Send customized invoice reminders, large transaction alerts, and monthly spend summaries relevant to finance teams.  
* **Risk & Compliance** *(OneTrust, Vanta)* → Notify security teams about compliance gaps, policy violations, and critical risk assessments based on the specific regulatory frameworks they manage.

## 3\. Why Not Build from Scratch?

Building a notification system from scratch is deceptively complex. Many teams start out thinking it’s just about sending messages, but the deeper they go, the more challenges emerge. It’s also not just about building it, once it’s built, you gotta maintain it.

Some of the biggest challenges include:

* **Backend Complexity:** Managing APIs, tokens, message queues, and multi-provider orchestration is a headache  
* **Maintaining Multiple Frontends:** Supporting iOS, Android, and web requires specialized skills and constant updates.  
* **Synchronization Issues:** Ensuring consistency across push, email, and in-app messages is hard  
* **Scaling Challenges:** As notification volume grows, complexity to maintain will increase.

## 4\. Building Developer First

At Courier, we set out to build an in-app notification platform that makes adding real-time notifications easy and fully customizable, ensuring they feel native to your app. Basically, what would we as developers expect. Here’s what we thought about when building Courier Inbox:

* **Cross-Platform SDKs:** Native support for iOS, Android, React Native, and Flutter along with Javascript for web.  
* **Real-Time Updates:** Push notifications and inbox sync instantly using websockets.  
* **Multi-channel Support:** Ability to send messages across multiple channels like email, Slack, and SMS along with push and in-app  
* **Offline Support:** Messages remain accessible without connectivity, syncing seamlessly when users reconnect.  
* **Customizable Design:** Easily tailor the inbox UI to your app’s branding and look native to the platform (eg iOS looks like iOS) 

## 5\. A Smarter Way to Build Notifications

That’s why we built [Courier Inbox](https://www.courier.com/docs/platform/inbox/intro): to take the complexity out of notifications. Real-time updates, cross-platform SDKs, and full customization—without the overhead. Give users the notifications they need, when they need them. No missed messages, no unnecessary complexity. Just a seamless experience across every platform.

If you’re ready to build notifications that users love, Courier makes it easy.  


Push and In-app - Header

B2C apps like Airbnb use push + in-app to keep users engaged. B2B can learn from them to build notifications that drive action and improve user experience.

Push + In-App: The Notification Strategy B2B Needs to Steal from B2C

Push and In-app - Thumb

Rethinking Push and In-App Notifications: What B2B Can Learn from B2C

Apple recently announced an **APNS Security Update**, requiring updated server certificates for push notifications starting **March 29, 2025**. If you rely on Apple Push Notification Service (APNS) for delivering notifications to iOS devices, you may be wondering what actions, if any, are needed to ensure uninterrupted service.

We’re excited to confirm: **Courier customers are unaffected by this update. Notifications sent via APNS with P8 keys or P12 certificates work seamlessly, and no immediate changes are required.**

For background, Apple’s [official announcement](https://developer.apple.com/news/upcoming-requirements/?id=01202025a) outlines the new requirements for all servers communicating with APNS. If you haven’t already, you can also check out our [original Courier blog post](https://www.courier.com/blog/get-your-ios-app-ready-for-the-2025-apple-push-notification-service-server) for additional context and preparation tips.

Here’s everything you need to know:

---

## What’s Changing with APNS?

Starting **March 29, 2025**, Apple will require all servers communicating with APNS to use updated root certificates. This change ensures APNS maintains the highest level of security and compatibility with industry standards. Any outdated configurations or unsupported certificates will no longer work beyond the deadline.

---

## What We Tested

To stay ahead of this update, we tested APNS push notifications using both **P8 keys** and **P12 certificates** with **Native iOS apps.**

**The result:** Everything is working as expected. 🎉 **Courier customers do not need to make changes.**

---

## Key Takeaways

1. **Courier customers are unaffected** by this update.  

   - Push notifications continue to work seamlessly with current configurations.

2. If you’re using **AWS Lambda** or **GCP Cloud Functions**, it is likely your configuration is also unaffected when using libraries like `node-apn`. However, be sure to test your setup on the APNS sandbox environment soon to confirm your setup is working properly.  

   - Testing is always recommended to ensure compatibility with your specific implementation.

3. For older or custom APNS implementations, ensure your server is using the updated root certificates. Apple’s [technical documentation](https://developer.apple.com/news/upcoming-requirements/?id=01202025a) provides all necessary details.

---

## Recommended Actions If You Are Not Using Courier:

We recommend that you do the following if not using Courier:

1. **Test your app’s push notifications** in both sandbox and production environments.  
2. **Verify your APNS configurations**, particularly if you use custom setups or older libraries.  
3. Stay informed by following Apple’s [official announcement](https://developer.apple.com/news/upcoming-requirements/?id=01202025a).

---


Get Your App Ready APNS Update 2025

Learn about Apple’s APNS Security Update for 2025. Courier customers can rest assured—no changes are needed for push notifications. Get all the details here.

APNS Security Update 2025: Courier Customers Are Covered

APNS Update Thumbnail

APNS Security Update 2025: Courier Customers Are All Set!

I've been making apps since just after the App Store launched - it's actually what made me want to make apps in the first place. Looking back over this journey, it's amazing to see how much has changed. Let me take you through this evolution, because what's happening right now in mobile development is absolutely incredible.

## The Early Days: When Native was the Only Game in Town

For about the first seven years after the app stores launched, there was really only one way to make apps - you built them native. On iOS, you were working with Objective-C, and honestly? It was scary stuff. The code was incredibly verbose, and when you were reading it, it was hard to understand what was actually going on. Over on the Android side, you had Java. While not quite as intimidating as Objective-C, Java was incredibly longhand - you had to write tons of code just to do simple things.

Building for both platforms? That meant maintaining two completely separate codebases. But it wasn't just about the programming languages. The APIs for essential features were all pretty rough around the edges. Want to add maps? Complex. Need Bluetooth connectivity? Complicated. Even basic stuff like fetching data from servers and parsing JSON was a hassle. Every feature required deep technical knowledge and a lot of boilerplate code.

## Early Cross-Platform Attempts: The First Wave

Before React Native, the mobile development world was desperately seeking a solution to the duplicate work problem - nobody wanted to maintain two separate codebases. PhoneGap (later Apache Cordova) tried using web technologies, wrapping HTML, CSS, and JavaScript in a native container. Xamarin took a different approach with C#, promising native performance. Some teams even tried using game engines like Unity for business apps, showing just how desperate developers were for a solution.

But none of these early attempts really cracked the code. Whether it was clunky performance, poor user experience, or development headaches, you'd often end up spending more time fighting with the framework than you would have spent just writing native code. The mobile world needed something better.

## Making Native Development More Approachable

Then both platforms evolved in a way that changed everything. Apple introduced Swift, and it was a game-changer for iOS development. I was part of that wave - looking at Objective-C thinking "ah, this is scary," then Swift comes along and suddenly I'm thinking "wow, this is so much easier. I can actually really make apps now."

Google wasn't far behind. They saw the success of Swift and introduced Kotlin for Android development. It was basically their version of Swift - a more modern, approachable language that made Android development feel less cumbersome.

At the same time, those clunky APIs I mentioned? They got better. Want to add a map to your app? Much easier. Need to work with Bluetooth or track location? The APIs improved dramatically. Even basic stuff like fetching and parsing data from servers became more straightforward. The barrier to entry was getting lower, but we were still building separate apps for iOS and Android.

## The React Native Era

Facebook's React Native emerged from a real problem: they had separate teams building the same features for Instagram and Facebook on iOS and Android. Their solution? Take React, which was already gaining popularity in web development, and create a system that could translate React components into native mobile components.

React Native gained huge momentum, becoming the hot new thing in mobile development. But I actually didn't jump on that wave initially. The developers I was working with at the time had a pretty clear take: "Yeah, it's just kind of clunky. It doesn't create a better quality app."

Take Instagram as an example. It's probably the best React Native app ever built - it's an incredible app. But to get there, they had to build tons of custom UI and implementation code. They made it work, and work well, but it required a lot of heavy lifting behind the scenes. This became a common pattern: you could build great apps with React Native, but you often needed to dive deep into native code to get the quality you wanted.

## The Flutter Revolution

I remember exactly when everything changed. I was watching Google IO, and Flutter was announced in one of these little talks. Right at that moment, I knew that all of mobile engineering, desktop app engineering, and even web development was going to be completely different.

Flutter flipped the script on how we think about cross-platform development. React Native tries to transpile your code into native components, but Flutter said, "Hey, what if native components aren't actually that important?" Instead of trying to use native UI elements, Flutter just draws everything itself, similar to how a game engine works. And here's the thing - my mom doesn't care if an app is made with native components. She has no idea. What she cares about is that the app works well.

This approach means if you write your app in Flutter (using Dart, which is very approachable for JavaScript developers), it can run consistently anywhere - iOS, Android, web, macOS, Windows, even game consoles. One codebase, running everywhere, looking exactly the same.

Now, you might think drawing everything yourself would be resource-intensive, but modern devices have made this a non-issue. Even on lower-powered Android phones, Flutter apps run at really high quality. The development community has noticed too - Flutter has actually surpassed React Native on Google Trends, and every new project I take on now is Flutter.

## The AI Revolution: Welcome to the Golden Era

Let me be clear - we're in the golden era of mobile development right now. This isn't just an iteration - this is the second app store wave. The first wave was "here's the app store, build stuff for it." Now? The tooling has been completely rebuilt, AI has arrived at exactly the right moment, and I believe every idea is going to be tried by anyone in the whole world.

When I'm writing Flutter apps with AI assistance, I'm at least 30% more efficient. And it's not just about coding faster - AI does things I hadn't even thought of. Sometimes you're sitting there thinking, "Okay, I know this can be better, but how?" You just ask the AI, and it'll give you new ideas. That's huge.

But here's the real game-changer: tools like Cursor. That command-K functionality, where you just highlight a block of code and tell it what you want to change? It's magic nearly every time. Want to make a list item look better? Add spacing? Put gaps between elements? These might sound like small things, but they're the tedious tasks that add up over time. Command-K just handles them instantly.

This is actually why I believe native apps are basically dead. When you're making a React Native or Flutter app, you can use all these amazing AI tools in your workflow. But if you want to make a native iOS or Android app? You're stuck using Xcode or Android Studio. Sure, Apple and Google are trying to add AI features to their IDEs, but they're way behind. I tried the Android Studio Gemini tools, and honestly? They took a long time to give wrong answers.

The reality is, for 95% of what developers do, there's no significant value in making a native app anymore. The only time you really need to open Android Studio or Xcode is for very specific native features, and that's becoming rare. Even with things like push notifications that require native code, it's just a small part of the overall development process.

## What's Next

The evolution of mobile development has been a journey of making things easier and more accessible. But what we're seeing now isn't just another step in that journey - it's a fundamental transformation. Projects like Expo are pushing to make React Native even more approachable, and new initiatives like one.dev are trying to unify native and web development.

Even the major players are starting to adapt. Google's launching new tools like IDX, and Apple's beginning to explore AI features in Xcode. They might be playing catch-up, but they see where the industry is heading. The question isn't whether this transformation is happening - it's how fast traditional development tools and approaches will evolve to keep up.

But the most exciting part? The barrier between having an idea and making it reality has never been lower. This isn't just about changing how we build apps - it's about changing who can build them. And that's going to lead to apps and ideas we haven't even imagined yet.


Building Mobile Apps in 2025

Discover how React Native, Flutter, and AI are reshaping mobile app development, from native apps to powerful cross-platform solutions.

React Native, Flutter, and AI: Transforming Mobile App Development

Building Mobile Apps in 2025 - Thumb

The Evolution of Mobile Development: From native apps to Flutter, React Native, and AI

Courier Live Thumbnail

The Courier Team

Twilio powers communication for over 10 million developers and 300,000 businesses worldwide. As a leader in customer engagement, they’ve set the standard for seamless, scalable developer tools. But as their business grew, managing notifications became a challenge. Fragmented tools and workflows created inconsistencies and inefficiencies across teams. To solve this, Twilio turned to Courier—a platform designed to unify notifications and improve the developer experience at scale.

---

## Twilio’s Challenge: Scaling In-Console Messaging

Twilio’s in-console notifications are critical for keeping developers informed. Whether it’s product updates, feature launches, or system alerts, notifications help developers stay engaged and take action. But as Twilio scaled, teams started relying on different tools to manage notifications. The result? Fragmented user experiences, messaging inconsistencies, and time lost managing workflows.

For a platform of Twilio’s scale, these challenges added friction to what should have been a seamless experience. They needed a unified solution to deliver consistent, real-time updates while simplifying workflows for their teams.

---

## Why Twilio Chose Courier For Notifications

Twilio needed a notification platform that could scale with them and adapt to their complex workflows. Courier stood out for its ability to centralize notifications and streamline delivery across channels. Key factors in their decision included:

- **Web Inbox**: Delivered targeted, real-time notifications directly within Twilio’s console.  
- **Seamless Integration**: Worked effortlessly with existing tools like Segment and SendGrid.  
- **Customization**: Easy to customize so that you can create consistent, branded notifications across all channels.  
- **Efficiency**: Reduced engineering effort with straightforward implementation and centralized workflows.  
- **Security**: Included enterprise-grade security and role-based access controls to protect sensitive data.

With Courier, Twilio could unify their notifications while enhancing the experience for developers.

---

## How Courier Solved Real-Time Notifications for Twilio

Integrating Courier gave Twilio the tools to fix fragmented workflows and deliver better notifications across their ecosystem. With Courier’s **web inbox**, Twilio created a central hub for real-time, in-console updates that developers could rely on. Notifications were now consistent, actionable, and delivered exactly when needed.

Courier’s notification center also allowed Twilio to give developers control over their preferences, including digest schedules and message frequency. Customizable templates ensured that every notification matched Twilio’s branding, while real-time delivery powered by webhooks and WebSockets kept developers in sync.

By streamlining their workflows and centralizing notifications, Twilio saved engineering time and created a better experience for their developer community.

---

## The Benefits of Courier’s Unified Notification Platform

The integration with Courier brought immediate and measurable improvements:

- **Centralized Notifications**: A single, unified inbox for all notifications reduced friction and confusion.  
- **Enhanced Experience**: Real-time, actionable updates kept developers engaged and informed.  
- **Scalability**: Built to handle Twilio’s growing ecosystem of developers and customers.  
- **Time Savings**: Simplified workflows allowed engineering teams to focus on building core features.  
- **Personalization**: Developers could tailor their notification experience to match their needs.

These changes didn’t just address the challenges Twilio was facing—they elevated the experience for developers and reinforced Twilio’s reputation for delivering world-class tools.

---

## Outcome: Twilio’s Improved Developer Experience with Courier

The partnership with Courier helped Twilio transform how they manage notifications. Developers now have a consistent and intuitive in-console experience, making it easier to stay informed and take action. By centralizing notifications and improving real-time delivery, Twilio increased engagement and reduced friction for its users.

Internally, the benefits were equally clear. Engineering teams saved time by eliminating fragmented workflows, while Courier’s customizable templates ensured consistent branding without additional effort.

Twilio’s Product Lead, Kandyce Knight, summed it up: *“We at Twilio know how important it is to meet your customers at their preferred channels. Courier gives us the power to fully personalize our customer touchpoints in one easy-to-use, centralized tool.”*

For Twilio, the integration wasn’t just a solution—it was a shift that enabled them to scale their platform while staying true to their developer-first ethos.

---

## Conclusion

Twilio’s success with Courier highlights the importance of a unified notification platform. By solving fragmented workflows and delivering real-time, personalized updates, they improved engagement for millions of developers while saving valuable engineering time.

For organizations managing complex notification systems, Courier offers a proven way to simplify workflows, deliver better user experiences, and scale seamlessly.

Explore how Courier Web and Mobile Inbox can help you better engage your customers. [Learn more here.](https://www.courier.com/platform/inbox)  


Twilio and Courier Header

Discover how Twilio unified notifications for 10 million developers with Courier, improving real-time updates, engagement, and workflow efficiency

How Twilio Used Courier to Unify Notifications for 10 Million Developers

Twilio + Courier Thumbnail

📣 How Twilio Used Courier to Unify Notifications for 10 Million Developers

This month, we’re rolling out updates to our mobile SDKs with a focus on usability, reliability, and developer experience. Here’s a breakdown of the latest improvements for iOS, Android, React Native, and Flutter.

---

## **iOS Updates**

#### **New Features**

- **Long Press Gesture Support:** Add long press interactions to notifications in the **CourierInbox view**, with haptic feedback for better usability.  
- **Pull-to-Refresh in Empty States:** Users can refresh their inbox even when it’s empty, ensuring they always see the latest messages.  
- **Brand Integration:** The unread count indicator now uses your app’s primary brand color if you apply a brand to the view. 

#### **Performance & Stability**

- **Websocket Keep-alive:** Prevents disconnections after \~10 minutes of inactivity in foreground, keeping notifications in sync.  
- **Improved Background Handling:** Ensures websockets reconnect reliably when the app moves between background and foreground.

#### **Developer Enhancements**

- **Actor-Based Singleton:** `Courier.shared` is now an actor, improving concurrency safety and reducing potential race conditions.  
- **Updated Documentation:** Includes new **SwiftUI examples**, refreshed screenshots, and clearer integration steps.  
- **Error Handling Updates:** Under-the-hood improvements to reliability when managing inbox message data.

**iOS SDK:** [Courier iOS SDK on GitHub](https://github.com/trycourier/courier-ios)

---

## **Android Updates**

#### **New Features**

- **Long Press Gesture Support:** Enables long press interactions for notifications in the **CourierInbox view**, mirroring iOS functionality.  
- **Jetpack Compose UI Support:** Fully supports integration with Compose-based apps.  
- **Scroll-to-Top on Tab Reselect:** When users reselect a tab in the inbox, the view scrolls to the top automatically.

#### **Performance & Stability**

- **Websocket Keep-alive:** Keeps connections active during periods of inactivity.  
- **ViewPager2 Support:** Improved compatibility for modern UI frameworks.  
- **Gradle & SDK Updates:** Supports Gradle 8.9 and Android API level 34, ensuring compatibility with the latest Android platform.

#### **Developer Enhancements**

- **Documentation Updates:** Includes examples for Compose and Traditional layouts, along with updated screenshots.  
- **Courier Bar Logo Fix:** Resolved an issue with logo tinting for a consistent appearance.

**Android SDK:** [Courier Android SDK on GitHub](https://github.com/trycourier/courier-android)

---

## **React Native Updates**

#### **New Features**

- All iOS and Android updates are now available in React Native.

#### **Developer Enhancements**

- **Async Functions:** Updated `Courier.shared` functions comply with Swift actor concurrency for better thread safety.  
- **Bug Fixes:** Resolved inbox listener callback issues on iOS.  
- **Gradle Updates:** Support for Gradle 8.1 and API level 34\.

**React Native SDK:** [Courier React Native SDK on GitHub](https://github.com/trycourier/courier-react-native)

---

## **Flutter Updates**

We’re actively working on updates to the Flutter SDK. New features and improvements are on track to launch in the coming weeks.

**Flutter SDK:** [Courier Flutter SDK on GitHub](https://github.com/trycourier/courier-flutter)

---

## **Next Steps**

The latest versions of the SDKs are available now. For integration guides, visit our updated documentation:  
📚 [Courier Inbox Documentation](https://www.courier.com/docs/platform/inbox/intro)

If you have feedback or feature requests, we’d love to hear from you.  


SDK Update Jan 2025 Big

Explore Courier’s January 2025 SDK updates for iOS, Android, React Native, and Flutter. New features, performance boosts, and tools for better apps!

January 2025 Courier Mobile SDK Updates for iOS, Android, React, Flutter

Jan 2025 SDK Update Thumb

Courier Inbox Mobile SDK Updates - January 2025

Seth Profile Pic

Seth Carney

**Smart Notification Scheduling with Delivery Windows**

Sending a notification is simple—sending it at the right time is not. Whether it’s avoiding off-hours pings or managing users across time zones, timing matters. With Courier’s new Delivery Window, you can deliver messages at the perfect moment—without the overhead of custom scheduling code.

**Set the Rules, We’ll Handle the Rest**  
The Delivery Window feature lets you define when notifications should go out, and Courier ensures they follow your rules. Instead of instant delivery, send the notification when it’s best for your user to get it and act on it.

For example, if a non-urgent alert is triggered on Sunday at 3 PM, you can configure a delivery window for work hours: Monday to Friday, 10 AM to 4 PM. Courier will hold the message and deliver it Monday at 10 AM—seamlessly, no extra work required.

Some key features include:

* Time zone adaptability, allowing messages to be sent based on specific user locations  
* Support for both IANA and UTC± formats  
* Flexible scheduling with the ability to define complex windows

Here’s what it looks like in your API request:

```
// If sent Thursday at noon, will send immediately
// If sent Saturday at noon, will delay until 8am the following Monday
{
  "message": {
    "to": {
      "user_id": "test123",
      "timezone": "Americas/Los_Angeles"
    },
    "delay": {
      "until": "Mo-Fr 08:00-16:30"
    }
  }
}
```

**Get Started Today**  
Ready to see it in action? Explore the [Delivery Window docs](https://www.courier.com/docs/platform/sending/delay#delivery-window) and start sending notifications at the right time for users.


Delivery Window Header

Delivery Window Thumb

Smart Notification Scheduling with Delivery Windows

## *Update*
**We’re excited to confirm that Courier customers are unaffected by this update. Notifications sent via APNS with P8 keys or P12 certificates work seamlessly, and no changes are required.**

[Read more about what we tested](https://www.courier.com/blog/apns-security-update-2025-courier-customers-are-all-set)

---
---

### **What’s Changing**

Apple is updating its Push Notification service (APNs) certificates to use the USERTrust RSA Certification Authority (SHA-2 Root). Key dates include:

* **Sandbox:** January 20, 2025  
* **Production:** February 24, 2025

To keep push notifications working, you must update your server’s Trust Store to include the new certificate authority. Both old and new certificates should remain trusted during the transition. [Read Apple’s official announcement here](https://developer.apple.com/news/?id=09za8wzy).

We’ll update this post with details for \`node-apn\` and similar packages after January 20\. Be sure to bookmark this post\!

### **Using Courier? No Changes Are Needed**

Courier has already implemented these changes, so you don’t need to worry. Notifications will flow seamlessly with no extra work on your part. Courier also lets you design and manage notification templates effortlessly. Explore Courier’s resources to get started:

* [Courier Website](https://www.courier.com/)  
* [Courier iOS SDK](https://github.com/trycourier/courier-ios)  
* [Courier Android SDK](https://github.com/trycourier/courier-android)  
* [Courier React Native SDK](https://github.com/trycourier/courier-react-native)  
* [Courier Flutter SDK](https://github.com/trycourier/courier-flutter)

If you are not using Courier, here's what you need to do:

### **How to Update Your Server**

If you’re updating manually, follow these steps:

#### **Step 1: Download the New Certificate**

Get the USERTrust RSA Certification Authority (SHA-2) certificate from Apple’s official site or a trusted source.

#### **Step 2: Update Your Trust Store**

**Unix/Linux Servers:**

1. Locate your `ca-certificates` directory (e.g., `/etc/ssl/certs/`).  
2. Copy the certificate:

```
sudo cp /path/to/USERTrustRSA.crt /etc/ssl/certs/
```

4.   
   Update certificate hashes:

```
sudo c_rehash
```

6.   
   Restart your server.

**Windows Servers:**

1. Open Microsoft Management Console (MMC) and add the Certificates snap-in.  
2. Navigate to "Trusted Root Certification Authorities."  
3. Right-click and select "Import," then follow the wizard.  
4. Restart your server.

#### **Step 3: Test the Update**

* **Sandbox Testing:** Begin testing on January 20, 2025\. Check server logs for SSL errors or issues.  
* **Monitor Logs:** Regularly review logs to catch problems early.

### **For .p8 Key Users**

If you’re using .p8 keys for APNs authentication, no changes are required for your app’s code. However, you still need to:

* Update your server’s Trust Store.  
* Test notifications in sandbox mode starting January 20\.

### **Risks of Not Updating**

Skipping these updates may cause:

* **Push Failures:** Notifications won’t be delivered.  
  * **Solution:** Test thoroughly in sandbox mode.  
* **SSL Errors:** Unreliable connections due to missing certificates.  
  * **Solution:** Use SSL tools like SSL Labs to verify configurations.  
* **User Impact:** Downtime can frustrate users and hurt engagement.  
  * **Solution:** Monitor closely during the transition.

### **Tips for a Smooth Transition**

1. **Start Early:** Test in the sandbox environment ahead of production updates.  
2. **Trust Both Certificates:** Load old and new certificates during the transition.  
3. **Document Testing:** Record your tests and fixes for reference.

### **Key Dates to Remember**

* **Sandbox Testing Starts:** January 20, 2025  
* **Production Update:** February 24, 2025

By preparing now, you’ll ensure your push notifications continue without interruption. If you need help, consult Apple’s documentation or contact your notification provider. Let’s make 2025 a seamless year for your app’s notifications\!


APNS Apple Push Notification Service Update 2025

Get ready for Apple’s 2025 APNs update. Key dates, steps to update servers, and tips for seamless notifications. Courier users: no changes needed!

Prepare Your App for the 2025 APNs Certificate Update

Get Your iOS App Ready for the 2025 Apple Push Notification Service Server Certificate Update

T01NA8E0677-U0390SD03GQ-c33142599c5b-512

Sarah Barber

Push notifications have carved their own niche as a powerful tool for continuous user engagement. Regardless of whether an app is actively in use, they deliver your messages straight to your user's device.

Two useful tools to enhance your push notification strategy are Segment and Courier. In this article, we show you how to set up Courier to listen to your Segment events and then send push notifications to an Android device based on data from these events.

[Segment](https://www.courier.com/blog/smarter-customer-engagement-flows-segment-integration/) is a customer data platform, enabling you to unify your customer data into a single data store, including information on how your users are interacting with a web page or the details of a successful transaction.

Courier is a multi-channel notification platform that goes beyond a simple push implementation. Designed for developers, Courier integrates seamlessly with both mobile and web platforms, providing a toolbox packed with rich notification features suitable for a wide range of use cases. Whether it's a simple task like a password reset or a more intricate multi-touch approval workflow, Courier has you covered.

## Using Segment and Courier together

Segment’s user groupings and event data are particularly useful for transactional push notifications, and will be useful to you if you develop systems like employee collaboration tools or e-commerce stores. Take a look at these examples:

### Collaboration tools

- __Inactivity reminders:__ Notify team members who haven't engaged with the collaboration platform for a while, using a personalized push notification. The message could remind them of their pending tasks, check in with them, or summarize important activities they might have missed.
- __User mentions:__ Trigger an immediate push notification when a user is mentioned in a discussion. The promptness of such notifications could be adjusted based on the user's role or status within the organization.

### E-commerce stores

- __Transaction notifications:__ For instance, when a user completes a purchase in your Shopify store, Segment records the event (provided Shopify is integrated with Segment). Courier, acting as a listener to Segment events, can then send a push notification acknowledging the transaction.
- __Real-time related offers:__ Suppose you're running an online sports goods store. If a customer purchases a significant amount of skiing equipment, you could send push notifications with exclusive offers on ski gear. Conversely, if they buy football gear, notifications would pivot to football-specific deals, ensuring relevance and user interest.
- __Abandoned cart recovery:__ Don't let potential sales slip away. Use Segment and Courier to send reminders about abandoned shopping carts and maybe even offer a small incentive to encourage checkout.

## Prerequisites
To complete this tutorial, you will need the following:

- A free [Firebase](https://firebase.google.com/) account
- A free [Segment](https://segment.com/signup/) account
- A free [Courier](https://app.courier.com/signup) account
- Android Studio installed on your Mac or PC

## Firebase setup

Log-in to the [Firebase console](https://console.firebase.google.com/) and create a new project. Once this project is created, create a new Android app.

Give it the package name `com.example.courierpush` and click __Register App__. Download the `google-services.json` (for later) and click __Next__. Don't worry about the SDK installtion information, just click __Next__ and finally __Continue to Console__.

Finally, in your Project Overview click the "gear" icon and go to your __Project Setting__. Click __Service Accounts__ and, in the "Firebase Admin SDK" section, click __Generate new private key__. This will cause a JSON file to be downloaded, so please hold on to it for the next step.

## Courier setup

If you don’t yet have a Courier account, [create one for free](https://app.courier.com/signup), then navigate to [Users](https://app.courier.com/) and create a user. Give your user an `ID`, and make a note of it, as you will need to use this later in the tutorial.

Technically, no other fields are required for this tutorial, but it makes sense to give your user a name, email address, and phone number as a bare minimum, in case you want to use Courier to send other types of notifications such as email and SMS.

Next, set up a Firebase as a push provider in Courier. In the Courier dashboard go to __Integrations__ → __Integration Catalog__, search for **Firebase** in the list of providers and click on the logo. Paste the contents of the JSON file you downloaded earlier into the "Service Account JSON" field and click __Install Provider__. More details about how to do all this is provided in [Courier’s FCM setup documentation](https://www.courier.com/docs/platform/channels/push/firebase-fcm/).

## Create a push notification template

In the Courier dashboard, go to [Templates](https://app.courier.com/designer/notifications) and click **Create Notification**. Name it “Push notification test” and click **Create Template**. You’ll now be prompted to add your notification channel. Select **Push**, then **Firebase FCM**.

Next, on the left side of your screen, click on your newly-created Push channel, and paste in this for title:

`Congrats {name}, you've got a push notification!`

...and this for content:

```
Courier templates accept variables inside curly braces. In this example, we use the "name" value from the Segment event and to populate the name field above 💡.
```

Finally, click **Publish Changes** to activate your template.

## Create a web page

In order to showcase how data can be sent from your website to Segment, we will need only the most basic web page, with no fancy hosting requirements — you can simply open the file locally in a browser. Create a file called `index.html` with the following content, and load the page in your browser.

```html
<html>
    <head>
    </head>
    <body>
   	 <h1>Courier Segment Tutorial</h1>
   	 <p>Loading this page will send events to Segment 📬</p>
    </body>
</html>
```

## Segment setup

[Sign up for a free Segment account](https://app.segment.com/signup/), if you don’t already have one. Once logged into the app, you’ll need to create a workspace, and then within that workspace, create a link between a “source” and a “destination.” In this example, the source will be your own website and the destination will be Courier, but you can also connect a wide variety of other data sources including Google Ads and Shopify.

### Add a data source 

To add a source, navigate to **Sources** and click **+ Add source**. Select **JavaScript Website** as the source and then click **Add source**. You’ll then see some options to fill in, such as your website URL. However, for this example you’ll be adding your Segment code to a local HTML file, so you can skip these options and click **Add source**. Next, paste the generated JavaScript code snippet inside the `<head>` tag of your website code, to set up the link between your website and Segment.

### Add a destination

To add Courier as the destination, navigate to **Destinations** and click **Add destination**. Search for “Courier” in the catalog search box, and when it appears, click it and then select **Add destination**. Select your website from your list of sources to connect your source to your destination, and click **Next**. Give it a destination name of “Courier Tutorial” and click **Create destination**.

### Connect your source to your destination

In your destination settings, paste in your Courier API key to create the connection between Segment and Courier. Click on the **API Key** section under **Connection Settings** to edit it. Also in your destination settings, there is a toggle that you must toggle on to ensure your destination is enabled.

![Segment Destination settings](//images.ctfassets.net/z7iqk1q8njt4/2KKxGoglYnYHC32zrmRYAG/73bea5d781d4063a3daf183133ebf191/Xnapper-2023-11-17-07.51.55.png)

You can find your Courier API key in the Courier dashboard, under **Settings** → **API keys**. Remember that best practice is to use your test API key for testing purposes and reserve your production API key for production code.

## Send an event to Segment from your website

In your website code, at the bottom of the `<script>` tag, after your pasted function that joins your site with Segment, let's now make two calls to Segment:

### Identify call 

This method tells Segment who is on your website. For our purposes, we will use the ID of the Courier user record you created earlier. Include the following code underneath the call to `analytics.page()`, making sure to replace the placeholder below with the Courier user ID:

```javascript
      analytics.identify('<COURIER_USER_ID>');
```

### Track call

This method allows you to track user actions on your site and store associated data in Segment. For our tutorial, add the following lines of code underneath your `analytics.identify()` call from above, making sure to replace `<NAME>` with the user's name.

```javascript
     analytics.track('Order complete', {
         type: "track",
	   name: "<NAME>",
     });
```

Open your HTML file in a browser, and the two Segment calls will occur on page load. You can verify this has happened by checking the **Debugger** tab of your **Source** in Segment. It should look like this:

![Xnapper-2023-11-16-13.40.58](//images.ctfassets.net/z7iqk1q8njt4/4VuaiO3kFkLFOvr27KsgQK/562aa04c838b86c6f33195fbe76149e3/Xnapper-2023-11-16-13.40.58.png)

### Check your Segment event gets sent to Courier

You can [check](https://segment.com/docs/connections/test-connections/) that Courier received your events by clicking on your **track** event in the same Segment Source **Debugger** tab and clicking **Validate…** Select your Courier destination and click **Next**, which will take you to an event tester area where you can send  a test version of your event. Select **Track** as your event type to generate your example payload and click **Send test event**. If the event is sent successfully, you’ll receive a 202 response.

Now you know that Courier is able to receive your Segment event, you’re ready to set up an automation in Courier to send a push notification whenever this happens.

## Set up Courier to send a push notification when a Segment event fires

You can use Courier [Automations](https://app.courier.com/automations) to send of push notifications based on trigger conditions. In this case, we are going to trigger the sending of a notification when a Segment event happens.

Start by clicking "Automation" in the Courier dashboard and click on "New Automation." Change the name of your automation from the default “Untitled Automation” to a more descriptive title, like “Push notification test automation”.

### Add a trigger to your automation

1. Drag the **Segment** node from the left-hand side of the screen towards the top of the main canvas.
2. Select the Segment event that you have recently created, which should be listed as “Order complete.”

Note: If you did not send a test Segment event you won’t see your Segment event in the list. If that's the case, take a moment to do that now.

### Connect your trigger to an action

You now need to connect your trigger to an action step that sends a push notification.

- Under "Actions" on the left-hand side of the page, drag the **Send** node onto the canvas, below the "Segment" trigger.
- These steps should now be connected to each other by a line.
- In the "Send" node, select your push notification template as the notification that will be sent.
- Now click **Advanced** on your "Send" node and enter `refs.data.userId` for the user ID and for the data object. This ensures that these values will be populated from the data that Courier receives from Segment, meaning that each time an event is called from your site, if your code sends a different user ID each time, the message can be sent to different users. 
- Also in **Advanced**, look for the "Data" section and click **Edit**. Add a field, give the "Field Name" the value of `name` and set the value to `refs.data.properties.name`. Doing this ensures that the `name` variable in your notification template will be populated by the relevant user's name each time, via the Segment event data.
- Finally, click **Publish changes** to save the automation.

## Integrate Courier into an Android app

In order to receive a push notification you are going to need an app. If you want to get started quickly, you can download and build our [Android push notification test app](https://github.com/trycourier/tutorial-android-push-notifs). After you clone the repo, make sure to copy the `google-services.json` that you downloaded earlier when you created your Firebase project into the `app/src` directory in your Android project.

If you're building an app from scratch or want to integrate Courier into an existing app, check out this step-by-step tutorial: [Mastering Android Push Notifications: A Guide Using Courier’s SDK](https://www.courier.com/blog/android-sdk-push-notifications-using-courier/). 

Assuming you’ve downloaded our GitHub repo, you will need to follow the steps in the [README](https://github.com/trycourier/tutorial-android-push-notifs) to build your Android app send a push notification. 

## Send a Segment event and watch it trigger a push notification on your phone

Reload your `index.html` page to trigger another Segment event to be sent to Courier. This will now trigger your automation, which will cause your push notification to be sent to your Android phone!

![Android push notification screenshot](//images.ctfassets.net/z7iqk1q8njt4/10dC30PLcvQpWvtvmTGkvV/cf5ee51aee32499deae47e3116100693/Screenshot_20231117_231759_One_UI_Home.jpg)

### Troubleshooting tips

* The [Courier logs](https://app.courier.com/logs/messages) can provide useful information if a notification has failed.
* Ensure your Firebase service account JSON used in step 1 comes from the same Firebase project that you’re using.
* Ensure you have the correct version of `google-services.json` inside your Android project.
* Ensure your app is permitted to receive notifications.
* The `userId` in your Android app (that you use to sign in to Courier) must match the user ID in the `analytics.identify()` call inside your `index.html` file.
* Ensure the name of the event at the top of your automation in Courier matches the name of the event you are triggering from your application. 

## Wrapping Up

In this tutorial you have learned how to trigger a push notification based on a Segment event. You can now use these principles to set up real Segment events in your applications and use them to trigger push notifications using Courier automations and the Courier SDK in your Android app code.

If you want to see more use cases of how Segment events can trigger notifications, you can watch this [video of Courier and Segment developers](https://www.youtube.com/watch?v=pi3nUY1rFdM) working through this integration together.

It’s worth noting that if you’re using RudderStack instead of Segment, Courier also has a [RudderStack integration](https://www.courier.com/blog/customer-data-insights-and-analytics-rudderstack/) that works in a very similar way. Or, if you want your push notifications to be triggered by a time schedule, you can do all this in the automations designer.

Linking Segment events with your push notifications is a real game changer, so it’s definitely worth giving this a try. You can [sign up to Courier](https://app.courier.com/signup) and try our free tier with 10,000 free messages, or [get in touch](https://www.courier.com/request-demo/) if you want to find out more.

Courier makes it easy to send SMS, email, push and in-app notifications with a single API call. We have a REST API, client SDKs and Docs that you'll love 💜

Create Your Free Developer Account

Send push notifications with Segment and Courier header

Flow diagram showing how Segment and Courier work together to send a push notification. It starts with some application code that calls a function  sendCompletedOrderDetailsToSegment, which links to Segment, which then links to Courier, which further links to an Android device with a push notification on its screen.

We explain how to set up automatic push notifications to Android devices based on the data from Segment events, using Courier’s notification platform. 

How to Set Up Automatic Push Notifications Based on Segment Events

How to set up automatic push notifications based on Segment events thumbnail

oleksii-image

Oleksii Klochai

Once upon a time, SMS was the crowning achievement of communications technology. It combined email’s asynchronous archive of messages with a portable device, allowing anyone to send and receive information anywhere they were. Today, widespread mobile internet access has somewhat eclipsed the main functionality of SMS, but it remains a dominant form for communication in many markets and in particular business cases.

SMS is typically suited to messages that need to arrive quickly and reliably. Although mobile apps can handle messaging in many cases, SMS software on phones requires no app and remains largely unchanged for decades; it therefore has better uptime and reliability than other messaging services. Mobile networks supporting SMS are also more extensive and cheaper to operate in remote areas, so messages like appointment scheduling, order information, and two-factor authentication can be more reliably delivered by SMS.

Many B2B and even some B2C use cases benefit from using SMS as a communication channel, but implementation can be expensive. SMS providers have variable logging and documentation, and often are limited in user-preference customization. It can often make sense to centralize these concerns in a single tool that can handle all the messaging channels you use, can integrate with your data management ecosystem, and allows you to implement complex logic around the sending of your notifications. Courier is an all-in-one notification platform that does just that.

Courier delivers easy access to the messaging providers you use, all in a familiar language and with documentation that’s comprehensive and easy to follow. This page will give you an overview of the SMS providers supported by Courier’s text messaging API, so that you can assess if moving towards a messaging management tool is right for you.

## Text message notification API – layers of tools

Like any software process, sending SMS messages to your users involves a series of individual tools. At each step of the SMS journey – starting with an internal call in your software for a message to be sent and ending in the cellular networks that deliver actual data to phones – there are product decisions to make. It all starts with the SMS API.

## What is a text message API?

A text message, or SMS, API is an API exposed by an SMS provider that you integrate into your own project’s codebase so that SMS messages can be sent automatically.

A third-party text message API is the basic service you will need to send SMS messages. There are many different SMS providers out there, and it can be overwhelming trying to decide between a bunch of different options when they might initially all appear to be very similar. Some things you may want to consider when looking at different providers are:

- **Regionality:** Does the provider cover the political or geographic region where your customer’s phones are?
- **Price**: Rate per message can vary widely between providers. Assuming your other needs are met by a given company, compare provider price per user to the value it brings you.
- **Reliability**: Providers make different guarantees about the stability and reliability of their network, and may also have different rate restrictions.
- **Logging and monitoring**: Does the provider offer a good monitoring and logging page that makes it clear that an SMS has failed and why?
- **Documentation and support**: Is the SMS provider’s API comprehensive and well-documented? Do they offer clear and simple lines of communication?
- **Integration with third-party systems in your stack**: If you need to trigger an SMS based on other systems in your stack such as a customer data platform, is this possible? Or if, on the other end of things, you want your message delivery logs to be integrated into a wider monitoring system or observability platform, can you do this easily?

## Finding the right SMS provider

The SMS providers, vendors who actually send messages on a network for you, can be hard to choose among, but are often the biggest cost in a text messaging campaign. We have already discussed some basic elements of a provider’s service that should be considered, but there are a nearly endless list of gotchas that might make your life harder, if you don't keep them in mind while picking a provider.

Firstly, you need to ensure that any service you’re going with actually offers all the features you need. Depending on your messaging needs, this might include:

- [SMS short code](https://www.twilio.com/docs/glossary/what-is-a-short-code) support: for high-throughput, mass messaging campaigns.
- Toll-free numbers: to reduce friction in markets where customers are conscious of potential fees for responding to your messages.
- [Alphanumeric sender ID](https://blog.burstsms.com.au/sms-marketing/what-are-alphanumeric-sender-ids/): this can help maintain trust in a messaging channel that is sometimes associated with spam, but it is not always supported by SMS providers.
- Regional support for regulations and local laws (for example, stop codes to remove recipients from the marketing list).

Again, we must stress that you should be aware of the quality of the SMS provider's API, the documentation for it, and the customer support provided with it. Communicating efficiently across a cell network and building a modern, highly performant API or SDK are two different projects, and not all providers that are good at the former are capable with the latter. If you find the perfect service at a good price point, you might still end up paying in drag on engineering teams as they work around a shoddy SMS API.

Because the provider matters so much, we [maintain comparisons](https://www.courier.com/integrations/list/transactional-sms/) to help our clients (and anyone else!) understand the best options on the market.

## When to use Courier with an SMS API

While most SMS providers’ native APIs are easy to use, allowing developers to send SMS messages globally with only a few lines of code, they can be limiting in the long-term development of a mature notification strategy. On the other hand, using a notification platform on top of a standard SMS API can yield important advantages to your SMS process:

### Improve reliability, flexibility, and developer velocity

Most of the distinct advantages of a notification platform like Courier are flexibility improvements at the junction between the SMS provider and your own codebase. Rather than overcompensating for irregularities between your own servers and the distant, complex architectures of a cell network, a good notification platform will cushion the interface and improve reliability for provider failover while also provisioning advanced retry, along with comprehensive logging and error handling.

While discussing SMS providers, the thought must have occurred to you: what happens if we expand to a new market not covered by our provider? There are many cases that could require a change of SMS vendor: service changes, legal developments, or new feature rollouts. When your business logic is routed through a notification platform, it becomes easy to price-shop between different providers – with a notification platform there’s no “soft lock-in” from the fear of diverting developers to build a new codebase for a strange new API.

Product quality also flourishes with a notification platform. You can design generalized strategies for messaging, and easily switch between channels other than SMS to deliver your message to customers. Common template designs and management allow strong identity while minimizing work to standardize copy and brand image.

![A medical-style diagram of the bones in a leg – the thigh bone is labeled “Your codebase,” the shin is labeled “SMS provider,” the kneecap is labeled “Courier”](//images.ctfassets.net/z7iqk1q8njt4/35XLavfGLuWyyLwroxoRul/a8c668dde3488a2ef3115f80e7e3fd4f/Best_Practices_for_SMS_Tools_and_Text_Message_API_Implementation_1.png)

*A notification platform reduces strain at the join between vital services.*

### Collect and manage data

One of the most important pieces of customer data when it comes to SMS messaging is a given user’s preferences for contact. A notification platform like Courier doesn’t only provide opt-in  preference by topic but also allows for fine-tuned controls on message frequency, delivery time, or batched daily notifications that don’t flood users with information.

User response to messages is an important metric that you will use for further marketing. Horizontal integration to other tools like customer data platforms allows you to maximize the usage of this information – with Courier you don’t need to make these connections yourself.

Courier also maximizes your own observability data. Third-party tools that allow you to quickly alert on delivery failures and view metrics for errors are seldom integrated with a given provider’s API, but Courier allows you to bring that information to your devops dashboards.

## Check out our guides for specific, in-depth usage of Courier’s notification platform

It’s clear that there are some general benefits to using a notification platform to supplement your text messaging API – but at Courier we have developed a number of specific guides for common use cases to help conquer a particular problem. Check out the following tutorials to get an idea of what is possible with a mature notification platform, or maybe as a direct guide for the project you’re currently developing!

- [Use Courier with an SMS API to write an SMS password reset in node.js](https://www.courier.com/blog/how-to-send-password-resets-via-sms-and-email-using-node-js-and-next-js/)
- [Use Courier and Twilio with node.js to create a complete notification system for SMS, or any channel](https://www.courier.com/blog/automated-sms-notification-system/)
- [Seamlessly expand an existing email strategy to an SMS alternative using Courier and Twilio](https://www.courier.com/blog/how-to-add-a-direct-twilio-sms-integration-with-sendgrid-emails)

And although these guides lean on Node.js development, Courier supports a suite of programming languages – from [Go](https://www.courier.com/guides/golang-send-sms) to [Java](https://www.courier.com/guides/java-send-sms), [Ruby](https://www.courier.com/guides/ruby-send-sms) to [Python](https://www.courier.com/guides/python-send-sms), we can show you how to get a quick text message API up and running.

## Courier gives you flexibility

When choosing an API package to launch your SMS development, pick tools that meet you where you are. Whether you are looking for easy brand customization, advanced user preference management, or easy multi-channel messaging support, Courier has it – and documented in a language you already know!

If all the discussion of text message APIs didn’t satisfy your curiosity about the use cases for SMS vs. push notifications, [we have you covered](https://www.courier.com/guides/sms-notifications/). If you’re interested in our product and want to see it in action, [we can set up a demo for you](https://www.courier.com/request-demo/). Or you can jump straight into a test drive, and [sign up to the app for free](https://app.courier.com/signup), where you can send 10,000 messages per month in our introductory tier.

We have SDKs in Ruby, Go, Python, Javascript, Node.js, and React.  

Get started sending notifications with Courier in minutes, not days!

Best Practices for SMS Tools and Text Message API Implementation header

From selecting a provider to navigating a text message API, text message marketing is far from simple. This page gives a guide for best practices in the space.

Text Message API Implementation and SMS Tools Best Practises

Best Practices for SMS Tools and Text Message API Implementation thumbnail

Best Practices for SMS Tools and Text Message API Implementation

Perhaps because we are constantly swamped with push notifications, they can go overlooked as a messaging category. They are nevertheless an important medium of modern communication, and a more diverse one than you might think.

Push notifications initialize interactions between a recipient and a sender, in an era of communication where response times are measured in seconds. Such high-frequency information requires effective distillation to remain efficient and to avoid flooding recipients with noise.

Users don’t have to request push notifications and don’t have to sort through an archive to view them. Because push notifications propagate even if the associated app isn’t open, they are durable to intermittent usage of your app.

This makes push notifications a preferred way to inform a user about changes to a system, to announce new messages or in-app content, or to re-engage in an abandoned process. In comparison with channels such as email, SMS, or social media, push notifications allow you to pinpoint a user’s attention to a specific event, without overwhelming them.

This article will dive into the topic of push notifications and will explain how to use Courier’s push API to deliver simple, one-time push notifications to Android or iOS systems. Web notifications are also supported by a different Courier product ([toast messages](https://www.courier.com/docs/platform/content/brands/how-to-brand-inbox-toast/)), which is not covered here.

## Different flavors of push

Push messages are a surprisingly wide-ranging topic. As a software developer, there are contexts where you need to provide users with small pieces of unsolicited information – whether on desktop or mobile, in a browser or in an app, brief contact from out-of-focus programs are vital for program function.

### Desktop

[A top-down notification box on an Ubuntu desktop](//images.ctfassets.net/z7iqk1q8njt4/4oTQWyMsc8lUbgfU2XZ8EV/6e1c49ea5d6780f100bbeeb2ee00b5f8/push-notification-api-image-1.png)
__A top-down notification box on an Ubuntu desktop
__

Commercial computer systems today are capable of running dozens of programs simultaneously, but rarely do users have visual space on their device to view more than a couple at once. Push notifications in a desktop help visually hidden processes claim user attention for events that require their input.

### Web browser

![A Firefox notification box drops down with a message from a notification testing website.](//images.ctfassets.net/z7iqk1q8njt4/4N0CakPa6QnEBqi67eGJDX/23866eeef5e194911fa1a94724e501cf/push-notification-api-image-2.png)

__Test your own browser notifications at [Ben Kennish’s website](https://www.bennish.net/web-notifications.html).__

Similarly to desktop, the proliferation of tab-capable modern browsers has necessitated browser push notifications. Information about audio media from a background tab, new content in an auto-refreshing page, or the completion of a file download are all intermittent events that often require user response, and are therefore announced by push.

### Mobile

![A typical Android lock screen, with some push notifications from WhatsApp and Gmail.](//images.ctfassets.net/z7iqk1q8njt4/7JEJKVOFmnhwO4GWEOV6js/f69cf81f38385ff50cfa8affb2104fdc/push-notification-api-image-3.jpg)

__A typical Android lock screen__

Mobile push notifications are very different from desktop and browser pushes. For one thing, mobile devices are generally used more intermittently than computers or tablets. This means that push notifications are important, asynchronous updates that keep users informed.

Additionally, mobile devices have a much smaller visual field for information. That makes push notifications more common, but also means there is more competition for attention among all the push notifications.

Mobile push notifications are therefore extremely important to the usage of a mobile device. Unlike other types of push notification, mobile pushes have a separate pipeline for generating, queuing, and distributing individual pushes. The software and servers that deliver these pushes are operated by push providers.

Keep in mind that mobile push notifications are NOT the same as an in-app notification. In-app notifications, such as confirmation messages after a user changes important settings, occur **inside the app**, in a context where user attention can already be assumed, and are not queued or distributed using the same push notification network as a mobile push. To learn more about in-app notifications, see our article highlighting the use of [toast messages](https://developer.android.com/guide/topics/ui/notifiers/toasts) using Courier.

## Pick a push provider, don’t use their push API

Mobile push notifications are sent to users through a specific provider’s service. Like a mobile network, that provider facilitates collecting and distributing the notifications. (Unlike a mobile network, these providers’ dispatches are broadcast not by cell towers, but by internet servers.)

Each provider has a number of advantages and disadvantages. Some providers – like Firebase Cloud Messaging – might already be ready to integrate with your existing customer tools. Others, like Apple Push Notification Service, are well adapted to a particular mobile development platform. Providers like OneSignal might offer support for your entire suite of customer messaging channels.

### Courier’s value add

Courier is not a push provider itself, so why bring Courier into the mix? Although most push services are reliable utilities with their own push API, they really only handle the message delivery. Metrics about the messages, including their conversion rates, and advanced controls for user preferences are still the domain of the back-end engineer.

Courier supports and extends the existing API of your push provider, while delivering incredible customization options. It enables you to match customer details to the message, handle messaging across channels, and create extensive logging and error handling for when phones can’t get connectivity. Courier also integrates well with adjacent tools in your stack – including customer data platforms like RudderStack and Segment, and cloud observability platforms like Datadog.

Whatever mobile push use case your marketing team might dream up, Courier can deliver. Courier supports the deployment of [many push providers](https://www.courier.com/docs/platform/channels/push/). Our long-term support and the peace of mind we offer will help you get on track while building up your own service.

### Bringing Courier online

Firebase Cloud Messenger is a common push notification service that supports easy Android and iOS development. Our docs outline a [simple but comprehensive](https://www.courier.com/docs/platform/channels/push/firebase-fcm/) process for testing out pushes via Courier in Firebase Cloud Messenger.

## Delivering pushes with care

With Courier, you have out-of-the-box support for your marketing strategy. What’s more, you have that same support for channels such as SMS, email, Slack, or MS Teams.

If you want to learn more about our support for your push services, you can read through the [documentation for our push notification API](https://www.courier.com/docs/platform/channels/push/), request a [demo](https://www.courier.com/request-demo/), or [sign up to the app](https://app.courier.com/signup), where you can send 10,000 messages per month, for free.

Let us keep you in touch with your users!

push-notification-api-header

Courier’s push API extends that of your push provider, with customization options to help you notify your users in real time on desktop, mobile, and browser.

How to Use a Push API to Send Notifications from your Mobile App

push-notification-api-thumbnail

Martina Caccamo avatar

Martina Caccamo

Have you downloaded Courier's iOS SDK yet? It's the easiest and most effective way to communicate with your users using push notifications.

Get the Courier iOS SDK

image1

This tutorial explains how to send Firebase notifications to iOS devices from your iOS application code using Firebase FCM and Courier’s iOS SDK.

How to Send Firebase Notifications to iOS Devices Using Courier

image14

## Toast Messages: What They Are, Why They Matter, and How to Use Them

In-app messaging has become an essential part of how modern products engage users, deliver feedback, and guide actions in real time. As communication standards evolve, users expect fast, relevant updates that feel seamless—not disruptive. One of the most effective patterns for this is the **toast message**: a short, unobtrusive notification that provides instant feedback and then disappears without requiring interaction.

Today, toast messages are a UX standard across mobile apps, web platforms, and SaaS products. They are crucial for confirming user actions, surfacing important but non-critical updates, and reinforcing positive user behaviors—all without breaking the user's focus or workflow.

When used correctly, toast notifications can:
- **Improve user satisfaction** by providing immediate feedback
- **Support faster onboarding** by guiding new users non-intrusively
- **Highlight feature discovery** at exactly the right moment
- **Reduce friction** in high-frequency actions like settings updates, file uploads, or checkouts

In this guide, we'll break down:
- What toast messages are and why they matter
- How toasts compare to snackbars, push notifications, and in-app inboxes
- Best practices for designing and timing toast notifications
- How Courier helps you unify toast messaging across multiple channels

If you want your product to feel faster, smarter, and more user-centered, mastering toast notifications is a key step—and an opportunity to improve engagement at every touchpoint.

## Toasts vs. Snackbars vs Banners: Clearing Up the Terminology

You might notice that different platforms use different terms for lightweight in-app notifications. Here's how they generally break down:

- **Toast Messages** are short, passive notifications that appear briefly and disappear automatically. They don't require any user action. Toasts are common in Android apps, web apps, and SaaS platforms.

- **Snackbars** (Material Design term) are similar to toasts but often include an optional action, like "Undo" or "Retry." Snackbars still auto-dismiss if no action is taken.

- **Banners** (iOS and other platforms) are slightly more prominent notifications that may persist until the user interacts. They’re often used for important updates like account issues or verification prompts.

While terminology varies, the goal is the same: deliver feedback or updates without disrupting the user's experience. Choosing between a toast, snackbar, or banner depends on how important the message is, and whether you want the user to take action.

| Feature                        | Toast Messages                  | Snackbars                        | Banners                          | Push Notifications               |
|---------------------------------|----------------------------------|----------------------------------|----------------------------------|----------------------------------|
| **Primary Purpose**             | Provide passive, quick feedback | Provide feedback with optional action | Display important info, often requiring action | Re-engage users outside the app |
| **User Interaction**            | No interaction                  | Optional action (e.g., Undo)     | Optional or required actions     | May open the app or deep link    |
| **Persistence**                 | Disappears automatically        | Disappears automatically         | Persists until dismissed or acted on | Stays until dismissed or interacted with |
| **Context**                     | Inside the app                  | Inside the app                   | Inside the app                   | Outside the app (OS-level)       |
| **Typical Placement**           | Bottom or top of screen          | Bottom of screen                 | Top or bottom of screen           | Device notification tray         |
| **Best For**                    | Confirming minor actions        | Reversing quick actions, retries | Alerting users to important info like warnings or updates | Bringing users back to the app   |
| **Risk if Misused**              | Missed important feedback       | Accidental action if not careful | Annoyance if overused             | Intrusiveness, notification fatigue |
| **Common Examples**             | "Settings saved"                | "Message deleted [Undo]"         | "Account needs verification"     | "You have a new message!"         |

## A Closer Look at Toast Messages

![Toast Image Example](//images.ctfassets.net/z7iqk1q8njt4/05G29k0tS5IC6Sj2REZSq/63149a4b8828d16d0dace2f8b7b2f664/image.png)

Toast messages are brief, unobtrusive notifications that provide instant feedback inside an app. They appear temporarily on the screen—without requiring user interaction—and automatically fade away after a few seconds.

Most commonly used in **mobile apps** where screen space is limited, toast messages are also found in **web applications**, **desktop software**, and even **video games**. Their lightweight design makes them ideal for delivering confirmation messages, quick tips, or non-critical updates without disrupting the user's flow.

Toast messages first gained popularity on [Android devices](https://developer.android.com/guide/topics/ui/notifiers/toasts), but the concept quickly expanded beyond mobile. Today, toast notifications are widely used across platforms—including [iOS libraries](https://github.com/scalessec/Toast-Swift), web applications, and even desktop operating systems.

The primary purpose of a toast message is to deliver **immediate feedback** or **draw attention** to a specific part of the app, without interrupting the user’s experience. Toasts can be as simple as confirming a successful action ("Settings saved") or part of a broader system—like guiding users through onboarding steps, upselling features, or highlighting important updates at the perfect moment.

Although the design and behavior of toasts may vary slightly by platform, they generally follow three core principles:
- **Unobtrusive**: Small, subtle, and positioned out of the way of critical content
- **Non-interactable**: Users typically can't take action beyond letting the toast expire or manually dismissing it
- **Short-lived**: Toasts automatically disappear after a few seconds, keeping the interface clean

Understanding what makes a toast message effective—and knowing when it’s better to use another notification format—is key to delivering a smooth, user-friendly experience. Next, we'll explore how toast messages compare to snackbars, push notifications, and in-app inboxes.

## When Toast Messages Aren’t Enough: Other Messaging Formats

Toast messages are perfect for quick, non-disruptive feedback—but not every situation calls for a toast. Depending on the urgency, persistence, and context needed, different messaging formats might serve your users better.

Let’s break down the main alternatives to toast notifications and when to use them.

---

### In-App Notification Centers

An **in-app notification center** serves as a centralized place for users to review all the communications related to your product—from quick toasts and push notifications to system updates and important alerts.

Unlike ephemeral messages, **notifications stored in an in-app center are persistent**, allowing users to revisit information whenever they need it—even if they missed the original toast or dismissed a push.

Advanced platforms like [Courier’s in-app inbox](https://www.courier.com/blog/app-notifications-inbox/) take this even further by syncing messages across channels. For example, if a user reads an email, Courier can automatically mark the corresponding in-app message as read, keeping everything aligned.

By giving users a reliable way to catch up on missed messages, in-app notification centers help improve clarity, reduce frustration, and create a smoother, more connected experience inside your app.

---

### Snackbars: Interactive, Temporary Feedback

**Snackbars** are a form of in-app notification that briefly displays feedback along with an optional action—typically near the bottom of the screen. 

![Snackbar UI Example](//images.ctfassets.net/z7iqk1q8njt4/68C7TokJjlBl4SbotIJdgk/d106d18b02f02b50f621877b77eccf34/snackbar_example.jpg)

While similar to toast messages in their lightweight, temporary nature, snackbars differ by offering users a chance to respond. Common examples of snackbar interactions include:
- "Item deleted. [Undo]"
- "Payment failed. [Retry]"
- "File uploaded. [View]"

Snackbars are ideal when you want to acknowledge an event while giving users a quick opportunity to reverse or act on it. However, because snackbars are small and short-lived, the actions they offer should be simple, safe, and easily reversible—avoiding critical or irreversible decisions.

---

### Push Notifications: Re-Engage Users Outside the App

**Push notifications** allow you to reach users even when they’re not actively using your app. They’re effective for:
- Alerting users about important updates
- Reminding them to return to the app
- Notifying them of time-sensitive events

While push notifications share the brevity of toast messages, their primary role is re-engagement. They are displayed outside the app’s context, making them ideal for drawing users back after an event, promotion, or system update.

⚡ **Pro Tip:** Use push notifications for external re-engagement. Use toast messages for in-the-moment, inside-the-app feedback.

---

### Persistent Messages: Email and SMS

**Persistent messages**—such as emails and SMS—are designed to be durable. They remain accessible to users until they manually delete or archive them, making them the best choice for information that needs to be saved or referenced later.

Common use cases for persistent messages include:
- Appointment confirmations
- Discount offers and promo codes
- Password resets and account recovery
- Legal notifications and receipts

Unlike toast notifications, which disappear quickly, persistent messages ensure critical information stays available over time. Whenever the user needs a record of an action or communication, persistent messages provide a reliable reference point.

## When and How to Use a Toast Message

Toast notifications are powerful when used at the right moments—but not every user action deserves one. Here's how to decide when a toast is the right choice:

Use a toast message when you need to:
- Confirm a successful user action (e.g., "Settings saved")
- Indicate that a background process has started or completed
- Highlight a lightweight, non-critical update without disrupting the user’s flow

Avoid using a toast when:
- The user needs to take immediate action (use a snackbar instead)
- The event is critical and must be acknowledged (consider a modal or alert)
- The message needs to persist over time (use a push notification, email, or in-app inbox)

In short: **Toast messages are best for providing quick feedback that reassures the user without demanding attention or action.**

Choosing the right notification type ensures your product feels responsive, respectful, and easy to use—without overwhelming users with unnecessary interruptions.

## Bring Every Channel Together with Courier

Toast messages are just one piece of the modern messaging puzzle. To create a seamless user experience, you need to deliver the right message, on the right channel, at exactly the right moment—whether that's inside your app, through a push notification, via email, SMS, or even Slack.

Courier makes it easy to orchestrate all of your communications from a single platform. With Courier, you can:
- Send toast messages, push notifications, emails, SMS, and Slack alerts—all from one unified API
- Customize the look and feel of every message, ensuring a consistent experience across every channel
- Build an in-app notification center that syncs seamlessly with external channels
- Manage routing, preferences, batching, retries, and fallbacks automatically—no custom code required

Whether you're confirming an action inside your app or delivering a critical update to a user's inbox, Courier helps you turn notifications into a powerful extension of your product experience.

Ready to see how easy multi-channel messaging can be?  
[Request a demo](https://www.courier.com/request-demo/) or [get started for free](https://app.courier.com/signup)—and send up to 10,000 messages per month at no cost.

Toast messages, their use cases, and examples header

Learn when to use toast messages, snackbars, banners, or push notifications. Improve your in-app messaging strategy with Courier’s multi-channel platform.

Toast Messages vs. Snackbars, Banners, and Push Notifications | Courier

Toast messages, their use cases, and examples thumbnail

Toast Messages: When to Use Them vs. Snackbars, Banners, and Push Notifications

SMS is the most reliable and highly-read notification channel, making it a popular choice for developers who want their systems to send notifications to their users. If you’ve got an application that needs to send out short, important, time-sensitive messages, you should consider integrating an SMS API into your system to help you handle this.

In this article, we explain how to choose the right SMS API provider for your needs. We also cover how using Courier can help save a lot of the headache of deciding on a provider, as well as how it offers extra functionality to enhance your SMS sending strategy.

We’ve also published an in-depth [comparison of the most popular SMS providers](https://www.courier.com/guides/transactional-sms-service/) that will be useful to developers who want to get into the details of what makes one provider better than another.

Courier is a full-fledged notification platform that integrates with many SMS APIs, as well as other types of notification channels like email, chat, and push notifications.

## What is an SMS API, and when should you use one?

An SMS API does what it says on the tin: it‘s an API (developed by a third party) that allows you to incorporate text messaging capabilities directly into your application, meaning you don’t have to deal with the behind-the-scenes details of how to physically send SMS yourself.

An SMS API is the sensible decision for companies who need to send SMS from within their app. There is no need to reinvent the wheel when so many affordable and simple APIs are available.

An important question to ask, though, is when it’s appropriate to send an SMS versus other potential channels of communication such as an email or a push notification. SMS is an excellent option for urgent communications as users tend to read SMS messages [more than any other types of notifications](https://www.gartner.com/en/digital-markets/insights/the-future-of-sales-follow-ups-text-messages). This is great if you need to alert your user to something important and time-sensitive, such as a package delivery arriving at their house in the next few hours.

But beware of sending too many SMS notifications! Spammy text messages can annoy users and cause your number to get blocked, so you should always consider whether another channel is more appropriate. For example, if you have an e-commerce site and a user orders a product, an email confirmation of this will suffice — there is no need to send an SMS in this situation.

Understanding when different notification channels are appropriate will help you give your users the best experience of your product. Some examples of different notification topics and the suggested notification channel are included here, along with our reasoning, to help you decide how to make good decisions about the right type of channel to use.

| Notification topic | Suggested channel | Reason |
| --- | --- | --- |
| Two-factor authentication | SMS | SMS is considered a more secure channel than email as email is more likely to be hacked than SMS. However, it’s worth noting that even SMS can be hacked through the practice of SIM swapping, so a 2FA app is an even more secure approach. |
| Welcome notification for new users | Email | This is non-urgent and your user can read it at their leisure. Email inboxes are also more easily searchable should your user need to find this message at a later date. |
| Important appointment reminders | SMS | If both you and your user are likely to agree that the appointment reminder is urgent, then you should use this channel. |
| Receipt of a purchase | Email | Email is a great place to keep notifications that are useful for the user’s records but which may not be particularly interesting to read right away. |
| A special offer aiming to tempt users back to using your app | Push notification | If you’re trying to increase user engagement, push can be a good approach, as these notifications are more prominent and more likely to be read than emails. Just remember to keep the message short and sweet. And don’t be tempted to use SMS for this purpose — although your message will be more likely to be read, your users won’t thank you for using an urgent channel for blatant marketing purposes. |
| In a workplace workflow system, a reminder that a task is ready to be worked on | Workplace chat app (Slack, MS Teams etc.), or email | Some companies like to keep a lot of their workflow information inside their team chat app, whereas others prefer email. Either way, SMS would not be a good choice for a potentially high-volume type of message, as this could be annoying for recipients. |
| System outage alert (to be sent to the system administrator) | SMS | This is the most urgent category of notification and it’s essential to make the sysadmin aware ASAP, so there can be no doubt that SMS is the right channel. Additionally, SMS infrastructure exists largely outside your own systems, so it is more likely to be a functional channel during an outage. |

## Choosing an SMS provider

An SMS provider is any third-party company that develops an SMS API. There are many out there, so how do you choose the right one for your project?

It helps to first understand your project requirements. Consider these questions, and then find out if the provider you’re looking at offers the features you need.

- Are you looking to send a large volume of messages?
- Will you be sending SMS internationally?
- Do you need to integrate any other third-party software into your code, and do any of the providers already have integrations with such software (for example, customer data platforms or cloud monitoring systems)?
- Do you want to use features like SMS short codes and alphanumeric sender ID?
- What are the legal requirements for SMS messages in your jurisdiction?

Any provider you’re considering will get bonus points for:

- Having an API (and documentation!) that’s clear and easy to use
- Offering good value for money
- Having a reputation for good developer support (tip: the comments of Hacker News and Reddit can often be a good starting point for understanding how other developers feel about these products)
- Easily integrating with your existing software stack

## How to supercharge your SMS notification strategy

Today it’s worth looking beyond a basic SMS API. Using a full-fledged notification system like Courier can give you much-needed extra functionality, including the ability to send notifications to different channels like email and MS Teams, or to easily switch out one SMS provider for another.

![A flow diagram showing how Courier simplifies the amount of code you need to write if you want to send notifications via multiple channels. Without Courier you would have to configure Twilio and use its SMS API, configure SendGrid and use its email API, configure Firebase and use its push API, etc. However, when using Courier, you only need to configure and use one API for all channels.](//images.ctfassets.net/z7iqk1q8njt4/1lvNJ6A4Gs2ttrGBHiXGp6/f80cbe994e26e1511587fb5ebe1e54a7/A_developer_s_guide_to_choosing_an_SMS_API_for_your_project.png)
*Courier makes it easy to use a single “send” API endpoint to send messages to multiple channels or multiple providers.*

Without Courier you would have to configure Twilio and use its SMS API, configure SendGrid and use its email API, configure Firebase and use its push API, etc. However, when using Courier, you only need to configure and use one API for all channels.

With Courier, you can even incorporate SMS with other notification channels. For example, you might send SMS for some parts of a workflow, emails for another, and push notifications for yet another. You can keep all your message templates in one system, and allow non-developers to edit the content of the messages.

You can also add advanced logic around your notifications. For example, you could try sending a push notification or email first, but if the user hasn’t read it within a certain timeframe and it’s urgent, automatically send an SMS. Courier also gives you the ability to retry if there’s a problem sending, as well as advanced logging and error handling.

One feature that’s a real game changer is the ability to trigger the sending of your SMS from customer data platform (CDP) events such as [Segment](https://www.courier.com/blog/smarter-customer-engagement-flows-segment-integration/) and [RudderStack](https://www.courier.com/blog/customer-data-insights-and-analytics-rudderstack/), and to do this within the Courier app, with no need to bother integrating your CDP API into your application code.

Courier provides a simple way for user notification preferences to be recorded and respected. This includes features such as opting in/out of specific communication channels (including SMS) or particular notification topics (such as marketing messages) so users will never need to be annoyed by a notification. Courier also offers [internationalization options](https://www.courier.com/docs/platform/content/notification-designer/internationalizing-notifications/), allowing you to send SMS in different languages, based on the region your user is located in.

Finally, it’s worth mentioning that Courier has been designed to be a joy for developers to use. With SDKs added for the most popular languages, it’s much less clunky than directly calling an API, and you can use the same API endpoint call for sending all different types of notification, for all different providers and user devices.

## Conclusion

Choosing an SMS API provider requires careful thought. The most common decisions will be based on price, ease of use, quality of developer support, and whether the company can support the number of notifications you need to send.

If you want your SMS notification strategy to be part of a wider notification strategy involving other types of notification, if you anticipate wanting to add logic around your notification sending procedures, or if you want to have a degree of user personalization over your messages, a system like Courier makes sense.

As Courier is a full-spectrum notification platform, you can plug in different notification providers for SMS, push, email and chat into it. Courier offers many different SMS providers, and if you decide you want to switch providers at any time, it’s super easy to switch one out for another.

If you’d like to try out Courier, you can [sign up](https://app.courier.com/signup) to our free tier for 10,000 free notifications or [get in touch](https://www.courier.com/request-demo/). You’ll need to set up an SMS provider as well — here is a guide on [how to send SMS using Twilio and Courier](https://www.courier.com/blog/automated-sms-notification-system/).

How to choose an SMS API for your project header

We explain how to choose the right SMS API for your project and show how using Courier’s multi-channel notification platform can make things easier.

How to Choose the Right SMS API for Your Project

How to choose the right SMS API for your project thumbnail

Most people who interact regularly with smartphones and tablets are familiar with what a push notification is. They want their calendar application to post an alert to their mobile or desktop interface, for example, whether or not they have the app open or their screen locked. If they want to change when, how, or if they receive notifications at all, they simply adjust those in the application settings.

For app developers, push notifications are a great way to keep users engaged with a product. Used properly, they can [significantly increase your click-through rate](https://www.mobiloud.com/blog/push-notifications) compared to an email blast.

Of course, never-ending alerts can get annoying. You don’t want to intrude so much that a user would uninstall your app. It’s crucial that you offer your users flexibility, giving them several options for managing notifications beyond just turning them on or off. Push notification APIs can integrate with your application for convenient and efficient management of these alerts and the data that comes with them.

Push notifications have been widely used [for more than ten years](https://en.wikipedia.org/wiki/Push_technology#Push_notification), so there’s no shortage of such services on the market. To make choosing one less of a challenge, we’ll review the seven most popular services and walk you through their main features.

To properly compare the services, we’ll weigh them against the following set of factors:

- **API documentation/SDK:** how easily the service integrates with your code, how accurate the documentation is, and whether the service supports all mobile languages
- **Features:** what the main service features are and whether it has common features for notification APIs
- **Price:** what the cheapest plan is, what exactly it covers, and how the pricing scales

## **1. [Airship](https://www.airship.com/)**

![A screenshot from Airship’s homepage.](//images.ctfassets.net/z7iqk1q8njt4/7tt7n6M9sibuo6EZm5I4eL/14bc99421f257a9a7bc959e33be8f839/airship.png)

Airship, formerly Urban Airship, is one of the oldest and most reliable services, founded in 2009 at the very beginning of the push notification era. It offers more than just push notification services; it’s an all-in-one tool, a platform that combines products for customer engagement, lifecycle marketing, and data solutions. It also allows for a high level of personalization for push notifications.

Airship partners with all sorts of companies, but it might be more beneficial for large companies (think AstraZeneca, the BBC, or Zillow) because of its emphasis on [reliably delivering billions of push notifications in real time](https://www.airship.com/platform/channels/mobile-app/push-notifications/) and coordinating huge marketing campaigns.

[Airship documentation](https://docs.airship.com/tutorials/getting-started/overview/about-airship/) is very comprehensive and detailed, with support for Android and iOS, Windows, and web platforms. Multiple SDKs and [REST API endpoints](https://docs.airship.com/api/ua/) make for easy integration with your app.

**Pricing:** You can start with a free account or even download a demo app to send yourself a push notification to give Airship a try. Airship lets you have up to 1,000 users before you have to [subscribe to their paid “App Experience Platform (AXP)”](https://www.airship.com/platform/pricing/) at $25k/year, and the free service covers only basic features: push notifications, web notifications, and in-app messages.

AXP isn’t the cheapest option, but that’s because it’s not just a simple push notification service — it also offers many other features, such as in-app messaging, a notification center, and deep user personalization and control over messages.

## **2. [Expo](https://expo.io/)**

![A screenshot from Expo’s homepage.](//images.ctfassets.net/z7iqk1q8njt4/2dkC84pGt6r382zMnKnguI/84f236171a7ab8f295300ed2640a6dd0/expo.png)

Expo is a framework and platform for React Native-based applications. It allows you to build and deploy apps for web, iOS, and Android with the same codebase. In general, Expo is well-known for being [easy to set up](https://expo.io/), and you can say the same about its push notification API — it’s very intuitive. You probably don’t even need to get through all the documentation.

However, [Expo’s documentation](https://docs.expo.io/push-notifications/overview/) is clear and to-the-point. You can easily learn as you go, and like most of these services, it offers SDKs for multiple server-side languages and a RESTful API to integrate with any type of back end. Expo’s [push notification tool](https://expo.io/dashboard/notifications) can help you test sending push notifications to your Expo project, so there’s no need to struggle with the back end — which is great for building prototypes.

For React Native-based apps, Expo makes the implementation of push notifications easier and more intuitive than a direct connection to Apple Push Notification service or Firebase Cloud Messaging, allowing you to treat iOS and Android notifications the same in your back end.

The only disadvantage is that the Expo push notification API works only if you build your whole app in Expo, implementing React Native. Still, this framework is widely used.

**Pricing:** Expo is free, which is one reason why it’s so popular among React Native developers; however, it does tie you into using Expo Application Services (EAS), a service for building your projects. Your first 30 builds per month are free, but if you’re doing intensive development then you’ll need to pay in order to run regular builds. EAS currently offers usage-based pricing, at around [$2 per build](https://expo.io/pricing).

## **3. [Firebase FCM](https://firebase.google.com/)**

![A screenshot from Firebase’s landing page.](//images.ctfassets.net/z7iqk1q8njt4/2PNDOaMIiCXaLorncwaOK2/8ee0f88be6f20503ba26ee08dc169cee/firebase.png)

Firebase Cloud Messaging (FCM), formerly known as Google Cloud Messaging (GCM), is a cross-platform push notification API for Android, iOS, and web applications. It is one of many tools under the Firebase platform umbrella, allowing you to combine various products for web and mobile production.

Since it’s a Google product, it’s perhaps expected that FCM is reliable and easy to get started with. [The documentation](https://firebase.google.com/docs/cloud-messaging?hl=en) includes video tutorials, which make the setup even faster. FCM comes with ready-to-go authentication SDKs, so you have everything you need to build your entire flow. And, of course, you can easily integrate with Google marketing platforms, such as Google Ads.

FCM is one of the most widely used push providers, and with a tech giant like Google behind the service, you can have confidence in its reliability.

**Pricing:** The [Cloud Messaging (FCM)](https://firebase.google.com/pricing/#cloud-messaging-fcm) part of Firebase is completely free, and includes some extra features like A/B testing, analytics, and app distribution. You may need some budget for storage, monitoring, or authentication, but many users will be able to implement a small business case free of cost.

## **4. [OneSignal](https://onesignal.com/)**

![A screenshot from OneSignal’s homepage.](//images.ctfassets.net/z7iqk1q8njt4/1vgJHCSylBn1pl5mE52RDw/6d6a499fc78fd62e2e87404f20b701e2/one-signal.png)

Unlike many others — Expo and FCM, for example — OneSignal is not a framework or a multi-product platform. Still, it’s one of the leading push notification companies. Founded in 2014, OneSignal powers all sorts of customer engagement tools: mobile (both iOS and Android), web, emails, SMS, and in-app messages.

[OneSignal documentation](https://documentation.onesignal.com/docs) goes into depth and covers all the issues you might have during setup and integration with third parties. Its SDKs are very user-friendly; it’s easy to implement and has an API that enables simple integration with platforms and services. Powerful analytics tools allow you to track push notification performance.

OneSignal provides an unlimited number of API calls and high-volume usage and doesn’t charge additionally for this, as some companies do. The quality of its customer service is highly acknowledged in the developer community, as well.

**Pricing:** OneSignal offers a robust free plan with core functionality that covers all the needs of a small startup. Other [plans](https://onesignal.com/pricing) include Growth (from $9/month), Professional (from $99/month), and Enterprise (custom).

## **5. [Pusher Beams](https://pusher.com/beams/)**

![A screenshot from Pusher Beams’ product landing page.](//images.ctfassets.net/z7iqk1q8njt4/49zOVz9bVhQh7NgH1ZzI19/958e407c79ac234cc454894614502fbd/pasted_image_0.png)

Beams is a product from the MessageBird company Pusher. MessageBird is a conglomerate with a wide range of messaging products, and [Beams](https://pusher.com/beams/) is their push messaging tool, with a variety of SDKs. You can [develop for iOS, Android, or web, all in whatever language](https://pusher.com/docs/beams/reference/all-libraries/#client-sdks) you use in your back end.

Consistent, clean documentation helps you understand the big ideas behind Beams, such as [webhooks](https://pusher.com/docs/beams/concepts/webhooks/). Webhooks automatically trigger behaviors in your application when certain Beam events happen, such as a user opening a Beam push notification on their devices. Beams also integrates with Pusher’s other product line, [Channels](https://pusher.com/channels/), a real-time communication tool for everything from gaming to direct messaging.

**Pricing**: Pusher Beams [offers the typical free starter package for up to 1000 users](https://pusher.com/beams/pricing/). Fixed-price plans offer decent customer support on a scale from $29/month for 10,000 users all the way up to 250,000 users at a price point of $399/month. The Enterprise option offers better per-user rates and has extensive customer support.

## **6. [Beamer](https://www.getbeamer.com/push-notifications)**

![A screenshot from Beamer’s homepage.](//images.ctfassets.net/z7iqk1q8njt4/cr7ebEQMFXBtnZTpwDczN/289a82b968ed6082fb78b74175b0b327/pasted_image_0.png)

Despite similar branding, [Beamer](https://www.getbeamer.com/push-notifications) is not to be confused with Pusher Beams. Beamer push notifications benefit from the [massive integration of Beamer products](https://www.getbeamer.com/integrations) with other SaaS tools. Beamer distinguishes itself with highly tailored products for people who want out-of-the-box solutions for [user feedback](https://www.getbeamer.com/nps), [changelogs](https://www.getbeamer.com/changelog), and more.

While their [documentation](https://www.getbeamer.com/docs/#parameters) might not be as extensive as other providers in the list, Beamer is in a lane for people who want quick functionality — a push product that “just works.” If you are looking for a product that’s simple to deploy, then it’s worth checking out.

**Pricing**: Beamer is priced as a combination of its total products, and the [free tier unfortunately doesn’t support push notifications](https://www.getbeamer.com/pricing). The Pro tier stands at $49/month and supports push notifications for 10,000 web visitors. Custom plans over $499/month allow wider broadcast of push notifications to a higher number of users.

## **7. [Apple Push Notification service (APNs)](https://developer.apple.com/documentation/usernotifications/sending-notification-requests-to-apns)**

![A screenshot from the landing page of APNs’ documentation. ](//images.ctfassets.net/z7iqk1q8njt4/16DhNbLWxzkQOajJMZNPQy/aee4d82f310d1269fea66b9f95d9be59/pasted_image_0.png)

This one is a bit unusual. Originally developed in the early days of smartphones to help spare battery life (background applications were notoriously power-hungry), APNs is Apple’s walled-garden solution to the problem of push notifications. Other push providers will generally support iOS pushes with a custom SDK that incorporates APNs, but any [iOS developer](https://developer.apple.com/documentation/usernotifications/registering-your-app-with-apns) can register their application to send notifications through the native APNs API.

If you are interested in tutorials introducing the actual usage of APNs and discussing iOS push notifications in more depth, [we have you covered](https://www.courier.com/guides/ios-notifications/).

**Pricing:** APNs is totally free, as long as you are developing within the iOS ecosystem.

## **Conclusion**

With lots of great push notification API providers offering different types of services, choosing the right one is a matter of understanding your business case for push notifications. Our list here tries to give an insight into the current marketplace, but as products grow and change, it's important to confirm the current state of each product with your own research. Ensure that the product meets your current needs and growth potential, at the right price point.

One way to manage the kaleidoscope of changing providers is to use a notification platform like [Courier](https://www.courier.com/) that allows your team to quickly slot in a new provider as your needs or budget change. Courier integrates with over 50 different notification providers, across a variety of channels including email, SMS, chat, and push notifications, meaning you can use one single API product for all your messaging needs.

Another benefit of using Courier is that it allows you to standardize branding and messaging across channels, organize users with integrated customer data systems, and even use generative AI tools to [automate basic messaging](https://www.courier.com/blog/ai-powered-notification-content-and-changelog/).

No matter how you choose to navigate the marketplace of push notification APIs, you’re sure to get your money’s worth from any company on this list!

Push notification API (page update) header

This article compares seven leading push notification APIs in terms of their features, quality of documentation and support, and pricing.

Top 7 Push Notification APIs for developers in 2023

Push notification API thumbnail

Top 7 Push Notification APIs

Adam Searle

Push notifications play a critical role in our digital world. They’re an essential tool for driving user engagement, ensuring retention, and delivering real-time updates, but implementing them in Android can be a complex task. Engineering teams are tasked with not only the technical implementation but also the logic that encompasses the entire notification experience. This includes sequencing notifications across multiple devices, managing tokens, complying with regional regulations, localizing notifications, and respecting user preferences. The challenge is far greater than just triggering a message.

Enter [Courier](https://www.courier.com/blog), a platform designed to streamline this process. Courier’s [Android SDK](https://github.com/trycourier/courier-android) provides a comprehensive solution for push notifications, simplifying the complex task of managing product-triggered communications across different platforms. 

In this tutorial, we will focus on Courier's push notification capabilities within Android apps, covering the setup process, key features, and how to send a test push notification. By the end, you’ll see how Courier can make managing Android push notifications a more manageable task, leaving you with more time to focus on creating a great user experience.

You can find the finished project at this [GitHub repo](https://github.com/trycourier/tutorial-android-push-notifs).

## Setting up the development environment

Before diving into the code, make sure you have all the tools and accounts you need. To work with the Courier SDK, you’ll need:

* **A Courier account**. If you don’t have one yet, you can [sign up here](https://app.courier.com/signup). (Don’t worry, everything we are going to do in this tutorial is free!)
* **Android SDK version 23 or later**. Your Android Studio project should be set to use a minimum Android SDK version of 23. Ensure that this is set in your project’s Gradle configuration. You can do this by navigating to your `build.gradle.kts` file at the app level and ensuring that `android.defaultConfig.minSdk` is set to 23.
* **A Firebase account**. [Firebase](https://firebase.google.com/docs/android/setup) is a requirement for Courier’s push notifications, as it handles the delivery of notifications to your Android devices. Your Android Studio project will need to be set up to use the Firebase SDK. First, add an Android app to your project in Firebase, and then follow the steps provided. If you already have an Android project in Firebase you want to use, go to your Firebase Android project, and then go to **Project Settings** > **See SDK instructions **and follow the steps there to add the google-services.json file to your project and to add the Firebase SDK to your Gradle build files.

_Note_: This tutorial assumes you are using the official IDE for Android development, Android Studio (Giraffe or later versions), and writing in Kotlin. If you’re not already using Android Studio, you can download it from the [official website](https://developer.android.com/studio). It comes bundled with the Android SDK that you’ll need for this tutorial. Covering the basics of Android Studio is not within the scope of this article, but if you need help getting started, check out the [official Android Studio documentation](https://developer.android.com/get-started/overview).

With these prerequisites met, you can now install the Courier SDK in your Android project by following these steps.

1. First, add JitPack repository support to your `settings.gradle.kts` file. JitPack is a repository where the Courier SDK package is located.

```java
pluginManagement {
    repositories {
        ..
        maven { url = uri("https://jitpack.io") }
    }
}

dependencyResolutionManagement {
    repositories {
        ..
        maven { url = uri("https://jitpack.io") }
    }
}
```

2. Next, add the Courier SDK as a dependency in your app-level `build.gradle.kts` file. This includes the SDK in your project, allowing you to use its classes and functions.

```java
dependencies {
    	implementation("com.github.trycourier:courier-android:2.0.2")
}
```

3. Lastly, initialize the SDK. This step grants Courier access to `SharedPreferences`, which is an Android class that allows you to store key-value pairs persistently. In this case, Courier uses SharedPreferences to keep track of the device token and other necessary information to manage push notifications effectively.  

You can do this in your `Application` class. If you’re starting from scratch, create a Kotlin class called `MyApplication` and paste this code in:

```java
package com.example.courierpush

import android.app.Application
import com.courier.android.Courier
import ...

class MyApplication: Application() {
    override fun onCreate() {
        super.onCreate()
        Courier.initialize(this)
    }
}
```

Make sure to use the correct package reference at the top and include any necessary imports. The Courier SDK initialization should occur before using other parts of the SDK.

Also, check that you have the name variable set correctly inside your `AndroidManifest.xml`, like so:

```java
<application
        android:name=".MyApplication"
        android:allowBackup="true"
        ... >
</application>
```

With these steps complete, you’re ready to dive into the world of push notifications with Courier. We’ll now explain the basics and how to configure them in your app.

## Push notification basics with Courier

In the world of Android app development, managing push notifications can be a complex endeavor. Courier’s Android SDK simplifies this process by automating the management of push notification device tokens, tracking user interactions with notifications, and streamlining how your application requests and checks push notification permissions.

For this tutorial, we’ll be using Firebase Cloud Messaging (FCM) as the push notification provider. FCM is a widely adopted platform for push notifications known for its reliability and scalability. To set up FCM with Courier, follow the instructions provided in [Courier’s FCM setup documentation](https://www.courier.com/docs/platform/channels/push/firebase-fcm/). Note that this is separate from the implementation of the Firebase SDK within your application. You must both **set up FCM as a provider** under **Channels** in the Courier dashboard and **implement the SDK into your project** (step 3 from “Setting Up the Development Environment” above). Setting up FCM as a provider establishes the connection between Courier and FCM, while implementing the Firebase SDK allows your app to receive and handle push notifications sent through FCM. 

Once you’ve set up FCM with Courier, you’ll be able to easily send push notifications to your app, customizing their content and appearance as per your requirements. In the next sections, we will delve deeper into how to configure your Android app to receive push notifications via Courier and FCM and demonstrate how to send a test push notification.

## Configuring Courier for push notifications

Configuring your Android app for push notifications using the Courier Android SDK involves two key steps: creating the `CourierService` file and adding the `CourierService` entry to your app’s `AndroidManifest.xml` file.

### Create the CourierService file

Firstly, create a `CourierService` file. This file will extend the `FirebaseMessagingService` and is responsible for handling the received push notifications.

Create a Kotlin class file called `MyCourierService` and paste in the following code:

```java
package com.example.courierpush

import com.courier.android.service.CourierService
import com.courier.android.notifications.presentNotification
import com.google.firebase.messaging.RemoteMessage

class MyCourierService : CourierService() {

   override fun showNotification(message: RemoteMessage) {
       super.showNotification(message)
       // This is where you can customize the notification shown to your users
       // message.presentNotification(...) is used to get started quickly and not for production use.
       message.presentNotification(
           context = this,
           handlingClass = MainActivity::class.java,
           icon = android.R.drawable.ic_dialog_info
       )
   }
}
```

### Update the AndroidManifest.xml file

Next, you need to declare the `CourierService` in your `AndroidManifest.xml` file. This is necessary so that the Android system knows that this service exists and can start it when a new push notification arrives. Here’s an example of what you need to add:

```java
<application>
…
    <service
        android:name=".MyCourierService"
        android:exported="false">
        <intent-filter>
            <action android:name="com.google.firebase.MESSAGING_EVENT" />
        </intent-filter>
    </service>
…
</application>
```

In this code snippet, replace `.MyCourierService` with your `CourierService` file. The intent filter with the action `com.google.firebase.MESSAGING_EVENT` ensures that this service will be started by the system when a new FCM message is received.

(It’s not part of this example, but if you’re interested in how to handle a user’s interaction with a push notification, your main activity or any activity that you want to open from a push notification click should extend `CourierActivity`. This allows Courier to handle notification clicks and track deliveries effectively.)

In the next section, we will dive into sending push notifications and examine the processes of user authentication with Courier and registration for notifications.

## Sending push notifications using the Android SDK

Sending push notifications with Courier involves two main steps:

1. Registering a user’s device with Courier
2. Making a request to the Courier API to send a notification

### Register a user’s device with Courier

After setting up your Android application to receive notifications, the next step is to register your device with Courier. This automatically gets the FCM token from Firebase and then sends it to Courier.

In your application, wherever you want to start registering the device for push notifications (for example, at user login or app start), use the `signIn()` function to connect your user with Courier.

```java
class MyApplication : Application() {
   override fun onCreate() {
       super.onCreate()

       // initialize Courier
       Courier.initialize(this)

       // Sign in to Courier
       CoroutineScope(Dispatchers.Main).launch {
           Courier.shared.signIn(
               accessToken = "<YOUR_AUTH_KEY>",
               clientKey = "nil",
               userId = "<YOUR_USER_ID>"
           )
       }
   }
}
```

This code fetches the FCM registration token and then sends it to Courier. As you’re not using [Courier Inbox](https://www.courier.com/docs/platform/inbox/), you don’t need to set the `clientKey` for this example, and can leave it as `nil`. Replace `<YOUR_AUTH_KEY> `with your [API key](https://app.courier.com/settings/api-keys), and replace `<YOUR_USER_ID>` with your Courier user ID, found in the [users](https://app.courier.com/) area of the Courier app.

This step is simple, but this is where all the magic happens. By signing a user in like this, Courier takes care of all the tricky token management behind the scenes. At this point, everything should be set up and good to go. All you need to do now is send the notification.

### Send a notification

With the device registered, you can now send a notification. This is done via a POST request to the Courier Send API. The Courier Send API allows you to define the content of the notification and specify the recipient(s).

Before sending, perform the following steps: 

1. Make sure you have connected a [physical device](https://developer.android.com/studio/run/device).
2. Ensure developer options are turned on for the device. This will vary for each device, but here is an [example](https://www.samsung.com/uk/support/mobile-devices/how-do-i-turn-on-the-developer-options-menu-on-my-samsung-galaxy-device/) of how to do it.
3. In Android Studio, run your app on your Android device.

![Run Android on your device from Android studio](//images.ctfassets.net/z7iqk1q8njt4/5YbQN61xNEPRltNYR3u1aC/04b01ebf110c54d9c55d02a27d58b266/android-sdk-push-notifications-image1.png)

4. Once you’re running your new app on your device, you may need to go to the settings for the new app and allow notifications.

You can make the POST request using any HTTP client of your choice. Here’s an example using cURL.

```javascript
curl --request POST \
  --url https://api.courier.com/send \
  --header 'Authorization: Bearer YOUR_AUTH_KEY' \
  --header 'Content-Type: application/json' \
  --data '{
    "message": {
        "to": {
            "user_id": "YOUR_USER_ID"
        },
        "content": {
            "title": "Hey there 👋",
            "body": "Have a great day 😁"
        },
        "routing": {
            "method": "all",
            "channels": [
                "firebase-fcm"
            ]
        }
    }
}'
```

In the request above, replace `YOUR_AUTH_KEY` with your Courier auth key and `YOUR_USER_ID` with the ID of the user you want to send the notification to. This will be the same user that you signed in previously, likely your own user ID.

That’s it! Your Android app is now set up to send and receive push notifications using Courier and FCM.

Remember, the actual process of making a request to the Courier API can be handled in many ways, not just through cURL. For instance, you could make this request from a server-side script or from within your mobile app using an HTTP client library. The cURL example above is just a simple demonstration. The best practice is to trigger these requests on the server side and not from the client to ensure your Courier auth key is kept secure. 

You can also use the Courier dashboard to [design a notification](https://www.courier.com/docs/platform/content/notification-designer/notification-designer-overview/), then send that notification. There are various ways to do this, but one way could be via cURL, like so: \

```javascript
curl --request POST \
--url https://api.courier.com/send \
--header 'Authorization: Bearer YOUR_AUTH_KEY' \
--data '{
    "message": {
       "to": {
                "user_id": "YOUR_USER_ID"
            },
      "template": "YOUR_NOTIFICATION_TEMPLATE_ID",
      "data": {}
    }
}'
```

## Advantages of the Courier Android SDK

Having gone through the process of setting up push notifications with Courier, let’s dive deeper into the specific features that make the Courier Android SDK a powerful tool for developers.

### Efficient management of tokens

One of the significant advantages of the Courier Android SDK is its ability to handle tokens effectively. 

Push notification tokens are unique identifiers assigned to each mobile device by push notification services like Firebase Cloud Messaging (FCM) for Android. These tokens are essential for routing push notifications to specific devices, ensuring the right users receive the intended messages.

When not handled automatically, token management can become complex as the user base grows. Manually storing tokens in databases and managing token refreshes can lead to errors and inconsistencies. Additionally, handling tokens separately from other application data can result in data discrepancies and time-consuming development efforts.

The Courier Android SDK addresses these challenges by automatically synchronizing FCM tokens with Courier. This approach saves development time, ensures data consistency, and provides a more robust and error-free system for push notification delivery. With automated token management, developers can focus on other critical aspects of the application while still delivering notifications reliably to users.

### User tracking

Another advantage is the ability to track user status with ease. The SDK can seamlessly track when a user signs in or out, providing you with more insights about your user base. This could help you to tailor your app’s user experience based on user behavior.

```java
// When a user signs in
Courier.identify(userId);

// When a user signs out
Courier.logout();
```

These are just a couple of examples of the benefits of the Courier Android SDK. It’s designed to streamline push notification management, making it easier to focus on what matters: building great app experiences for your users.

## Conclusion

Throughout this article, we have explored the process of setting up and sending push notifications in an Android app using the Courier Android SDK. We also touched on some of the unique features of the SDK that make managing notifications easier and more efficient.

By leveraging Courier, you can send push notifications to your users directly and manage user engagement in a more streamlined manner. Courier can also handle FCM tokens automatically and track user status, giving you more time to focus on the core functionalities of your app.

Remember, this guide provides a basic setup. The Courier Android SDK has much more to offer, including customizing notifications and tailoring them to your app’s specific needs.

Whether you’re looking to improve an existing application or starting a new project, we hope this guide has provided you with a clear understanding of how to implement and optimize push notifications using Courier.

For more detailed information about all the features of the Courier Android SDK, take a look at the Courier Android SDK [GitHub documentation](https://github.com/trycourier/courier-android) or [sign up for Courier](https://app.courier.com/signup). Happy coding!


Mastering Android Push Notifications header

Courier’s Android SDK simplifies the task of sending Android push notifications. This tutorial covers all you need to get it set up and working.

Mastering Android Push Notifications: A Guide Using Courier’s SDK

Mastering Android Push Notifications thumbnail

When you need to send important alerts from your web or mobile app, text messages via SMS can be very useful, especially for time-sensitive notifications, e.g. to quickly warn users about things like possible fraud or payment issues. It can also be helpful to pair SMS notifications with other types of messages, such as email, Slack messages, or push notifications. This allows you to take a more layered approach to your notifications, adding notification logic that considers whether a user has read your earlier SMS attempts before deciding to notify them on these other channels.

While there are excellent SMS APIs like Twilio and MessageBird that let you send an SMS with a few lines of code, these services don't handle all the complexities of an automated SMS that will require an SMS notification system like [Courier](https://www.courier.com/).

You will need to add extra logic around your notifications if you want to:

- Send the message to additional channels like a push notification or in-app message.
- Trigger your notifications based on a schedule, a product event or collection of events.
- Integrate notifications with your Customer Data Platform or Reverse ETL.
- Send a sequence of notifications based on certain conditions
- Accommodate user communication preferences (which channels they want to be notified by, and how often)
- Include data from third party systems in your notifications
- Implement automatic failover between SMS providers, if one goes down. Or between channels if the SMS isn’t read.

Without an SMS notification system to help you manage this work, you’ll be left developing and maintaining all this logic yourself.

This article shows how to use the Courier SMS notification system to easily send basic SMS notifications, as well as how to add automation logic around your notifications and read user preferences to avoid bombarding them with an excess of messages.
<a id="components"></a>
## Components of an SMS notification system

SMS notification systems provide a powerful set of features that extend far beyond SMS delivery. Here are some of the capabilities supported by Courier, which may be useful if you’re building a product requirements document **(or developing against one) for product notifications.

- **Multiple channels:** Offers a wide range of notification channels, such as email, push, Slack, MS Teams and an in-app notification inbox.
- **User preferences:** Your users can decide how often and by which channels (e.g. SMS, email, Slack etc.) they wish to be communicated with, and Courier will automatically honor these preferences.
- **Integration with other software:** Has deep integrations with adjacent systems in your stack (like Customer Data Platforms, for example).
- **Delivery tracking and retry mechanisms**: Ensures reliable message delivery.
- **Monitoring and logging:** Provide comprehensive monitoring and logging for debugging delivery issues, in a way that looks at SMS in the context of other channels.
- **Delivery options**: Gives you the flexibility to trigger messages in a way that aligns with your use case: including api-driven, event-driven, or one-time send.
- **Cross channel synching:** Sync delivery status across channels, so when a user opens an email, the related inbox message can automatically be marked as read.
- **Channel/provider failover:** Easily failover between SMS providers (e.g. from Twilio to MessageBird) or between channels (e.g. from SMS to Email or Slack) if a notification has failed.
- **Testing capabilities:** Provides easy ways for you to test that your notifications have been sent properly.
- **Integration with your coding language**: Offers SDKs for most languages. It’s easy to integrate Courier with both front-end and back-end code for web, as well as mobile application code for Android and iOS.
- **Scalability**: Can handle increased message volume as your application grows.
- **Advanced send logic**: Features such as [throttling](https://www.courier.com/docs/platform/automations/throttle/) and [send limits](https://www.courier.com/blog/notification-send-rate-limits/) to prevent overrun of messages that have both cost and user experience implications.
- **Internationalization:** Allows you to automatically select different message templates and timing restrictions for different regions.
- **Template design and management** - can you design and manage templates for all your notifications in one place?

<a id="sendsms"></a>
## Send with SMS using an SMS notification system

In this example, we will use Courier, with Twilio as the SMS provider. We’ll build automated SMS notifications into a Node.js application. Although we are using Node.js, there are a number of [quick start guides for other languages](https://www.courier.com/docs/guides/getting-started/python/) available.

<a id="setup_twilio"></a>

### Step 1: Set up Twilio
Twilio offers a free trial with no credit card required, so we will use Twilio as our example SMS service provider. Start by [signing up to Twilio](https://www.twilio.com/try-twilio). Once you have signed up, you will be directed to the [Twilio console](https://console.twilio.com/), where there is a basic tutorial for creating a new phone number for your Twilio messages. Once you have done this, continue with the tutorial and run the command to send yourself a test SMS, just to check that Twilio is working correctly.

Next, scroll down the Twilio console homepage to find your Twilio account SID, auth token, and phone number — which you will need to use Twilio with Courier.

![Screenshot of the Twilio SMS notification system showing how to find the account SID, auth token, and phone number.](//images.ctfassets.net/z7iqk1q8njt4/6B3wKIpXvq6JsYCDwTpXxd/fb9c1376fe58642bd2717936501f3c48/sms-notification-system-1.png)

<a id="integrate_twilio"></a>
### Step 2: Integrate Twilio with Courier using the web UI

[Sign up to Courier](https://app.courier.com/signup) and add Twilio as a [channel](https://app.courier.com/), by selecting **Twilio** under **configured providers**. Now, enter your Twilio account SID, auth token, and phone number that you previously found in the Twilio console, and click the **Save** button.

![Screenshot showing how to input the Twilio details into Courier.](//images.ctfassets.net/z7iqk1q8njt4/7ccZq0SqHMOn8YkVHxwEbh/c21716d69df27adc59e32cf00f88042c/sms-notification-system-2.png)

<a id="create_template"></a>
### Step 3: Create your SMS notification template

We will be using an e-commerce package delivery notification for our example. Navigate to **Designer → [Create Template](https://app.courier.com/designer/notifications)** and name your template “Package delivery*.*” You will now be prompted to say which channel you want to use for sending your message. Select **SMS** and select **Twilio** as your SMS provider in the drop-down box.

Next, click on **SMS** under **Channels** to begin writing your notification for the SMS channel. Either use the AI-powered content generator or enter this text into the notification designer:

`“Your package with reference {packageRef} is estimated for delivery between {startTimeHours}: {startTimeMins} and {endTimeHours}:{endTimeMins} today. Not going to be in? {rescheduleOrSafePlaceUrl}” and then click “Publish changes”.`

![How to create an SMS notification template in Courier.](//images.ctfassets.net/z7iqk1q8njt4/1pdDHqtHoDRXCW1vOeBbyZ/2a1bf9241521ecfde358ef6b540df012/sms-notification-system-3.gif)

<a id="install_node"></a>
### Step 4: Install the Courier Node.js SDK

- Create a directory for your Node code called package-notification and enter this directory.
- Make sure you have the [latest version of Node.js](https://nodejs.org/en/download/) and [npm](https://www.npmjs.com/package/npm) installed.
- Install the [Courier Node.js SDK](https://www.npmjs.com/package/@trycourier/courier) package via npm:

<a id="send_sms"></a>
### Step 5: Send SMS using Node.js

Now you are going to write some code that will send an SMS notification to your phone from your Node.js code, using Courier (with Twilio as the SMS provider).

Inside your package-notification directory, create a file called package.js and add the following code:

```javascript
const { CourierClient } = require("@trycourier/courier");
const courier = CourierClient({ authorizationToken: "<AUTH_TOKEN>" });

const packageRef = "<PACKAGE_REFERENCE>";
const startTimeHours = "<START_TIME_HOURS>";
const startTimeMins = "<START_TIME_MINS>";
const endTimeHours = "<END_TIME_HOURS>";
const endTimeMins = "<END_TIME_MINS>";
const rescheduleOrSafePlaceUrl = "<RESCHEDULE_OR_SAFE_PLACE_URL>";

const { requestId } = courier.send({
  message: {
	to: {
  	data: {
    	    packageRef : packageRef,
          startTimeHours : startTimeHours,
          startTimeMins : startTimeMins,
          endTimeHours : endTimeHours,
          endTimeMins : endTimeMins,
          rescheduleOrSafePlaceUrl : rescheduleOrSafePlaceUrl
  	},
  	phone_number: "<PHONE_NUMBER>",
	},
	template: "<NOTIFICATION_TEMPLATE_ID>",
	routing: {
  	    method: "single",
  	    channels: ["sms"],
	},
  },
});
```

- Replace all the template variables like `packageRef` with your own values. Note: the time-based variables such as `startTimeHours` should each contain two digits, as they use military time.
- Replace `<AUTH_TOKEN>` with your  [Courier API key](https://app.courier.com/settings/api-keys).
- Replace `<PHONE_NUMBER>` with your own phone number, so you can test that the SMS sends correctly.
- Replace `<NOTIFICATION_TEMPLATE_ID>` with the ID of the template you just created. This can be found by going to your template in the Courier app and navigating to the notification settings:

![Using Node.js code to send an SMS notification in Courier.](//images.ctfassets.net/z7iqk1q8njt4/2JSccoAPnLf2eQBIVvxa6u/97816c2b6a8d476c2b58200ac64f28ef/sms-notification-system-4.gif)

When you run your code, it will send an SMS:

![An example SMS about an expected package delivery.](//images.ctfassets.net/z7iqk1q8njt4/3pAxNikoC3r5MXdjvKhx5B/547cfbc804c5d9030f5c34e445884621/sms-notification-system-5.png)

As you can see, it’s pretty simple to send an SMS using Courier. It's worth noting that Courier offers multiple notification channels — so you can use the same notification platform for communicating via email, Slack, MS Teams, push notifications, and more. For example, the user may have wanted this parcel notification as both a mobile push notification and an SMS.

<a id="logic"></a>
## Using Courier automations to simplify complex SMS logic

Courier automations allows you to abstract complex SMS (or multi-channel) notification workflows into a no-code designer in the Courier web UI, which can then be invoked via Courier’s [Automations API](https://www.courier.com/docs/reference/automation/). Workflows are easily created as templates via drag-and-drop components. These templates contain all the logic needed for a notification sequence. It consists of a trigger and a number of actions. Once you’ve created the template, you can later run an automation from it.

Some examples of automation templates that can be created in the automation designer include:

- Send an SMS on a time-based schedule — for example, send an SMS 10 days before Black Friday to notify customers of an impending sale.
- Send an SMS that is triggered by an event in your customer data platform (Courier accepts Segment and RudderStack events as triggers, meaning you don’t need to integrate their APIs into your code).
- Branching logic: sending one SMS if one condition is met, and a different one if it’s not — for example, if a new user signs up to a gym, they could be sent different workout suggestions based on age.
- Applying throttles to your SMS messages to avoid notification fatigue — if an automation template involves sending multiple notifications, a throttle can be added to place a limit on the number of SMS messages that can be sent.

In this tutorial, we will create an automation template that causes an order confirmation SMS to be sent when an [“order completed”](https://segment.com/docs/connections/spec/ecommerce/v2/#order-completed) event occurs in [Segment](https://segment.com/), the Customer Data Platform from Twilio. We will use Courier’s [Segment integration](https://www.courier.com/blog/smarter-customer-engagement-flows-segment-integration/) to achieve this.

<a id="create_template"></a>
### Step 1: Create a notification template in Courier

Navigate to [Designer](https://app.courier.com/designer/notifications) and click **Create Template**. Name your template “Order confirmation.”  Select **SMS** as the notification channel and choose Twilio as a provider from the drop-down box.

Now, click the **SMS** channel on the left to add your message content to your template. Add the following text to the notification designer, then click **Publish changes**.

`“Your recent order of {productName} (#{orderNumber}) has been completed. We hope you enjoyed your purchase and thank you for shopping with us.”`

<a id="create_automation"></a>
### Step 2: Create your automation in Courier

Navigate to the [automations designer](https://app.courier.com/automations) and click **New Automation**. Rename your automation from “Untitled Automation” to “Order Confirmation.”

![Creating an automation in Courier.](//images.ctfassets.net/z7iqk1q8njt4/3DCKGMGnCKbojBn0lY7TAm/d85efae462f09daaa8a6a02e530e4f8c/sms-notification-system-6.gif)

Start with a trigger for your automation. For this example, we will choose a Segment event as the trigger. Drag the Segment trigger onto the automation designer canvas. You will need to select a particular Segment event within this. In this example, we will use an e-commerce Segment event called “[order completed](https://segment.com/docs/connections/spec/ecommerce/v2/#order-completed).”

Next, add a **Send** action to your automation and fill in the following information in this node:

- **“To” field:** Enter `refs.data.user_id` as the user.
- **Select a template:** Choose your **Order confirmation** template from the drop-down box.

![Adding a Send action to the automation in Courier.](//images.ctfassets.net/z7iqk1q8njt4/4NDyUrKEff4dgbsqfju4Gs/7310b9560d6a11991a0ac0fa4e024a74/sms-notification-system-7.png)

To [use Segment dynamic data](https://www.courier.com/docs/automations/dynamic/) in the variables of your notification template, click on **Advanced** in the **Send** node, and enter the following in the **data** field:

`{`
`"productName": "data.products.name"`
`---`

![Adding Segment dynamic data to the automation in Courier.](//images.ctfassets.net/z7iqk1q8njt4/52OAlxa4TIKxRAN43CeBJR/4e263a41a1176ec8c98cd17ff4b72213/sms-notification-system-8.gif)

Finally, click **Publish changes**.

When an order gets marked as completed in Segment, this will invoke the automation, and cause your SMS to be sent. You can also test your automation template by invoking it yourself: click the **Invoke** button at the top of your automation template to find a cURL command that you can run to check your automation is working properly.

<a id="conclusion"></a>
## Conclusion

We have covered why you need an SMS notification system and how to automatically trigger an SMS using Courier with Twilio.

You can get started immediately using Courier’s free tier and Twilio’s free trial. Courier allows you to [integrate with many of the big SMS notification providers](https://www.courier.com/integrations/), which means that you don’t have to decide right away which provider to use. If you’ve been working along with this coding example and have decided you want to use Courier to send more notifications, you can [sign up today](https://app.courier.com/signup) or [contact us](https://www.courier.com/request-demo/) to discuss your specific use case.

Courier is a notification service that centralizes all of your templates and messaging channels in one place which increases visibility and reduces engineering time. 

Start Routing Notifications Today!

sms notification system header

This article explains why you need an automated SMS notification system, with an example using Courier to send an automated SMS with Twilio.

How to Create an Automated SMS Notification System

sms notification system thumbnail

Push Notifications vs In-App Messages Header-min

Learn the key differences between push notifications & in-app messages, when to use each, and how to implement across web, iOS, & Android apps using Courier.

Push Notifications vs In-App Messages | Differences, Use Cases & Guide

Push Notifications vs In-App Messages Thumb-min

Build your first notification in minutes

Build your first notification in minutes

Platform

Use Cases

Explore

Company