
Delivery windows control when notifications send. Quiet hours control when they don't. Same outcome, different framing—and implementations vary wildly across platforms.
Courier handles this with per-node controls in Journeys and API-level flexibility. Here's how that compares to Braze, Customer.io, Knock, OneSignal, and Novu.
Delivery windows define when messages can send. Quiet hours define when they can't. Platforms use both terms interchangeably, but the configuration differs. Some (like Customer.io) have you set windows when sending is allowed. Others (like Braze) have you define hours when sending is blocked.
Courier supports both patterns. You can configure delivery windows per node in a Journey, or set timing constraints at the API level for individual sends.
On most platforms, no. Timing is an admin-level decision.
The exceptions: Novu lets users configure schedules via Inbox UI—a built-in interface where subscribers set their own delivery windows per day. Knock supports user-controlled quiet hours through its preferences system with transactional exceptions.
Courier's Preference Center handles topic subscriptions and channel selection, but doesn't include a turnkey quiet hours UI. However, you can build user-controlled timing through the CDP: user preferences flow from Segment to Courier's user profiles, and delivery windows automatically respect the timezone trait. For custom quiet hours, store user preferences as profile traits and use Journey conditional logic to check them before sending.
Braze, Customer.io, and OneSignal treat quiet hours as something you set for users, not something users set for themselves.
Braze (Intelligent Timing), Customer.io, and OneSignal (Intelligent Delivery). These use engagement data to calculate optimal send times per user. Braze claims 23% higher open rates; OneSignal cites similar lift across 300K+ apps.
Courier, Knock, and Novu don't offer ML-powered send optimization. If you need AI timing, you're looking at Braze, Customer.io, or OneSignal—and paying for it.
Yes, on most platforms—but the implementation matters.
Courier's per-node approach makes this clean. In a single Journey, your account security alert sends immediately while your promotional push respects quiet hours. No global override needed; you just don't apply the delivery window to that node.
Braze allows per-campaign overrides. Knock and Customer.io require you to structure workflows around it. Novu's subscriber-controlled schedule can have exceptions for critical messages.
Depends on the platform.
Courier queues the message and sends when the window opens. Customer.io holds users at the Time Window step until it opens. Knock queues messages but continues workflow execution for downstream steps. Braze lets you choose: abort entirely or send at the next available time.
Courier takes an API-first approach with controls at two levels: per-message via the API, and per-node within Journeys.
Per-node Journey controls let you apply different timing rules at different steps. Your weekly digest respects quiet hours. Your security alert doesn't. All in the same workflow, configured per step—not as a global setting you override. See the Delays & Delivery Windows documentation for configuration details.
Timezone support works at multiple levels. Set it on the message, on the recipient profile, or fall back to system default. User profiles sync from CDPs like Segment, so timezone traits flow automatically. This matters for transactional use cases where you might not have full user profiles but still need to respect local time.
Send Limits provide frequency capping with per-topic granularity. Marketing gets different limits than transactional. Critical alerts bypass limits entirely.
What Courier doesn't have: No AI-powered send time optimization. No per-channel delivery windows (only Braze and Knock let you set different timing for push vs. email). No built-in subscriber-facing quiet hours UI (Novu has this out of the box).
| Feature | Courier | Braze | Customer.io | Knock | OneSignal | Novu |
|---|---|---|---|---|---|---|
| Quiet Hours | API + per-node | Global + override | Via Time Windows | Via Send Windows | Yes (paid) | Via Schedule UI |
| Timezone-aware | Yes (multi-level) | Yes (local time) | Yes (user attribute) | Yes (user property) | Yes (device-based) | Yes (subscriber) |
| Per-Journey Controls | Yes (per-node) | Yes (Canvas/Campaign) | Yes (workflow step) | Yes (per channel step) | Limited | Yes (delay step) |
| Per-Channel | No | Yes | No | Yes | Partial | No |
| AI Send Optimization | No | Intelligent Timing | Yes | No | Intelligent Delivery | No |
| User-Controlled | Custom build | No | No | Via preferences | No | Yes (Inbox UI) |
| Frequency Capping | Send Limits | Robust (channel + tag) | Message limits | Throttle function | Yes | Digest |
Braze{rel="nofollow"} has the most complete system. Global quiet hours with campaign-level overrides, per-channel frequency capping, and Intelligent Timing that respects quiet windows automatically. The catch: 48 hours advance scheduling for AI timing to work, and none of it applies to in-app messages.
Customer.io{rel="nofollow"} treats time windows as workflow building blocks. Drag a Time Window step into your workflow; users hold there until the window opens. Clean UX, but every journey needs its own configuration—no global quiet hours.
Knock{rel="nofollow"} configures Send Windows per channel step. Messages queue while workflows continue executing. The preferences system lets users set their own quiet hours with transactional exceptions.
OneSignal{rel="nofollow"} focuses on push with timezone delivery and Intelligent Delivery (ML-powered from 300K+ apps). Quiet hours exist on paid plans. Less sophisticated for multi-channel orchestration.
Novu{rel="nofollow"} is subscriber-first. The Schedule feature lives in the Inbox UI where end users configure their own preferences. No admin-level global quiet hours—timing is user-controlled.
Per-channel quiet hours are rare. Only Braze and Knock let you set different windows for push versus email. A 10pm push is invasive in a way a 10pm email isn't.
User control is undervalued. Only Novu and Knock let subscribers manage their own quiet hours meaningfully. Everyone else treats timing as an admin decision.
Critical bypass is inconsistent. Your security alert shouldn't wait because someone hit a message limit. Courier's per-node approach and Braze's override system handle this cleanly; others require workarounds.
Courier lets you orchestrate messaging across email, push, SMS, Slack, and in-app from a single API. See how Journeys handles delivery timing →

The federal texting rule your transportation and logistics software is breaking
A single text to a driving trucker can trigger a federal fine of up to $11,000 for the motor carrier, and your transportation and logistics software is often what sent it. How to design driver notifications that stay on the right side of FMCSA rules.

How Apple's on-device AI works, and what it changes for your users
Apple's 2026 on-device models (AFM 3) are good enough to read, rank, and summarize everything that lands on your phone, locally and for free. Here's how they actually work, in plain terms, and how a model that reads every message before your users do changes what you should send.

Apple Intelligence finally got smart. Here's how it changes the notifications your users see.
Apple Intelligence's on-device models got dramatically better in iOS 27, and they now summarize, rank, and filter notifications before your users ever see them. There's no API to control that, so the words you send are the only lever you have. Here's how notification summaries work and how to write for them.
© 2026 Courier. All rights reserved.