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.

On this page

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 B2BObjectsandTenants. 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/frameworksteps 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+BullMQengine ($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.
1. Knock (knock.app): Elixir/BEAM feeds, B2B Objects & per-send billing
- 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. - B2B
Objects&Tenants: Users subscribe to domain entities (project:proj_892) while workspace branding and preferences attach pertenant_id. - 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
- Code-first
@novu/framework: Novu definesworkflow()steps (step.inApp,step.digest,step.email) with Zod and@react-emailin your TypeScript repo over an HTTPS Bridge, while PMs edit copy in Studio. - 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.
- 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 WHATWGSSE. 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.
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:
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.
- Option A: Knock Enterprise (
25Mbilled messages/mo + HIPAA BAA + SSO +$500/moSES):- Setup (
80h@$75/hrCEE = $6,000;$165/hrUS = $13,200):<KnockFeedProvider>,Tenants/Objects, Slack OAuth, and webhooks. - 36-mo SaaS + SES ($6,400/mo x 36 = $230,400):
25Mbilled sends ($5,900/moassumed negotiated Enterprise commit + BAA + SSO) +$500/moSES +6h/mo(216h) ops ($16,200 CEE /$35,640US) = $252,600 ($279,240US).
- Setup (
- Option B: Novu Cloud Enterprise (
10Mworkflow events/mo + HIPAA BAA + SSO +$500/moSES):- Setup (
90h@$75/hrCEE = $6,750;$165/hrUS = $14,850):@novu/frameworkBridge routes, Zod schemas,<Inbox />, and tenant prefs. - 36-mo SaaS + SES ($4,700/mo x 36 = $169,200):
10Mtrigger events ($4,200/moassumed negotiated Enterprise commit + BAA + SSO) +$500/moSES +6h/mo(216h) ops ($16,200 CEE /$35,640US) = $192,150 ($219,690US).
- Setup (
- Option C: Self-Hosted Novu (
MIT-licensed core) on AWS EKS (MongoDB + Redis + Workers +$500/moSES):- Setup (
240h@$75/hrCEE = $18,000;$165/hrUS = $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/moSES +14h/mo(504h) MongoDB/Novu SRE ops ($37,800 CEE /$83,160US) = $115,200 ($182,160US).
- Setup (
- Option D: Owned VPC Notification Engine (
PG17 FORCE RLS+BullMQDigest + React Inbox +SES):- Turnkey build (
640h@$75/hrCEE = $48,000;$165/hrUS = $105,600): PartitionedPG17prefs/digests/deliveries,BullMQworkers,APNs/FCM v1/SES/Slack, WebSocket<NotificationInbox />, andk6QA. - 36-mo AWS + SES ($950/mo x 36 = $34,200): Primary
PG17delta ($120/mo), Multi-AZ Redis ($150/mo), and Graviton4c8g.largepods ($180/mo) =$450/mo+$500/moSES +8h/mo(288h) SRE ops ($21,600 CEE /$47,520US) = $103,800 ($187,320US).
- Turnkey build (
Sensitivity check: Knock vs Novu payback math
- Seed & Series A (
<250kevents/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/hrCEE, Option D's$42,000extra CapEx over Knock divided by$5,300/moOpEx savings ($6,850/movs$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/hrUS 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:
Inside the worked 640-hour ($48,000 CEE vs $105,600 US) owned notification build
- 1. PG17 Prefs &
FORCE RLS(25% / 160h / $12,000 CEE vs $26,400 US): Org, workspace, and user preference levels, partitionednotification_deliveries,AS RESTRICTIVEfences, and RFC 8058 one-click unsubscribes. - 2. Digest &
BullMQ(25% / 160h / $12,000 CEE vs $26,400 US): AtomicON CONFLICTJSONB coalescing,SKIP LOCKEDrelay, quiet hours, and15munread SES escalation. - 3.
APNs,FCM v1,SES& Webhooks (20% / 128h / $9,600 CEE vs $21,120 US): HTTP/2.p8APNs,FCMv1 OAuth2 HTTP/2 multiplexing, token pruning,SES v2bounce 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,000events/seck6storm 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.
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/FHIRsync 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 Connectsplit payouts across Instagram, TikTok, and YouTube.
Five questions cover most Knock vs Novu vs Courier decisions in 2026:
- Under
250kevents/mo needing B2BObjects+ Slack OAuth fast? Pick Knock Starter ($250/mo base, 50k messages included). - Want Git-synced
@novu/frameworksteps and event billing? Pick Novu Cloud ($30Pro/$250Team). - Already running MongoDB on K8s under
<10Mevents? Self-host Novu MIT (14 hrs/moops). - Pure OTPs and receipts without inbox feeds? Use
Resend,Postmark, orAWS SESdirectly. - Past
10M+events/mo (25M+sends) or under HIPAA / PCI VPC rules? Deploy an OwnedPG17+BullMQEngine ($950/moincl.5MSES). Contact our team for a 48-hour TCO audit.

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.
More from the journal

Paddle vs Lemon Squeezy in 2026: MoR Fees, Stripe & TCO
Paddle vs Lemon Squeezy and Stripe Managed Payments in 2026, compared on fees and 36-month TCO: stacked international and subscription surcharges, merchant of record liability, B2B Net-30 invoicing, PG17 entitlement guards, and the math for a $6M/yr SaaS.

Merge vs Paragon in 2026: Unified API, Embedded iPaaS & TCO
Engineering and 36-month TCO comparison of Merge.dev vs Paragon vs Nango in 2026: per-linked-account vs per-tenant billing at 800 connections, Common Models vs ActionKit, an AWS KMS envelope OAuth2 vault on PostgreSQL FORCE RLS, and itemized payback math.

Nylas vs Cronofy in 2026: Calendar Sync, CASA & TCO
Nylas vs Cronofy vs Aurinko and owned Google Workspace + Microsoft Graph sync in 2026: public per-account pricing, which Google scopes need CASA Tier 2, a PostgreSQL KMS token vault, and 36-month TCO math at 6,000 accounts.