Skip to content
Comparisons
Comparison

Courier vs BuildBase, and the meter that never switches off

Courier has no subscription line. It is $0.005 a send from the first one, sitting on top of the provider bill you already pay, and it is cheaper than our top plan below roughly 20,000 sends a month.

Dharmendra Jagodana9 min read

In short

Courier is notification infrastructure with no subscription line: $0.005 per send on the Business tier, charged from the first send, on top of the SendGrid or Twilio bill you pay anyway. BuildBase is a flat plan from $19 covering email, web push and Slack inside a backend that already does auth and billing.

Courier has no floor. No subscription line, no included volume, just $0.005 a send from the first send onward, and below about 20,000 sends a month that works out cheaper than our top plan.

That is awkward for us. Three days ago we published a comparison arguing that notification infrastructure gets expensive because it meters the one thing your product is supposed to get better at, and the example was a $250 floor you pay before you have sent anything. Courier does not have one. So this post does not get to lead with the invoice, and it would be dishonest to pretend otherwise.

The other half of that argument survives. No floor also means no ceiling, and a meter that counts everything counts things you were not thinking about when you priced it.

The one-paragraph answer

Pick Courier if notifications are a surface your users judge you on and you need to reach them off the web: iOS and Android push, text messages, an embeddable in-app inbox, Microsoft Teams and WhatsApp. Pick BuildBase if your notifications are email, web push and Slack alerts, and they are one piece of a backend you have not finished building. Courier reaches further and starts cheaper. Our bill is flat, and it does not bill for your staging environment.

What each one actually is

Courier is orchestration, not delivery. You connect your own provider accounts, and the ones Courier names are SendGrid, Postmark, Amazon SES, Twilio, Firebase Cloud Messaging and APNs. Courier then owns the routing between them, the failover when one is down, the templates, the preference page and the logs. That is a real product and the $0.005 buys it. And that half a cent sits on top of what SendGrid and Twilio charge you, because Courier does not send the message, your provider does.

BuildBase is a backend sold as an SDK. Notifications are a few of its 20 modules, not the product. Email runs through Mailgun, Google, Amazon SES or your own SMTP, with templates, open and click tracking, unsubscribe groups and preference centers. Web push generates VAPID keys per organization on the first subscribe, and one server call sends email and push together to a single user or a whole workspace. Slack alerts are Block Kit messages that link back to the console record. The workflow builder wires it together with more than 100 triggers and 19 actions.

One of those is a layer you add to a stack. The other is the stack.

Pricing, verified 15 November 2026

Courier publishes three tiers and one meter. Developer is free up to 10,000 sends a month and includes the SDKs, the CLI, the MCP server and workspace login through Google or GitHub. Business is $0.005 per send. Adding a card is what moves a workspace onto it.

Read that Business line carefully, because it is unusual. There is no flat fee, which is the good part. There is also no included volume, and Courier's own billing documentation says Business charges for every send including the first 10,000. The free tier does not carry over. So the first send past 10,000 does not cost half a cent, it costs about $50, because adding the card re-prices everything you already sent that month.

BuildBase plans are Free at $0, Launch at $19, Grow at $49 and Scale at $99 a month, with yearly billed as ten months for twelve. Those four prices were last checked against the database on 31 October 2026, and the pricing page renders live from it, so treat them as a mirror rather than the source.

Key takeaway

At $0.005 a send, Courier passes our $19 Launch plan at 3,800 sends a month, Grow at 9,800 and Scale at 19,800. Only the last of those is a number anyone meets, because below 10,000 sends nobody is paying Courier anything. So the real crossover sits around 20,000 sends, and almost nobody writes it down.

What the meter counts

Courier counts one unit per template send, per recipient. What it does not count matters more. A multi-channel template is one send even when it delivers over email, text message and push separately. Fan one event out to three channels and the meter moves once. That is a genuinely better unit than per-message metering, and it is the strongest thing on Courier's pricing page.

Two other things it counts, though, and both live in the billing docs rather than on the pricing page. A send counts whether or not the provider delivers it, so bounces and blocks are billable. And sends from every environment count, including Test and custom environments.

Your CI suite, your load test and your staging smoke test all bill at the production rate. Nobody notices until the invoice arrives carrying a number nobody can attribute to a customer.

Our side meters differently, and "we do not meter" would be too convenient a way to put it. Marketing email is metered. Transactional and system mail is not counted and not capped: not password resets, not invites, not billing alerts, not a workflow telling someone their export finished. Web push is metered per device actually delivered to, rather than per user dispatched. And of every quota we run, only three bill past their allowance at all: workflow runs, web analytics events and storage. Everything else stops instead of charging.

So we have a ceiling you can hit and Courier has a bill that keeps climbing. Neither is obviously the better deal. They are different failure modes, and you should pick the one your finance team would rather explain.

FeatureBuildBaseCourier
What the bill tracksA flat plan, $19 to $99$0.005 per send, no plan fee
Free tierFree plan: $0, 10,000 MAUDeveloper: $0, 10,000 sends/mo
Included volume when payingPlan allowances that stop, not billNone. Every send billed from the first
Test and staging sendsCounted against a dev allowance, never billedBilled at the production rate
Who deliversMailgun, Google, Amazon SES or your SMTPYour own providers, billed separately
ChannelsEmail, web push, SlackEmail, text, mobile push, chat, in-app
Mobile deliveryWeb push only, VAPID per orgAPNs and Firebase Cloud Messaging
Self-hostingPriced per installation, by conversationManaged cloud only, per their docs
ScopeNotifications inside 20 modulesNotification infrastructure only

Read that table from the bottom up. Scope changes what every row above it means.

Where Courier wins

Where Courier wins

The cheap end, and it is not close. Ten thousand sends a month for nothing, then half a cent each with no plan fee. A product sending a few thousand notifications a month pays Courier zero. The smallest paid plan here is $19, and that $19 is buying a backend rather than a notification service, which is only an argument if you wanted the backend.

Channels nobody reaches from a browser. Mobile push through APNs and Firebase Cloud Messaging, text messages through your own Twilio account, chat into Microsoft Teams and WhatsApp. Our outbound list is email, web push and Slack. Web push reaches a browser, including when your app is closed, and nothing past that. If a notification has to arrive on a phone that is not currently looking at your site, this comparison ended several paragraphs ago.

The compliance answer. Courier's documentation states SOC 2 Type II, HIPAA and PCI DSS programs, a security portal holding current reports for a vendor review, a BAA on the Enterprise tier and an EU datacenter for residency. That is the paragraph a healthcare or fintech buyer's security review is looking for. Ours says AES-256 at rest and TLS 1.2+ in transit, and on uptime it says targets vary by plan with no guarantee of 100%. For that buyer those are not the same answer.

Design Studio, and the organizational question underneath it. Courier ships a visual multi-channel editor where one author writes once and sees every channel rendered, with no deploy in the loop. Their changelog, read 15 November 2026, dates experiments in Journeys to July and AI translation to June. Our templates are editable in the console in HTML, Markdown or plain text, and the workflow builder owns the triggers, but there is no single canvas a growth team can be handed.

The in-app inbox. Courier's Inbox is an embeddable in-app notification center with a real-time message list and toasts, with drop-in components for React, JavaScript, iOS, Android, React Native and Flutter, plus a hosted preference page enforced on every send. It is one of their named product pillars, which is why the comparison table above has no line for it: we could not write ours honestly, and an empty column is better than a guess.

Who owns the message

Courier assumes a notification belongs to whoever writes the copy. On our side it belongs to the code that fired the event, and most of that table, the invoice line included, is downstream of that one difference.

Design Studio, the hosted preference page, routing strategies, Journeys with their branches and digests: these exist so a growth or lifecycle team can change what a notification says, who gets it and when, without opening a pull request. Courier now describes itself as a customer messaging platform rather than a notification API, and that is not marketing drift. It is the shape of the product.

We start from the event instead, because your product code already owns it. The subscription upgraded. The workspace member was added. The credit balance went low. Those are our events before they are anybody's notification, which is why the notification is a step in a workflow sitting next to the gate that checks the plan and the webhook that tells your own systems.

Neither is better. One of them describes your team and the other does not. If your notification copy is changed by someone who does not deploy, we are the wrong shape for you whatever the bill says.

When each one is the wrong call

Courier is the wrong call if your notifications are email and a Slack alert and the rest of your backend does not exist yet. You would be paying for orchestration across channels you do not use, on top of a provider bill, and still needing auth, billing and workspaces from somewhere else.

BuildBase is the wrong call above roughly 20,000 notifications a month if notifications are all you want, and it is the wrong call at any volume if you need a phone. We would be the cheaper wrong answer, which is the most expensive kind.

Running both is the third option people forget. We emit 239 webhook events signed with HMAC-SHA256 and carrying Standard Webhooks headers, so Courier can subscribe to what happens in your product and own delivery on the channels we do not reach. Two bills, no gaps.

If you are moving

There is no import to build. Notification history is a log you let age out, not state you migrate, so the work is re-authoring templates and re-deciding the preference model. The preference model is the part that overruns, and which notifications a user gets to turn off is the decision underneath it.

Move one workflow that matters. Run both for a billing cycle. Then read the invoice, and read the line that says how many of those sends came from your test environment.

notifications
email
comparison

Frequently Asked Questions

How much does Courier cost?

Verified 15 November 2026: the Developer tier is free up to 10,000 sends a month, and Business is $0.005 per send with no platform fee. There is no included volume on Business, and the free 10,000 does not carry over, so every send is billable from the first one. Courier's own worked examples on that page put 50,000 sends at $250 and 200,000 at $1,000. Enterprise is custom, quoted by sales on volume.

Is Courier cheaper than BuildBase?

For notifications alone, below roughly 20,000 sends a month, yes. On Business at $0.005 a send, Courier passes our $19 Launch plan at 3,800 sends, our $49 Grow plan at 9,800 and our $99 Scale plan at 19,800. In practice only the last one is reachable, because under 10,000 sends nobody is paying Courier at all. Our own Free plan is $0 too, but it is counted in monthly active users rather than sends, so the two free tiers are not measuring the same thing.

Does Courier charge for notifications sent from a test environment?

Yes. Courier billing documentation, read 15 November 2026, says sends from every environment count, including Test and custom environments. A load test, a CI run and a staging smoke test bill at the same $0.005 as production. Budget for it before you wire Courier into a test suite.

Does BuildBase send text messages or mobile push?

No. Web push only, with VAPID keys generated per organization on the first subscribe. Courier reaches iOS and Android through APNs and Firebase Cloud Messaging, and routes text messages through your own Twilio account. If your product needs either, this comparison is already decided.

Try BuildBase instead of Courier

See how far you get in an afternoon. Start on the Free plan, or try a paid plan free for 7 days, no credit card.

Free plan7-day free trial on paid plansNo credit card required