Engineering

Inbox SDKs for Vue and Angular: a native in-app notification center

Courier now ships first-class inbox SDKs for Angular and Vue. Drop in a real-time notification center, toasts, and a preferences center with native components, an injectable service, and a composable, all backed by the same in-app inbox that already powers React and JavaScript apps.

Human-in-the-loop for AI payment agents: building approval notifications that work

AI agents need human approval before taking consequential actions: financial commitments, irreversible changes, decisions that affect other people. This post covers how to design those checkpoints and build the notification infrastructure: multi-channel delivery, live context, escalation, and a back-and-forth question loop between reviewers and the agent.

Create a customer journey from AI coding agent

Use Courier's Journey API to create multistep customer engagement workflows from your coding agent of choice. Describe the kind of journey you'd like to create, answer a few questions, and publish to the platform.

CocoaPods end of life: here's what to do

CocoaPods has been the default iOS dependency manager for more than a decade. On December 2, 2026, its central registry becomes read-only. Here's what that actually means for native iOS, React Native, and Flutter apps.

Firebase CocoaPods support is ending. What happens to iOS push notifications?

Firebase is ending new Apple SDK releases to CocoaPods in October 2026. Your app will not break overnight, but your Firebase push notification stack can get stuck on old SDKs while APNs, iOS, Xcode, and Firebase keep changing.

Custom Environments: Ship Customer Messaging like you Ship Code

Courier workspaces now support custom environments. Each is fully isolated with its own templates, integrations, and logs. Match your messaging workflow to how you ship code.

Fonts in email: what works, what breaks, and how to fix it

Email clients don't agree on fonts. Gmail strips your custom typeface, Outlook sometimes defaults to Times New Roman, and Apple Mail handles web fonts fine. This guide covers what the industry actually does: fallback-first font stacks, progressive enhancement, readability standards, and a pre-send QA workflow

Debug Delivery Issues in Your AI Editor with MCP

Between quarterly audits, delivery issues don’t wait. When emails fail or alerts fire, you need answers fast. Courier’s MCP server lets you debug notifications conversationally—find the message, trace its timeline, and inspect user data in minutes. Instead of jumping between dashboards, your AI agent pulls everything on demand, surfaces root causes, and even automates investigations. The result: faster fixes, less guesswork, and a smarter, always-on reliability workflow.

Design Studio + Journeys: The Engineering Integration Guide

This is the engineering guide for setting up Design Studio and Journeys. When you move notification logic to Courier, your architecture shifts from a push model to an event model. Your backend stops rendering templates and managing provider APIs directly, and starts emitting events. This guide covers both integration paths (direct API and Segment), how to structure the data object so PMs can build without asking for backend changes, error handling and idempotency, how to use test environments safely, and the specific code you can delete from your repo once it's running.

Courier MCP: Let your AI agent handle customer messaging end to end

The Courier MCP server lets your AI agent send notifications, manage users, debug delivery, and trigger automations. If you can do it in Courier, your agent can too.

iOS 27 UISceneDelegate push notification deadline: What breaks and how to prepare

Apple is making UISceneDelegate mandatory with the iOS 27 SDK, expected September 2026. Apps that don't adopt the scene lifecycle will crash on launch, killing APNs token registration and all push notification delivery. This guide covers the full timeline, cross-platform impact for Flutter and React Native, and a practical action plan.

Your AI agent already knows how to use a terminal. Why CLIs beat MCP servers

LLMs already know how to use a terminal. We maintain both an MCP server and a CLI at Courier, and the difference tells you something about where AI tooling is heading.

EU Data Residency for Notifications: What Engineering Teams Need to Know

Courier supports EU data residency through a dedicated datacenter in AWS EU-West-1 (Ireland), with full API feature parity, same-workspace dual-region access, built-in GDPR deletion endpoints, and localization support for multilingual notifications. Engineering teams can switch to EU hosting by changing a single base URL with no workspace migration or downtime required.

Expo Push Notifications: The Complete Implementation Guide (SDK 52+)

Expo push notifications are alerts sent from a server to a user's phone, even when the app isn't open. To set them up, install the expo-notifications library, ask the user for permission, and get a unique push token for their device. Your server sends a message to Expo's push service with that token, and Expo delivers it through Apple or Google. Push notifications only work on real phones, not simulators. Local notifications are different — they're scheduled by the app itself for things like reminders. You can also route Expo push through services like Courier to add email, SMS, and Slack fallbacks.

Best Email API Providers for Developers in 2026: SendGrid vs Postmark vs Mailgun vs SES vs Resend

Your email provider sticks with you longer than most technical decisions. Courier handles notification infrastructure for thousands of teams, so we went deep on the six email providers that show up most: SendGrid, Postmark, Mailgun, Amazon SES, Resend, and SMTP. This guide covers real API primitives, actual code from each provider's docs, Courier integration examples with provider overrides, and an honest read on where each developer experience holds up and where it breaks down. We also asked Claude to review every API and tell us which one it would wire up first. The answer surprised us.

The Courier MCP Server Is Open Source. Here's How It Actually Works.

Courier's MCP server is open source at github.com/trycourier/courier-mcp. It connects AI coding tools like Cursor and Claude Code to your Courier account so they can send messages, manage users, and install SDKs without hallucinating API details. This post walks through the actual codebase: how 16 tool classes are registered (and how a config allowlist gates most of them), why we pull installation guides from GitHub at runtime instead of bundling them, how the DocsTools class generates live JWTs alongside setup instructions, and what the SdkContextTools class does in the repo to prevent v7/v8 SDK conflicts (even though it isn't wired into the server yet).

Cross-Channel Notification State: Why Read Receipts Are Harder Than They Look

When a user opens your email, does your app know? For most products, the answer is no. Each channel tracks its own state. Email has read receipts. Push has delivery confirmation. In-app has its own unread count. They don't talk to each other. Users notice. This guide covers the three approaches to notification state management (channel-first, central-first, event-first), when to use each, and how to implement cross-channel sync without overengineering. Includes state diagrams and practical implementation patterns.

Terminal-First Development vs. IDE: Building Notification Infrastructure with Claude Code and Cursor

AI coding tools split into two camps: terminal agents (Claude Code) and IDE-augmented editors (Cursor). This guide compares both approaches using Courier's CLI and MCP server as the test case. Covers installation, configuration, and practical workflows for building multi-channel notifications. Includes code examples for user management, bulk operations, and automation triggers. Also explores agent-to-agent communication patterns where AI systems need notification infrastructure to coordinate tasks and escalate to humans.

The Notification Platform Developers Choose

Most notification platforms built dashboards first and added developer tools later. Courier did the opposite. With a CLI that handles real workflows, MCP integration with setup management, typed SDKs in seven languages, and SOC 2 Type 2 certification, Courier is built for teams that ship. This isn't marketing copy: Twilio chose Courier to unify notifications across their 10M+ developer platform. LaunchDarkly uses Courier to power feature release workflows. When the companies that build developer infrastructure choose your notification platform, that says something about the technical foundation.

Vibe Coding Notifications: How to Use Courier with Cursor or Claude Code

Courier's MCP server lets AI coding tools like Cursor and Claude Code interact directly with your notification infrastructure. Unlike Knock and Novu's MCP servers that focus on API operations, Courier's includes embedded installation guides for Node, Python, Flutter, React, and other platforms. When you prompt "add Courier to my app," your AI assistant pulls accurate setup instructions rather than relying on outdated training data. OneSignal's MCP is community-maintained, not official. Courier supports 50+ providers, native Slack/Teams integration, drop-in inbox and preference components, and a free tier of 10,000 notifications/month. Configure in Cursor with "url": "https://mcp.courier.com" and "headers": { "api_key": "YOUR_KEY" }.

How Top Notification Platforms Handle Quiet Hours & Delivery Windows in 2026

No platform offers per-template delivery windows in 2026—it's either per-workflow (Customer.io, Knock), per-campaign (Braze), or global settings. This comparison shows exactly how six platforms handle quiet hours and send time controls based on their documentation and API specs. Braze leads on AI timing (23% open rate lift from Intelligent Timing across their customer base). Novu is the only platform letting subscribers set their own delivery windows. Customer.io and Knock require manual workflow configuration. OneSignal's strength is push-specific optimization across 300K+ apps. Courier combines per-node flexibility with API control. Includes feature matrix, timezone handling, and frequency capping differences.

Notification Observability: How to Monitor Delivery, Engagement, and Provider Health

Notification observability is the practice of monitoring notification delivery, engagement, and provider health using the same tools and discipline you apply to the rest of your application infrastructure. It means tracking whether messages are delivered, opened, and acted on across email, SMS, push, and in-app channels, then surfacing that data in dashboards alongside your other application metrics. Key metrics include delivery rate by channel, bounce and failure rates, provider latency, open rate trends, and click-through rates by template. Teams can build notification observability through DIY webhook handlers that pipe provider events to Datadog or Prometheus, log aggregation from application send logs, or notification platforms with built-in observability integrations. This matters most for multi-channel systems, business-critical notifications like password resets and payment confirmations, and teams using multiple providers with fallback routing.

SMS Opt-Out Rules in 2026

TCPA consent rules changed in April 2025. Consumers can now revoke consent using any reasonable method, including keywords like "stop," "quit," "end," "revoke," "opt out," "cancel," or "unsubscribe." Businesses must honor opt-out requests within 10 business days, down from 30. The controversial "revoke all" provision, which would require opt-outs to apply across all automated messaging channels, has been delayed until January 2027 and may be eliminated entirely. SMS providers like Twilio handle delivery infrastructure and STOP keyword responses at the number level. They don't sync opt-outs to your email provider, push notification service, or in-app messaging. That cross-channel gap is your responsibility. Courier provides unified preference management that enforces user choices across SMS, email, push, and chat automatically.

Top 8 Transactional Email Solutions for Developers in 2026

Transactional emails are the messages your users are waiting for: password resets, order confirmations, shipping updates, and two-factor codes. Unlike marketing emails, they're triggered by user actions and need to arrive fast. With Gmail, Yahoo, and Microsoft now enforcing strict authentication requirements (DMARC, SPF, DKIM), choosing the right transactional email provider matters more than ever. Non-compliant emails face permanent rejection. This guide compares 8 solutions for 2026: Courier for multi-channel orchestration across email, SMS, push, and Slack. SendGrid for scale and analytics. Postmark for speed (under 2 seconds average delivery). Resend for React/Next.js teams. Amazon SES for cost-conscious AWS shops. Plus Mailgun, Mailtrap, and SMTP2GO. We cover pricing, deliverability, developer experience, and when each provider makes sense. If you're building a product where notifications will eventually span multiple channels, start with Courier. If you genuinely only need email, we break down the tradeoffs.

React Native Push Notifications: FCM, Expo, and Production-Ready

React Native lets you ship to iOS and Android from one codebase, but push notifications still require platform-specific infrastructure. This guide covers implementing push with Firebase Cloud Messaging (FCM) for bare React Native and Expo Push for managed workflows. Both get basic push working, but production apps quickly hit limitations: no delivery confirmation, no fallback channels, no user preferences, and debugging is guesswork. Learn why teams add a notification orchestration layer to handle token lifecycle, multi-channel coordination, user preferences, and delivery observability. Includes code examples for authentication, in-app inbox components, preference centers, and multi-channel routing with automatic fallbacks.

Flutter Notifications: Add In-App Inbox and Push in 10 Lines of Code

Flutter 3.38 is production-ready, but most teams still waste weeks building notification infrastructure. FCM setup, token management, inbox UI, preference centers, cross-channel state sync. Skip all of it. Add a complete notification system in 10 lines: real-time inbox, push for iOS/Android, digest batching, GDPR preferences. When users open an email, inbox messages auto-mark as read. Courier handles FCM/APNs tokens, WebSocket reconnection, and compliance. Same infrastructure Twilio uses for 10M+ developers.

How We Investigate Support Tickets at Courier

Courier's support team resolves complex issues 4X faster using parallel investigation. Here's how it works: when a ticket comes in, an AI agent starts exploring the codebase while the support engineer examines actual customer data. The agent traces code paths and searches past investigations. The human reads event logs and forms hypotheses based on real state. Running both simultaneously catches mismatches fast—the agent sees what could cause a problem, the human sees what actually happened. This post breaks down the workflow, tools, and documentation structure that makes it repeatable.

How to Use WhatsApp Typing Indicators on Twilio (Public Beta Guide)

Twilio now supports typing indicators for WhatsApp. When your backend takes a few seconds to generate a response, you can show users that something's happening instead of leaving them staring at a silent chat. The indicator appears when you call the new /v2/Indicators/Typing endpoint, automatically marks the message as read, and disappears after your response arrives or 25 seconds pass. This guide covers the API details, implementation patterns for Node.js and Python, when to use typing indicators, and current beta limitations.

Nodemailer Alternative: Outgrowing DIY Email Infrastructure

Nodemailer works great for transactional email in early-stage products. But B2B customer journeys demand more: Slack notifications for engineering teams, Microsoft Teams messages for enterprise customers, in-app notification centers, SMS escalations, and push alerts. Building this yourself means maintaining integrations with SendGrid, Twilio, Firebase, Slack's API, and Microsoft Graph. Courier provides omnichannel notification infrastructure through one API, handling routing, preferences, delivery, and analytics across every channel.

How to migrate AppDelegate to UISceneDelegate (iOS 26 Requirement)

Apple is enforcing the UIScene lifecycle in iOS 27 — and it directly affects push notifications. In iOS 26, simulators began warning about missing scene support. Here’s what’s changing, what errors to expect, and how to update your app to keep push notifications working.

What is the Twilio Messaging API?

Twilio's Messaging API enables developers to send and receive SMS, MMS, WhatsApp, and RCS messages at scale across 180+ countries. While Twilio excels at reliable message delivery through carrier networks, modern applications need more than single-channel messaging. Courier acts as a provider-agnostic orchestration layer that activates messaging across Twilio and other channels from a single platform. You get intelligent routing, user preference management, and fallback logic without vendor lock-in.

What Most People Get Wrong About Push Notification Metrics

Push notification analytics have evolved beyond traditional engagement metrics, yet many teams still rely on outdated measurement approaches that obscure real business value. The challenge lies in applying email marketing metrics to push notifications without considering fundamental differences in user behavior and platform constraints. A notification that never gets "opened" might still drive a purchase decision or prevent user churn.

How to Embed a Template Designer into Your React Application

Multi-tenant SaaS platforms struggle with giving customers template design control without compromising security. Courier Create solves this with an embeddable React component that provides drag-and-drop editing, variable substitution, and brand customization while maintaining tenant isolation. Learn how companies like Side and Hipages benefit from customer-controlled templates, plus get setup code examples for React 18.2+ integration.

Video Guide: Courier MCP + AI Coding (Cursor)

Building notifications into your app just got dramatically easier. Courier's new MCP server brings AI-powered notification assistance directly to your IDE, so you can integrate, test, and manage notifications without ever leaving your workspace. Model Context Protocol servers give AI agents deterministic functionality instead of guessing. Connect your AI assistant directly to Courier's platform, get smart installation guidance, send messages with natural language, and manage users safely—all through Cursor, Claude Code, VS Code, and more.

Best Push Notification Services: A Complete Comparison

Push notifications are critical for modern user engagement. In this guide, we compare the best push notification platforms, from legacy tools like Airship and Firebase to modern APIs like Courier, covering features, pricing, and developer experience.

Why You Need Multi-Tenant Infrastructure for Notifications

Need to send notifications for many customers without mixing data or losing brand identity? This practical guide walks you through mapping a tenant hierarchy, carrying context in every call, setting up layered preferences, and adding dynamic branding. It pairs code samples with checklists so you can choose to build from scratch or plug in Courier when you are ready to scale

How to Send an SMS in Java

Send an SMS in Java using the Courier SDK with your existing Twilio account as the provider. Complete working code, step-by-step setup, and a direct Twilio comparison for when the orchestration layer is overkill.

Why ByteDance Built Lynx? Because React Native Left a Gap

ByteDance didn’t adopt React Native or Flutter. Instead, they built their own mobile framework: Lynx. With native rendering, support for multiple JavaScript frameworks, and a focus on performance, Lynx reflects a broader shift in how modern teams approach cross-platform development. In this post, we look at why it was built, what problems it solves, and whether it’s a sign of what’s coming next.

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

Lynx, React Native, and Flutter each offer a unique approach to cross-platform development in 2025. Lynx brings a web-native workflow with full CSS support, React Native thrives on its vast ecosystem and React compatibility, while Flutter delivers consistent UIs with high-performance rendering. This breakdown explores their strengths, technical differences, and which framework suits your next project.

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

Firebase Dynamic Links will be discontinued by August 25, 2025, impacting push notifications, SMS, and email deep linking. Discover the best alternatives, from App Links and Universal Links to third-party services and custom solutions.

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

Mobile development has come a long way—from the challenges of native apps to the rise of cross-platform tools like React Native and Flutter. Now, AI is driving a new wave of innovation, making app creation faster, smarter, and more accessible than ever. Explore the journey and see what’s next for developers.

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

Apple is updating its Push Notification Service (APNs) certificates in 2025. Learn how to prepare your app for these changes, ensure uninterrupted notifications, and get expert tips for a smooth transition.

Simplifying notifications with the Courier iOS SDK

Push notifications are a valuable tool for keeping users informed and increasing their engagement with your app. You can use push notifications to alert users about promotions, new content, or any other important updates. While push notifications are a powerful tool, setting up push notifications in iOS can be a daunting task that requires a significant amount of effort and time. Fortunately, the Courier iOS Mobile Notifications Software Development Kit (SDK) simplifies this process.

Develop a Motivational QOTD with Courier and GPT2

Courier and OpenGPT2 in action: build a service that sends friends and family an AI generated motivational quote of the day.

How to Send Invoice and Add Payment Reminder in Next.js with Courier API

Learn how to build an invoice management system with Next.js and Courier.

Building a Great UX Outside of your App

This article argues that there’s a more important user experience than the one inside your app.

Build a WebAssembly Language for Fun and Profit: Code Generation

The final phase of our compiler is code generation. This phase takes the AST and converts it to a set of executable instructions. In our case, WebAssembly.

Build a WebAssembly Language for Fun and Profit: Parsing

In this post, we’ll cover the next phase of our compiler, parsing. Parsing is the portion of our compiler that takes the token stream generated by the lexer and converts it into an AST.

Build a WebAssembly Language for Fun and Profit: Lexing

I decided to create this guide and provide a simple overview designed to help get your feet wet in building languages and exploring the inner workings of WebAssembly (wasm).

Building a Slack Integration for Your SaaS Notification System

Many organizations don’t quite know what to expect when building an integration for sending messages from their SaaS product to a Slack channel or a direct message.

Common Courier Troubleshooting Solutions for Developers

In this post, we will discuss example issues around Courier’s Gmail integration and API rate limits, an incomplete data profile, and an incomplete request with Inbox and Toast, and how to fix them.

How We Became HIPAA Compliant

Today, we are excited to announce that Courier is now HIPAA compliant and this post will get into why SaaS companies should be HIPAA compliant, why this is important for our company, and the steps we took to get here.

How Cloud Providers Support SaaS Compliance and Security: What Developers Need to Know

Public cloud providers simplify security and compliance for SaaS developers—but they don’t solve everything. Learn how services like AWS, Azure, and GCP support SOC 2 and ISO 27001 readiness, and how to avoid common cost and audit pitfalls. Includes practical guidance on audit logs, approval workflows, compliance tools, and more.

How to Get GDPR and Customer Communications Right

If you are considering sending notifications to the users of your SaaS application, whether via email, push, or a Slack bot, you need to keep GDPR in mind when building your service.

The Developer's Guide to SaaS Compliance

In this article, we will review what kinds of compliance certifications and regulations exist for SaaS applications, what these certifications mean for developers, and how to begin the certification process for compliance standards.

How to Build Security for your SaaS User Communications

In this article, we cover why you should look closely at how secure your customer communications are and implement strict security measures for emails, push notifications, and other communications you send to your users.

How to Build Approval Workflows with Slack and Node.js

In this article, we’ll explore the difference between manual and automated approval workflows and what you’ll need to know if you decide to automate your workflow.

DynamoDB Partition Key Strategies for SaaS

When using Amazon DynamoDB for a multi tenant solution, you need to know how to effectively partition the tenant data in order to prevent performance bottlenecks as the application scales.

How to Internationalize Your App’s Product Notifications

In this article, you’ll learn about the scope of internationalization and the tools that are available to build software with internationalization logic. You’ll also see how our own internationalization workflow is designed and our suggestions for how to do it yourself.

Hacking PostgreSQL Internals to Deliver Push Notifications

In this post, we will start diving into the internals of Postgres to understand how replication works and data integrity is ensured using WAL (Write-Ahead Logging). We will then steer towards interesting concepts like logical decoding and output plugins. Finally, we will start hacking some code to write our own plugin that can send push notifications!

The Developer's Guide to Building Notification Systems: Observability and Analytics

In the bigger picture, observability ties your technological infrastructure to your overarching product and business objectives. These key insights will also help to scale the product and manage data as your business grows.

How to Improve or Rebuild a Product Notification System: Video

This video will really give you enough to get started thinking about what improvements you might want to make to your notification infrastructure or what notifications you want to send that you’re not sending today and how you should think about building and maintaining those systems moving forward.

The Developer's Guide to Building Notification Systems: Routing and Preferences

In this article, you’ll learn invaluable points to consider when building your own routing service. You’ll understand the requirements for multi-channel support and in choosing the right API providers. You’ll also learn how to design user preferences so that you can make the most out of each message.

The Developer's Guide to Building Notification Systems: Scalability and Reliability

For a company to grow, it will eventually need to decide between the cost of building and maintaining its own system, or opting for the functionality and proven reliability of a third-party product. In this guide, we cover building a scalable and reliable notification system in detail to give you an idea of the required effort of building yourself.

The Developer's Guide to Building Notification Systems: User Requirements

So your CTO has just handed you a project to revamp or build your product’s notification system. It seems like an interesting project before you realize you really don’t know how to go about this and you can’t even find comprehensive resources online to help.

APIs Are The Prefabrication Of Software

The evolution of software development has followed a similar trajectory, with APIs serving as the prefabricated software that companies are leaning on to build software faster and more cheaply than ever before.

How to Set Up Multi-Channel Notifications in Your AWS Stack

In this article, we’ll walk through an example architecture for building your own notification service with AWS, and show you how to implement it in Node.js. We’ll also discuss a few considerations related to using AWS services for notifications.

How I used Unity and Courier to Create a Notification-based Game

I got featured in Courier’s live stream to build a notification-based game with Unity Engine, Courier, Twilio, and Mailjet. In this article, I will walk through the design of this game, called Rain Spikes, and provide a step-by-step explanation of how I used Courier to integrate notifications into the game.

Nodemailer and the SaaS Paradox of Choice

In this blog post, we start by diving into Nodemailer, a module that helps send emails from your Node.js backend, and then we steer our way into writing a transport layer plugin that can help you switch downstream email service providers purely by configuration instead of tedious and sometimes massive code changes.

Why You Can't Replace REST with GraphQL

The question isn’t necessarily which one is better to use, but which one is better to use for specific circumstances. The best way to evaluate GraphQL, REST, or any other technology is to figure out your constraints based on the problem you are going to solve.

How to Add a Notification System to your MVP

At the MVP stage, developers focus on finding product-market fit for their venture. On the one hand, this means experimenting with functionality that’s capable of creating value. On the other hand, teams at this phase start requiring less and less time on every new experiment, before finding something that works. In this article, we show you how to build a notification system for your MVP, in a way that both enables experimentation and helps you get results quickly.

How We Built React Components for Any Front End

To make sure teams don’t need to build an in-house solution for a notification systems problem, we adapted our offering. We created a lightweight solution using React that has a global state and runs independently in the background, so teams can render our components regardless of their tech stack.

Who Knew Email Subjects Are So Complicated?

Here is our journey into email subjects upon finding out that Microsoft Outlook didn’t work with certain characters in our email subjects. Through the process, we were able to build a solution that works for multiple providers. 

The Three Things to Never Build In Your App: Authentication, Notifications, and Payments

In this post, we use Auth0’s post-user registration hook and Courier’s automations feature to learn how to help a user sign up for your product.

Follow These Considerations For An Effective Push Notification System Design

Push notifications are generally an effective mechanism for user engagement, but it's no longer enough to simple just *have* push notifications. Given increased user scrutiny and competitiveness for attention, notification system design is more important than over. We offer some guidelines on how to design effective push notifications.

Notification Strategy for Web and Mobile Apps: Design, Channels, Best Practices

Designing effective notifications isn’t just about delivery—it’s about timing, personalization, and user experience. In this guide, we’ll walk through how to build a scalable, multi-channel notification system that keeps your users informed, engaged, and in control.

Build vs. Buy: What’s better for a transactional email notification service?

Comparing the advantages and disadvantages of building your own notification system for transactional emails vs. buying a product.

Three Ways to Send Emails Using Python With Code Tutorials

Learn how to send an email in your Python application with SMTP, with a transactional email API, and with a multi-channel notification service.

How to Send Emails in Node.js: SMTP, Email APIs, and Notification Services (With Code Tutorials)

Learn how to send transactional emails in Node.js using SMTP, email APIs like SendGrid or Mailgun, and multichannel tools like Courier. Step-by-step code examples included.

Top 6 Transactional Email Services for Developers in 2025

Looking to send transactional emails for your application? We compare the top transactional email API services for developers to help you pick the right one.

Twitch Notifications (Part Three): How to Create and Notify a List of Subscribers Using Courier

In this tutorial, Aydrian will show you how to extend the Node.js and Express app from part two to send notifications to more than one destination using Courier’s Lists API. He'll also demo sending to a Discord channel.

Twitch Notifications (Part Two): How to Send Notifications When Your Twitch Stream Goes Live

In this tutorial, Aydrian will show you how to listen for events from Twitch and then create and trigger a notification in Courier. He’ll demo sending an SMS notification with Twilio.

Twitch Notifications (Part One): How to Handle Real-Time Events from Twitch

This series will show you how to use Twitch EventSub and Courier to automatically send notifications to many destinations – Discord, Slack, Facebook Messenger, and more – when your Twitch stream goes live.

How to Set Up Your Apple Silicon Mac for Development (M1, M2, M3 Guide)

Setting up a dev environment on an Apple Silicon Mac can be tricky. When I joined Courier, I had to get my M1 MacBook Pro ready for development fast. In this guide, I’ll show you how to use Rosetta 2, install essential CLI tools like nvm and Homebrew, and find native apps for M1, M2, and M3 Macs—so you can skip the trial and error.

How to White Label Email Notifications for Multiple Brands

If you've ever had to whitelabel emails manually, you know how much of a headache that can be. Here's how you can use Brands in Courier to quickly and easily whitelabel emails to match your customers' brands or your own sub-brands.

How to Send Emails with Attachments Using Amazon SES and S3

In this tutorial, you'll get a step-by-step walkthrough of how to add attachments to your transactional emails using Amazon SES and S3. We'll also show you how to integrate your email provider with Courier to manage your email templates and delivery.

How to Send Email with Ruby

In this tutorial, we’ll show you an easy way to add email functionality to your Ruby app. You’ll learn how to set up your email service, design your email template, and test and preview your email before publishing it to production. You’ll also find sample code you can use to quickly start sending in your Ruby program.

Why We Are Moving off REST and Implementing GraphQL

We’re excited to be moving Courier’s internal infrastructure and eventually our customer-facing APIs to GraphQL. In this blog post I’ll talk about why we’ve decided to make the change from REST and what our plans are for the rollout.

Announcing the Courier Destination for Segment – Send Multi-Channel Notifications With No Code

We’re excited to announce the Courier destination for Segment is publicly available. Product teams can now send targeted notifications to users on any channel – without shipping any code. 

How to Add a Direct Twilio SMS Integration With Sendgrid Emails

In this white paper, we share the strategies we have discovered through our work in building direct integrations and explain how to add SMS with Twilio to an existing SendGrid integration. We'll help you think through the various questions involved and set up your infrastructure.

What to consider when standardizing your REST APIs

Recently, we’ve been working on standardizing some aspects of Courier’s REST APIs, such as naming conventions and HTTP status response codes. I thought I’d share some of our guiding principles and learnings that might be useful for your team as well.

Standardizing Message Status Across SendGrid, Twilio, Slack, Firebase, and More

I wanted to share how statuses work today in Courier and some of the things we thought through while building a single source of truth across integration providers. I’ll also explain how we provide open tracking for emails and click-through tracking across all channels.

9 Ways Product Management Expectations Differ from Reality

As a former product manager, bright-eyed and bushy-tailed out of college, I remember clearly coming into the role with a set of rosy expectations that did not align at all with reality. I want to share my experience of what product was like for me, and a smattering of the various ironies that I experienced on the job.

How to Use The Shadow Dom To Isolate Styles on a DOM That Isnt Yours

Shadow DOM is an API for DOM encapsulation. It's perfect for when you need to embed a widget in a DOM you don't have access to.

How An Event Driven Architecture Works

Event-Driven Architecture: how it works, why we use it at Courier, and what our experience has been like so far.