

TL;DR:
- Customer journey orchestration coordinates the triggers, branching, multichannel sends, and retries that move a user through a defined sequence (onboarding, dunning, escalation, re-engagement, agent-driven flows).
- The marketer-facing version lives inside CEPs like Customer.io and Braze. The developer-facing version exposes the same primitives as APIs, SDKs, and CLI so flows live in source control next to the product.
- Courier Journeys handles orchestration above your existing providers (Twilio, Resend, FCM, Slack). You define the journey; Courier handles delivery, failover, and observability. See the docs and quickstart to wire one up.
Customer journey orchestration is the practice of coordinating the messages a user receives across channels, in the right order, based on what they do or fail to do in your product. It sits above the providers that actually deliver messages (Twilio for SMS, Resend or SES for email, FCM for push) and decides who gets what, when, and through which channel. API-first orchestration exposes that decision layer as code rather than a marketing UI.
Customer journey orchestration is the layer that turns a product event (user signed up, payment failed, alert fired, deployment shipped) into a sequence of well-timed messages across the channels a user actually checks. A single trigger can fan out to email now, an SMS reminder in 24 hours if the email goes unread, and a Slack ping to an internal team if the user still hasn't acted by day three.
Three things distinguish orchestration from sending a single notification:
Any orchestration product worth using has the same five primitives. The differences are in how you operate them: through a marketer UI, a developer API, or both.
Observability ties these together. A journey without logs is a journey you can't debug.
The two get conflated because they both send messages based on user behavior. The audience, surface, and failure mode are different.

| Marketing automation | Customer journey orchestration | |
|---|---|---|
| Primary user | Marketer or lifecycle manager | Developer, PM, growth engineer |
| Primary surface | Visual builder inside a CEP | API, SDK, CLI, optional visual builder |
| Source of truth | The CEP's UI | Source control (or a UI synced to source control) |
| Triggers | Audience entry, CRM event, email click | Product events, webhooks, API calls, scheduled jobs |
| Typical channels | Email, SMS, push (campaign-shaped) | Email, SMS, push, in-app, Slack, Teams, webhook |
| Versioning | Tool-specific, often manual | Git, branches, code review |
| Best fit | Lifecycle campaigns, broadcast offers | Transactional flows, product alerts, agent outputs, mixed marketing + product |
Courier covers both: marketers build journeys in the canvas and run broadcasts, and engineers wiring up payment-failure dunning or alert escalations can create journeys through the API and manage them in code alongside the rest of the application.
In a UI-first orchestrator, a new journey is a meeting, a Figma file, and a marketer clicking through nodes. In an API-first orchestrator, a new journey is a TypeScript file in the same repo as the product.
A minimal trigger looks like a normal API call. Here's a payment-failure flow using Courier:
import Courier from "@trycourier/courier";
const courier = new Courier(); // reads COURIER_API_KEY
await courier.journeys.invoke("payment-failed-dunning", {
user_id: "user_28af3",
data: {
invoice_id: "in_19fr",
amount_due: 4900,
grace_period_ends: "2026-06-02"
}
});payment-failed-dunning is a published journey: send email immediately, wait 48 hours, send SMS if the invoice is still unpaid, escalate to a Slack channel after day five. The application code that handles the failed payment doesn't care about any of that. It invokes the journey with a payload, and the orchestrator owns the sequence. Compare the underlying delivery options in best email API providers for developers and the broader transactional email services breakdown.
For a journey with branching that depends on runtime state, you define the journey once (in the Journeys canvas or through the Journeys API, where send, delay, branch, fetch, and AI are first-class nodes) and then invoke a run for a user from code:
from courier import Courier
client = Courier() # reads COURIER_API_KEY
# Invoke a published journey for a user; data is available as variables in every node.
client.journeys.invoke(
"abandoned-checkout",
user_id="user_19c",
data={"cart_id": "c_551"},
)If you build journeys through the API, their definitions can live in your repo and go through code review like any other change. Journeys built in the canvas are versioned and published in Courier, with separate Test and Production environments. AI coding agents can build them too: the AI agent quickstart sets up Courier Skills and the MCP server in Claude Code, Cursor, or Codex.
Try Courier Journeys free. Build multichannel journeys in the canvas or in code. Create a free developer account.

A handful of patterns show up across nearly every product, regardless of vertical.
The pattern isn't the interesting part. All of these collapse to the same set of primitives (trigger, wait, branch, send, cancel), which is why a single orchestration layer can own them.
Customer journey tracking is the data side of the same problem. The orchestrator emits events at every step; useful measurement means turning those events into answers to four questions:
Customer journey optimization is what you do with those four answers: shorten a delay that's losing users, swap a channel where deliverability is poor, cap frequency where unsubscribes spike. The orchestrator's logs make the change auditable; the metrics make it justifiable.
For most teams, journey-level analytics live in three places: the orchestration product's own logs (per-message debugging), a warehouse (long-term cohort analysis), and a product analytics tool (funnel and conversion). Courier covers the first with per-message logs and step-by-step run inspection, and feeds the others through outbound webhooks and observability integrations.
Three paths, depending on who owns the journey and what good looks like for the team.
If the team is engineering-led, the journey involves product events more than marketing campaigns, and the existing provider stack (Twilio, Resend, SES, FCM, Slack) should stay in place, an API-first orchestrator like Courier Journeys is the closer match.
For a deeper comparison of specific products, see the customer journey orchestration tools comparison. For the underlying delivery layer, multichannel notifications explains the channels Courier coordinates.
Customer journey orchestration is the layer that coordinates triggers, branching, multichannel sends, delays, and retries to move a user through a defined sequence based on product events and behavior. It sits above the providers that actually deliver messages and decides who gets what, when, and on which channel.
Mapping is the diagram of what should happen. Orchestration is the running system that executes against the map, sending messages, waiting, branching, and recovering when steps fail.
No. They overlap on lifecycle campaigns, but orchestration also covers transactional notifications, product alerts, and agent-driven flows. API-first orchestrators define journeys in source control rather than a marketing UI, so engineering can own them.
Options range from marketer-focused customer engagement platforms like Customer.io and Braze to Courier, the customer messaging platform for humans and AI agents. The right fit depends on whether engineering or marketing owns the journeys; see our customer journey orchestration tools comparison for a full breakdown.
Not necessarily. A CDP helps if user data is fragmented across many systems. For most product teams, the orchestrator can read directly from the application database and the user profile store the orchestrator already maintains.
Yes, with a BYOP (bring your own provider) orchestrator. Courier Journeys sits above your existing providers, so they continue to handle delivery while the orchestration layer handles routing, failover, and observability.
AI agents emit events to the orchestrator, which applies batching, throttling, and digest logic before sending. That keeps a burst of agent activity from turning into a burst of notifications, while still surfacing the important results to the user.

Catch broken lifecycle journeys with synthetic users and AI
Paste one prompt into a coding agent and get a local test of your onboarding journey: synthetic users, real timing, and every send explained. Catch stale reminders before your customers do.

Control how fast Courier sends to your providers
You shouldn't have to think about how fast you send to Courier. Set a send rate limit on any provider, and Courier sends your notifications to it at the rate you choose. Anything over the limit is queued, not dropped.

Know the moment users change notification preferences
Every preference change in Courier now reaches your systems two ways. A `preferences:user:updated` webhook fires the moment a user opts in, opts out, or changes a topic's channels, wherever they made the change. `GET /preferences/logs` returns the history, newest first, with the previous value where Courier knows it. Keep your CRM, warehouse, or marketing tools in step with what users chose.