Skip to content
Engineering deep-divesAll articles

Knock vs Novu vs Courier in 2026: Notification Infrastructure & TCO

Engineering and 36-month TCO teardown of Knock vs Novu vs Courier in 2026: event vs per-message billing traps, MongoDB self-hosting overhead, PostgreSQL 17 FORCE RLS digest batching, and multi-channel fan-out math.

Artem Zaitsev
Artem ZaitsevCTO · Idealogic
Author: Artem ZaitsevPublished: Updated: Reading time: 16 minHow we write →
On this page
Idealogic 2026 engineering comparison of Knock vs Novu vs Courier covering multi-channel notification workflows, digest coalescing, MongoDB vs PostgreSQL 17 RLS storage, and 36-month TCO

If you're wiring bell feeds, push alerts, Slack digests, and fallback emails into a SaaS product, you'll end up comparing Knock vs Novu. The shortlist usually grows to Knock vs Novu vs Courier, with Customer.io close behind.

Resend vs SendGrid covers raw SMTP/SES delivery and Sendbird vs Stream covers peer-to-peer chat. Product notification infrastructure sits above both: B2B preferences, in-app React and React Native feeds over WebSockets or SSE, digest batching, quiet hours, and fan-out across channels (APNs, FCM, AWS SES, Twilio, Slack, and Teams).

Knock vs Novu: which is better? Knock fits teams that want a managed service with ready in-app feeds and B2B object and tenant models. Novu fits TypeScript teams that want code-first workflows, billing per workflow run, or an MIT-licensed core to self-host. Past roughly 10 million events a month, an owned PostgreSQL engine is cheaper than both in our model.

At Idealogic, our SaaS development, custom software development, React Native app development, and JavaScript development teams build notification engines across fintech and social and creator economy platforms. Below is our 2026 teardown, a PostgreSQL 17 and BullMQ digest coalescer design, and a 36-month TCO model at 25M monthly deliveries.

The short version

  • Knock is the managed B2B option. Knock is built on Elixir/BEAM and ships <KnockFeedProvider> feeds plus B2B Objects and Tenants. Knock pricing runs from Free (10k messages) to Starter ($250/mo for 50k messages, $0.005 per extra message) to Enterprise at custom volume pricing. The trap: Knock bills per message sent, so one event that goes to in-app, push, and email is up to 3 billed messages. Suppressed, skipped, and failed sends aren't billed.
  • Novu is code-first TypeScript with billing per workflow run. Novu (MIT core plus commercial enterprise modules) syncs @novu/framework steps over an HTTP Bridge and ships <Inbox />. Novu pricing: Free (10k events), Pro ($30/mo, 30k), Team ($250/mo, 250k, about $1.20 per extra 1k), and Enterprise. The catch is that self-hosting Novu adds MongoDB and Redis next to your Postgres.
  • Courier and Customer.io get expensive on high-fanout feeds. Courier pricing (10k free, then $0.005 per send, or $5.00 per 1k) bills in-app and push sends at the same rate as email. Customer.io bills on profiles, so dormant B2C users still cost you.
  • At 25M monthly sends (10M events) with a HIPAA BAA, an owned PG17 engine saves $11.4k to $148.8k in our model. Over 36 months, with $500/mo of SES in every option, the owned PG17 + BullMQ engine ($103,800) beats Novu MIT on EKS ($115,200), Novu Cloud Enterprise ($192,150), and Knock Enterprise ($252,600). The two Enterprise figures are assumed negotiated commits, not list prices.

2026 vendor internals & billing meters: Knock vs Novu vs Courier

Knock bills per message sent, Novu bills per workflow run (trigger), and Courier bills per send. That split explains most quote gaps: in our model, two apps firing 10,000,000 monthly events get SaaS quotes about $20,000 per year apart (Knock vs Novu Cloud). The vendors also differ on database engine and on who owns the workflow code.

Four structural and commercial fault lines separating Knock, Novu, Courier, and an owned PostgreSQL 17 + BullMQ notification engine in 2026

1. Knock (knock.app): Elixir/BEAM feeds, B2B Objects & per-send billing

  1. Elixir/BEAM & <KnockFeedProvider>: Knock is built on Elixir/BEAM and streams WebSocket updates to React, React Native, iOS, and Android feeds with badge counts, read/archive tabs, and Slack/Teams OAuth pickers.
  2. B2B Objects & Tenants: Users subscribe to domain entities (project:proj_892) while workspace branding and preferences attach per tenant_id.
  3. No open-source edition, billing per message: Knock pricing in 2026 is Free (10k messages), Starter ($250/mo for 50k messages, $0.005 per extra message), and Enterprise at custom volume pricing, which is where HIPAA BAA, SAML SSO, and log streaming live. Because Knock bills per message, 10M triggers at 2.5 channels each become about 25M billed messages (up to 30M at three channels). Suppressed, skipped, and failed sends aren't billable, so treat that as a ceiling.

2. Novu (novu.co): @novu/framework Bridge, event billing & MongoDB ops

  1. Code-first @novu/framework: Novu defines workflow() steps (step.inApp, step.digest, step.email) with Zod and @react-email in your TypeScript repo over an HTTPS Bridge, while PMs edit copy in Studio.
  2. Event-based Cloud billing: Novu pricing on Cloud is Free (10k events), Pro ($30/mo for 30k), Team ($250/mo for 250k, then about $1.20 per extra 1k), and custom Enterprise for HIPAA BAA, SSO, and retention. Novu meters workflow runs (triggers), so 1 trigger sent to 3 channels is 1 event.
  3. MongoDB self-hosting tax: Self-hosted Novu (the MIT-licensed core) skips event fees, but it stores subscribers, feeds, and traces in MongoDB, with BullMQ on Redis. On a PostgreSQL stack, that means running HA MongoDB as well.

3. Courier, Customer.io & Owned VPC Orchestration (PG17 + BullMQ)

  • Courier & Customer.io: Courier pricing is 10k sends free, then $0.005 per send ($5.00 per 1k) on Business from the first send. WebSocket and push sends cost the same as email. Enterprise is custom, so confirm a BAA with sales. Customer.io's profile-based tiers penalize dormant B2C cohorts.
  • Owned VPC engine (PG17 FORCE RLS + BullMQ): Preferences, digest buckets, and inbox rows stay in PostgreSQL 17 (the same SQL runs unchanged on 18). BullMQ dispatches the jobs (Inngest vs Trigger.dev) and updates stream over RFC 6455 WebSockets or WHATWG SSE. Workers call Amazon SES at $0.10 per 1k emails before attachments and dedicated IPs, Apple APNs and FCM at $0 per message, Twilio SMS, and Slack Webhooks. You pay no per-send SaaS fee and run no extra MongoDB cluster.
DimensionKnock (2026)Novu Cloud / MITCourier (2026)Owned (PG17 + BullMQ)
Runtime & OSSElixir SaaS (No OSS)MIT Core (MongoDB + Redis)Prop. SaaS (No OSS)Owned (PG17 + Redis)
Billing meterPer message (1x3 = 3)Per trigger event (1x3 = 1)Per send ($5/1k Business)$0 engine ($0.10/1k SES)
Paid entry$250/mo (50k msgs)$30 Pro; $250 Team (250k)$0.005/send PAYG~$450/mo compute + SES
In-app UI<KnockFeedProvider><Inbox /> React / hooksCourier Inbox SDKReact / RN hooks + WS/SSE
HIPAA & PCIBAA = EnterpriseBAA = Ent. or self-hostEnterprise (confirm BAA with sales)AWS HIPAA BAA & PCI DSS v4.0.1

Pricing last verified in November 2026. AWS services are HIPAA-eligible, which makes them compliant only when you configure them under the BAA.

Notification infrastructure blueprint: PostgreSQL 17 digest batching and multi-channel fan-out

In multi-tenant SaaS and regulated API integrations, an owned notification engine has three hazards to handle: comment storms (50 PR comments firing 50 emails), cross-tenant inbox leaks (BOLA), and duplicate sends when a retry only partly succeeds.

The digest coalescer is the part that replaces Knock's and Novu's batching steps. A partial unique index allows one open bucket per tenant, recipient, topic, and group, and an atomic upsert folds every new event into that bucket.

The window is fixed. The first event sets the flush deadline and later events don't push it back, so a busy thread still flushes on time. The bucket keeps up to 20 event summaries for the digest body, and the counter keeps counting past that.

Six other decisions shape the rest of the engine:

DecisionWhere it's enforcedWhat it buys you
Tenant isolationDatabase: Row-Level Security with FORCE ROW LEVEL SECURITY and a restrictive policy on every notification tablePostgreSQL ORs permissive policies together, so the restrictive policy is the real tenant wall. It fails closed when the session has no tenant ID set (see multi-tenant SaaS architecture)
Claiming due digestsDatabase: a separate relay role marks due buckets as processing with FOR UPDATE SKIP LOCKEDSeveral workers can poll at once without grabbing the same bucket, and a bucket stuck in processing for 10 minutes gets picked up again
Idempotent fan-outDatabase: one delivery row per bucket and channel, unique on tenant, channel, and idempotency keyIf SES throttles after the in-app and push sends succeed, the BullMQ retry skips both and resends only the email
RetriesApp: one BullMQ job ID per bucket, 5 attempts with exponential backoffDuplicate enqueues collapse into one job, and a provider hiccup doesn't drop the digest
Quiet hours and preferencesApp: the worker reads each user's channel list and quiet window before sendingPush and email are logged as suppressed during quiet hours, while the in-app inbox row still lands
Regulated payloads and unsubscribesApp: push carries only an opaque delivery ID and an event count; unsubscribe links carry an HMAC-SHA256 signature checked with a constant-time comparePHI stays off lock-screen banners (see HIPAA-compliant software development), and a forged link can't unsubscribe someone else
Paying per message on Knock, or running MongoDB just to self-host Novu?
Share your monthly event volume, channel fan-out ratio, and HIPAA or B2B preference rules. Our architects will benchmark Knock, Novu, and an owned PostgreSQL 17 notification engine.
Audit your notification stack

Worked 36-month TCO model: Knock vs Novu vs owned at 25M monthly deliveries

Model a B2B SaaS or creator platform over 36 months: 800 B2B tenants, 10,000,000 workflow triggers/month fanning out 2.5x into 25,000,000 monthly deliveries (10M In-App + 10M APNs/FCM Push + 5M AWS SES Emails), under SOC 2 Type II + HIPAA BAA + SAML SSO.

Raw email transport (5M SES emails/mo @ $0.10/1,000 = $500/mo; APNs/FCM = $0) is included identically across all four options. Labor compares Idealogic's $75/hr Senior CEE vs $165/hr US agency rates (2.2x), anchored in the 2025 EU whole-economy hourly labour cost benchmark (lc_lci_lev, EUR 34.9) and US DOL / BLS Software Developers (15-1252.00) wage data:

One caveat before the numbers. The Knock and Novu Enterprise figures are illustrative negotiated commits, not list prices: at Knock's list overage of $0.005 per message, 25M messages would run $125,000 a month. The MongoDB, Redis, and EKS lines are our estimates.

  1. Option A: Knock Enterprise (25M billed messages/mo + HIPAA BAA + SSO + $500/mo SES):
    • Setup (80h @ $75/hr CEE = $6,000; $165/hr US = $13,200): <KnockFeedProvider>, Tenants/Objects, Slack OAuth, and webhooks.
    • 36-mo SaaS + SES ($6,400/mo x 36 = $230,400): 25M billed sends ($5,900/mo assumed negotiated Enterprise commit + BAA + SSO) + $500/mo SES + 6h/mo (216h) ops ($16,200 CEE / $35,640 US) = $252,600 ($279,240 US).
  2. Option B: Novu Cloud Enterprise (10M workflow events/mo + HIPAA BAA + SSO + $500/mo SES):
    • Setup (90h @ $75/hr CEE = $6,750; $165/hr US = $14,850): @novu/framework Bridge routes, Zod schemas, <Inbox />, and tenant prefs.
    • 36-mo SaaS + SES ($4,700/mo x 36 = $169,200): 10M trigger events ($4,200/mo assumed negotiated Enterprise commit + BAA + SSO) + $500/mo SES + 6h/mo (216h) ops ($16,200 CEE / $35,640 US) = $192,150 ($219,690 US).
  3. Option C: Self-Hosted Novu (MIT-licensed core) on AWS EKS (MongoDB + Redis + Workers + $500/mo SES):
    • Setup (240h @ $75/hr CEE = $18,000; $165/hr US = $39,600): EKS Helm, HA MongoDB replica set, Redis, Bridge routes, and SAML wrappers.
    • 36-mo EKS + MongoDB + SES ($1,650/mo x 36 = $59,400): HA MongoDB ($520/mo), Redis ($220/mo), and EKS pods ($410/mo) = $1,150/mo + $500/mo SES + 14h/mo (504h) MongoDB/Novu SRE ops ($37,800 CEE / $83,160 US) = $115,200 ($182,160 US).
  4. Option D: Owned VPC Notification Engine (PG17 FORCE RLS + BullMQ Digest + React Inbox + SES):
    • Turnkey build (640h @ $75/hr CEE = $48,000; $165/hr US = $105,600): Partitioned PG17 prefs/digests/deliveries, BullMQ workers, APNs/FCM v1/SES/Slack, WebSocket <NotificationInbox />, and k6 QA.
    • 36-mo AWS + SES ($950/mo x 36 = $34,200): Primary PG17 delta ($120/mo), Multi-AZ Redis ($150/mo), and Graviton4 c8g.large pods ($180/mo) = $450/mo + $500/mo SES + 8h/mo (288h) SRE ops ($21,600 CEE / $47,520 US) = $103,800 ($187,320 US).
Worked 36-month notification TCO ($k) at 25M channel deliveries/mo (10M events, $500/mo SES included): Owned PG17 Engine saves $11.4k vs Novu MIT EKS, $88.35k vs Novu Cloud, and $148.8k vs Knock Enterprise
36-month line item (10M events, 25M sends)Option A: Knock Ent.Option B: Novu Cloud Ent.Option C: Novu MIT EKSOption D: Owned PG17 EngineEconomic driver
1. Setup / build (@ $75/hr CEE)$6,000 (80h; $13.2k US)$6,750 (90h; $14.85k US)$18,000 (240h; $39.6k US)$48,000 (640h; $105.6k US)VPC engine & Inbox
2. 36-mo SaaS / AWS + $500 SES$230,400 ($6,400/mo)$169,200 ($4,700/mo)$59,400 ($1,650/mo)$34,200 ($950/mo)Zero send tax / MongoDB
3. 36-mo SRE ops (@ $75/hr)$16,200 (6h/mo; 216h)$16,200 (6h/mo; 216h)$37,800 (14h/mo; 504h)$21,600 (8h/mo; 288h)Reuses primary PG17
Total 36-Month TCO$252,600$192,150$115,200$103,800 (CapEx incl.)Saves $11.4k to $148.8k
Year-2+ Run-Rate$82,200/yr$61,800/yr$32,400/yr$18,600/yrSaves $13.8k to $63.6k/yr
DB Sprawl & Lock-InProp. SaaSSaaS BridgeExtra MongoDB HASingle PG17 + zero vendor lock-inACID outbox

Sensitivity check: Knock vs Novu payback math

  • Seed & Series A (<250k events/mo, <$300/mo): Rent Novu Cloud Team ($250/mo) or Knock Starter ($250/mo base, 50k messages included) until retention holds (SaaS development cost).
  • High-volume payback (10M+ events/mo): At $75/hr CEE, Option D's $42,000 extra CapEx over Knock divided by $5,300/mo OpEx savings ($6,850/mo vs $1,550/mo) pays back in 7.92 months (11.46 months vs Novu Cloud: $41,250 / $3,600/mo; 26.09 months vs Novu MIT EKS before saving $13,800/yr). Even at $165/hr US labor ($187,320), owning beats Knock ($279,240) and Novu Cloud ($219,690).

2026 notification infrastructure & inbox build costs (Senior CEE vs US)

Our SaaS development, React Native app development, and JavaScript development teams deliver fixed-milestone builds at $75/hr senior CEE vs $165/hr US agency rates:

Engagement tierTimelineHoursSenior CEE ($75/hr)US Agency ($165/hr)Deliverables
Knock / Novu Sprint2 to 3 wks120 to 200h$9,000 to $15,000$19,800 to $33,000@novu/framework / Knock feeds & prefs
Novu MIT EKS4 to 6 wks240 to 360h$18,000 to $27,000$39,600 to $59,400EKS Helm, HA MongoDB + Redis & OTel
Owned PG17 Engine (640h)8 to 11 wks560 to 800h$42,000 to $60,000 ($48k)$92,400 to $132,000 ($105.6k)PG17 FORCE RLS, digests, SES & Inbox
HIPAA / FinTech Hub12 to 15 wks880 to 1,200h$66,000 to $90,000$145,200 to $198,000Zero-PHI wakeups, KMS & SMS failover
Dedicated PodOngoing240h/mo (2)From $18,000/moFrom $39,600/moTypeScript, PostgreSQL & React Native

Inside the worked 640-hour ($48,000 CEE vs $105,600 US) owned notification build

Worked model, assumptions in text: 640-hour ($48,000 at $75/hr CEE vs $105,600 at $165/hr US) owned PostgreSQL 17 notification preferences, digest coalescer, multi-channel adapters & React Inbox
  • 1. PG17 Prefs & FORCE RLS (25% / 160h / $12,000 CEE vs $26,400 US): Org, workspace, and user preference levels, partitioned notification_deliveries, AS RESTRICTIVE fences, and RFC 8058 one-click unsubscribes.
  • 2. Digest & BullMQ (25% / 160h / $12,000 CEE vs $26,400 US): Atomic ON CONFLICT JSONB coalescing, SKIP LOCKED relay, quiet hours, and 15m unread SES escalation.
  • 3. APNs, FCM v1, SES & Webhooks (20% / 128h / $9,600 CEE vs $21,120 US): HTTP/2 .p8 APNs, FCM v1 OAuth2 HTTP/2 multiplexing, token pruning, SES v2 bounce suppression, and Slack OAuth.
  • 4. <NotificationInbox /> & WS/SSE (20% / 128h / $9,600 CEE vs $21,120 US): Optimistic read/archive hooks for Next.js and React Native, Redis badges, and cursor feeds (Convex vs Supabase).
  • 5. Cutover & Storm QA (10% / 64h / $4,800 CEE vs $10,560 US): Shadow dual-write migration, 5,000 events/sec k6 storm tests, and OpenTelemetry alerts.

Knock and Novu save months before Series A. Once workflows fan out twenty-five million times a month or self-hosting adds MongoDB to a Postgres stack, moving digests onto PostgreSQL 17 and BullMQ cuts ongoing notification COGS by roughly 70 to 77 percent versus managed SaaS in our model.

Artem Zaitsev · CTO at Idealogic

Shipped Idealogic proof & 5-step checklist for Knock vs Novu vs Courier

Idealogic ships regulated notification and alert pipelines in production:

  • Mobile banking alerts (C-Bank): Instant payment confirmations, loan flows, and reporting under OWASP MASVS and PCI DSS v4.0.1, lifting launch-quarter downloads +30%, MAUs +40%, and cross-service usage +25%.
  • Zero-PHI clinical reminders (AddMed): Adaptive medication reminders, clinical adherence alerts, and bidirectional HL7/FHIR sync keeping PHI out of lock-screen pushes across zero-incident HIPAA and GDPR pilots.
  • Creator payout alerts (Ugreator): Cross-network milestone alerts wired to automated Stripe Connect split payouts across Instagram, TikTok, and YouTube.

Five questions cover most Knock vs Novu vs Courier decisions in 2026:

  1. Under 250k events/mo needing B2B Objects + Slack OAuth fast? Pick Knock Starter ($250/mo base, 50k messages included).
  2. Want Git-synced @novu/framework steps and event billing? Pick Novu Cloud ($30 Pro / $250 Team).
  3. Already running MongoDB on K8s under <10M events? Self-host Novu MIT (14 hrs/mo ops).
  4. Pure OTPs and receipts without inbox feeds? Use Resend, Postmark, or AWS SES directly.
  5. Past 10M+ events/mo (25M+ sends) or under HIPAA / PCI VPC rules? Deploy an Owned PG17 + BullMQ Engine ($950/mo incl. 5M SES). Contact our team for a 48-hour TCO audit.
Scoping Knock vs Novu or graduating to an owned VPC notification & inbox engine?
Send your monthly trigger counts, channel mix, and compliance constraints. Our senior CEE architects will return a PostgreSQL 17 + BullMQ blueprint and fixed-milestone quote within 48 hours.
Request a 48-hour notification TCO audit

Occasional field notes on building software, no spam

Protected by Cloudflare Turnstile · Privacy · Terms

Artem Zaitsev
Artem ZaitsevCTO · Idealogic Development OÜ

CTO and Co-founder at Idealogic. Directing engineering, systems architecture, security, and full-stack delivery across web, mobile, and blockchain.

Frequently asked questions

  • Choose Knock when you want a managed service with nothing to operate. You get ready React and React Native in-app feed components, first-class B2B object and tenant subscription models, and visual workflow debugging. Choose Novu when your TypeScript team wants code-first workflows synced from Git via @novu/framework, billing per workflow run that doesn't multiply across channels, or an MIT-licensed open-source core you can self-host.

  • Knock and Courier meter each outbound channel message. One workflow event that writes an in-app inbox row, fires a mobile push, and sends a fallback email can count as three billable messages (Knock doesn't bill suppressed, skipped, or failed sends, so three is the ceiling). Novu Cloud meters workflow runs, so one API trigger fanning out across three channels uses a single billable event. At 10 million monthly triggers averaging 2.5 channels each, per-message metering bills 25 million units instead of 10 million.

  • Novu's core is MIT-licensed, but it keeps its state in MongoDB, with Redis and BullMQ workers alongside, not in PostgreSQL. A team standardized on PostgreSQL has to provision, back up, patch, and monitor a separate high-availability MongoDB replica set or Atlas cluster just for notification state. In our model that adds roughly $1,150 per month for MongoDB, Redis, and worker compute, plus 14 hours per month of database and upgrade work.

  • Courier pricing starts with a free Developer tier up to 10,000 monthly sends, then a pay-as-you-go Business tier at $0.005 per send ($5.00 per 1,000 messages) from the first send. That gets expensive once high-frequency in-app and mobile push sends reach the millions. Customer.io is strong at lifecycle marketing journeys and behavioral segmentation, but it bills mainly on stored profiles, which penalizes consumer and creator apps with large dormant user bases.

  • Without digest batching, 50 comments posted on one pull request or incident ticket within two minutes trigger 50 separate push banners and 50 emails per subscriber. A fixed-window digest keys an open PostgreSQL bucket on tenant ID, recipient ID, topic, and group, and sets a flush deadline when the first event arrives. Later events append to the same bucket atomically, and one summary notification goes out when the window closes.

  • Push payloads pass through Apple (APNs) and Google (FCM) servers and can show up on the lock screen, depending on the user's preview settings. So Protected Health Information and sensitive cardholder details shouldn't travel inside push payloads. Regulated platforms keep sensitive bodies in VPC PostgreSQL 17 behind FORCE ROW LEVEL SECURITY, send a wake push with no PHI that references an opaque notification ID, and route encrypted email through AWS SES configured under an AWS HIPAA Business Associate Addendum.

  • Managed notification SaaS wins easily below 500,000 monthly events, because prebuilt inbox feeds and preference UIs save months of product work. Once a multi-tenant platform reaches 10 million workflow events and 25 million channel deliveries a month with HIPAA BAA and SAML SSO requirements, an owned PostgreSQL 17 outbox, digest aggregator, and React inbox brings 36-month TCO down to $103,800 in our worked model. That's $88,350 less than Novu Cloud Enterprise and $148,800 less than Knock Enterprise, both priced at assumed negotiated commits, not list prices.

  • With Idealogic's senior Central and Eastern European TypeScript, React Native, and PostgreSQL engineers at $75 per hour (versus $165 per hour at US agency rates), a 640-hour build costs $48,000 ($105,600 at US rates). It covers PostgreSQL 17 FORCE RLS preference hierarchies, digest batching, BullMQ workers, APNs, FCM, and AWS SES adapters, and a real-time WebSocket React inbox. It runs on $950 per month including 5 million SES emails.

Still unanswered
Ask us directly

A senior engineer replies under 4 hours.

Related expertise