Novu vs Knock vs Courier vs SuprSend: Notification Infrastructure Compared (2026)

Every product I've shipped in the last four years has needed the same boring thing: a way to tell users that something happened. A booking confirmed. A payment failed. An export finished. A teammate left a comment. For years I hand-rolled this — a notifications table, a queue worker, an SMTP call, a Firebase push, and a pile of "if email then, else SMS" logic glued together with hope. It worked until it didn't. The moment a client asked for "let users mute comment emails but keep payment alerts," the whole thing became a maintenance tax I paid every sprint.

That is the exact pain notification infrastructure platforms exist to remove. They give you one API call, a workflow engine that fans out to email/SMS/push/in-app, per-user preference management, and a pre-built notification feed widget. In this comparison I'm putting the four that actually matter in 2026 — Novu, Knock, Courier, and SuprSend — head to head, with real pricing, the architectural tradeoffs I've hit in production, and a decision matrix you can act on today.

Quick disclosure on where I'm coming from: I run Warung Digital Teknologi and have shipped 50+ projects across 30+ clients in 11+ years — a Hotel Management Suite, a Smart POS, a Digital Pawnshop, an e-commerce marketplace, plus AI products like a food-scanner and an AI helpdesk bot. Almost all of them send transactional notifications. My stack is Laravel/Node on the backend and Vue/React/Flutter on the front, so I care a lot about whether a vendor's SDK plays nicely outside the JavaScript-only bubble.

The short answer (for people who don't read 3,000 words)

• Novu — pick it if you want open source and the option to self-host. Apache 2.0, the only one of the four with a real self-hosted distribution today.
• Knock — pick it for the best developer experience and the cleanest in-app feed. The catch is the pricing cliff: free, then $250/month with nothing in between.
• Courier — pick it if non-engineers (marketing, design) will own templates. Best visual template builder, friendliest to enterprise procurement.
• SuprSend — pick it for multi-tenant B2B SaaS. Strong batching, preferences, and "Objects/tenants" modeling at a price between Knock's free tier and its $250 wall.

Now the long answer.

What "notification infrastructure" actually means

People conflate three different things, so let's separate them. A push provider (FCM, APNs, OneSignal) physically delivers a push to a device. An email API (Resend, Postmark, SendGrid) delivers email. Notification infrastructure sits above both. It owns the logic: which channels to try, in what order, with what fallback, batched or not, respecting which user preference, in which timezone — and it owns the in-app notification feed (the bell icon with the red dot). It then hands the actual delivery off to providers like the ones above.

In my experience the in-app feed is the feature people underestimate. Building a real-time, paginated, mark-as-read, "seen vs. read" notification center with websocket updates is a two-to-three week job done properly, and it's pure undifferentiated plumbing. Every one of these four gives you a drop-in React/Vue component for it. That single feature is usually what justifies the buy-vs-build decision before you even get to multi-channel routing.

The contenders at a glance

Pricing verified June 2026 from each vendor's public pricing page; tiers change often, so treat exact dollar figures as a starting point and confirm before you commit.

Novu: the open-source default

Novu is the one I reach for first, and the reason is simple — it's Apache 2.0 licensed and it's the only platform here you can genuinely self-host today. That matters more than people expect. Two of my clients (a hospital-adjacent system and a fintech-flavored pawnshop product) have data-residency clauses in their contracts that make "ship customer events to a US SaaS" a non-starter. With Novu I run the whole thing on a VPS inside the client's own boundary and the compliance conversation ends before it begins.

The cloud free tier gives you 10,000 workflow runs per month, and the paid cloud tiers are usage-based with a low entry point — a meaningfully different cost curve from Knock's $250 floor. If you self-host, the per-event cost disappears entirely and is replaced by infrastructure cost. For a well-sized self-hosted deployment that's roughly $50–200/month in compute regardless of whether you send 200k or 2M events, which is why self-hosting becomes economically obvious somewhere north of 1–2 million events per month.

What I like in production: the workflow engine is a clean state machine (steps, delays, digests, conditional branches) and the React notification center component is genuinely drop-in. What I'd warn you about: self-hosting is not free in labor. You own upgrades, Redis/Mongo babysitting, and on-call. The "$50/month VPS" number is real only if you don't count your own time. For a small team I now default to Novu Cloud and only move to self-host when a contract forces it or volume makes the math undeniable.

My opinionated take

If you have no specific reason to pick another tool, start with Novu Cloud. The escape hatch to self-hosting is worth keeping even if you never use it — it's the only platform here that prevents vendor lock-in at the architecture level.

Knock: the developer-experience leader

Knock is the one engineers fall in love with. The SDKs are clean, the docs are the best of the four, the workflow builder is intuitive, and the in-app feed widget is the most polished. If I were optimizing purely for "how fast can a senior dev wire this up and feel good about it," Knock wins. I integrated it into a client dashboard in an afternoon, preferences and all.

The problem is the pricing cliff, and it's a real one. The free tier is 10,000 messages/month, and then the next step is the Starter plan at $250/month for 50,000 messages, with overages around $0.005 per message. There is nothing between free and $250. For a side project or an early-stage product doing 15,000 messages a month, that jump is brutal — you're paying $250 to send 5,000 messages over the free cap. Knock also splits pricing models: messages are message-based, but their in-app "Guides" product uses active-user pricing, so model your real volume carefully before assuming a number.

Where Knock earns the price is once you're past the cliff and sending real volume with a real team. The reliability, the observability into delivery, and the developer ergonomics are top of the class. I'd recommend Knock over the others when you have a funded product, a dedicated engineer who owns notifications, and you've outgrown the "is this worth $250" question.

Courier: built for the people who aren't engineers

Courier's distinguishing bet is that the person designing your notifications often isn't a developer. Its visual template builder and routing/orchestration designer are the strongest of the four for non-technical owners. If your marketing or design team wants to tweak the copy and layout of a "your order shipped" email without filing a ticket, Courier is built for exactly that handoff.

Pricing: free tier of 10,000 notifications/month, Business plan starting at $99/month, and custom enterprise pricing above that. That $99 entry sits nicely below Knock's $250 wall, which makes Courier a sane middle option for a growing team that wants more than the free tier but isn't ready for Knock money.

In practice I've found Courier shines in companies where notification content is a cross-functional asset — a product manager owns the message, design owns the look, and engineering only owns the trigger. For a pure dev team that treats notifications as code, Courier's strengths matter less and you may find the visual-first approach slightly in the way. Pick it for the org structure, not just the feature list.

SuprSend: the multi-tenant B2B specialist

SuprSend is the one I'd single out for B2B SaaS that serves other companies — where each of your customers is a tenant with its own users, its own branding, and its own notification preferences. Its data model treats "Objects" and tenants as first-class, and batching/digest plus preference management are strong. That's not a glamorous feature until you're the one building per-tenant notification settings, at which point it's the whole ballgame.

Pricing is the most graduated of the group: free tier of 10,000 notifications/month, Essentials at $79/month for 50,000 notifications, Business at $299/month (adding batching, preferences, Objects, multi-tenancy), and custom Enterprise for multi-tenant SLAs, audit trail, RBAC, and SSO. That $79 Essentials tier is the cheapest paid 50k-notification plan in this comparison — notably below both Knock's $250 and SuprSend's own Business tier.

The caveat to set expectations correctly: self-hosting is on SuprSend's roadmap but not generally available as of mid-2026. So if "we must run this inside our own infra" is a hard requirement, SuprSend isn't the answer today — Novu is. But if you're a hosted B2B SaaS that needs clean multi-tenancy without paying Knock's floor, SuprSend is the most direct fit.

Three things I learned the expensive way

These are the lessons that don't show up on pricing pages, drawn from wiring these into real client products:

1. The free tiers converge at 10,000 — the real cost is the second tier. All four offer ~10k free events/month, which is a deliberate "easy to start" trap. Your decision is never about the free tier; it's about what the jump costs. The spread there is enormous: SuprSend Essentials at $79 vs. Knock Starter at $250 for the same 50k volume. If budget is tight and you'll cross 10k, that $171/month gap is the actual decision.
2. "Self-hostable" is a binary that quietly eliminates two vendors. If a client contract requires on-prem or in-region data, your shortlist collapses to Novu, full stop — Knock and Courier are cloud-only, and SuprSend's self-host isn't shipped yet. I've seen teams burn two weeks evaluating all four before someone reads the data-residency clause. Read it first.
3. Batching is the feature that saves you from your own success. When a noisy resource generates 40 events in five minutes (think a busy chat thread or a bulk import finishing), a platform without digest/batching will fire 40 emails and your users will revolt. I learned this the hard way on an early project that mailed users on every single inventory change. All four support batching now, but the quality and ergonomics differ — test it with a realistic burst, not a single event, during your trial.

Decision matrix: pick by your actual constraint

How I'd actually run the evaluation

Don't pick from a blog post — including this one. Here's the 90-minute test I run before committing a client to any of these:

1. Wire the in-app feed first. Drop the React/Vue component into a real page. This is the highest-value feature and the fastest way to feel the SDK quality. If it fights you here, it'll fight you everywhere.
2. Build one multi-channel workflow with a fallback. "Send in-app; if unread after 10 minutes, send email." This exercises the workflow engine, delays, and channel routing in one shot.
3. Fire a burst of 30 events and see what your inbox does. This is your batching/digest test. Good infrastructure collapses them; bad infrastructure spams you.
4. Add a user preference and verify it's respected. Mute one channel and re-run. Preference enforcement is where the cheap-looking abstractions leak.
5. Model your real monthly volume against the second tier, not the free tier. Multiply your active users by notifications per user per day. That number decides the price, and the price decides the tool more often than features do.

Frequently asked questions

Do I even need notification infrastructure, or can I keep hand-rolling it?

If you only send transactional email and nothing else, a plain email API like Resend or Postmark is fine. The moment you need (a) an in-app notification feed, (b) more than one channel with fallback logic, or (c) per-user preference management, the buy decision pays for itself. Rebuilding the in-app feed alone is a two-to-three week engineering project I no longer take on by hand.

What's the difference between these and OneSignal or Firebase?

OneSignal and FCM/APNs are delivery layers — they push to devices. Novu/Knock/Courier/SuprSend are the orchestration layer above them: they decide what to send, on which channel, with what fallback and batching, and they actually use providers like FCM under the hood. You typically use both together, not one instead of the other.

Is Novu self-hosting really free?

The software is free (Apache 2.0). The operation is not. You pay in infrastructure (~$50–200/month for a reasonable deployment) and, more importantly, in engineering time for upgrades, scaling, and on-call. For most small teams, Novu Cloud or a paid competitor is cheaper once you price your own hours honestly. Self-hosting wins at high volume or under a hard compliance requirement.

Which is cheapest if I'm just over the free tier?

For 50,000 notifications/month, SuprSend's Essentials plan at $79/month is the lowest paid tier among the four, versus Courier's $99 Business plan and Knock's $250 Starter. Novu Cloud's usage-based pricing can also come in low at modest volume. The big one to avoid by accident is Knock's $250 floor if your volume is only slightly above 10k.

Do these work outside of JavaScript/Node backends?

Yes — all four are API-first with REST endpoints, so a Laravel or Python backend triggers workflows with a normal HTTP call. The richest first-party SDKs are JavaScript/TypeScript (and the in-app feed components are React/Vue), but the trigger side is language-agnostic. My Laravel projects call them over the API without issue.

The verdict

There's no universal winner here, and anyone who tells you otherwise is selling something. The decision is driven by a single dominant constraint, and once you name yours the choice is almost automatic:

• Compliance or lock-in fear → Novu.
• Best developer experience and you can afford it → Knock.
• Non-engineers own the content → Courier.
• Multi-tenant B2B SaaS, budget-aware → SuprSend.

My personal default for a new project with no special constraints is Novu Cloud — it's capable, the pricing curve is gentle, and the self-hosting escape hatch means I'm never trapped. But I've shipped products on all four philosophies, and the meta-lesson is this: stop building notification systems by hand. The undifferentiated plumbing you save is worth far more than the monthly bill, and you can always migrate later because the trigger-side code is thin. Spend your engineering hours on the thing only your product can do — not on the bell icon with the red dot.