# Knock vs BuildBase for product notifications

> Knock bills per message sent. BuildBase never meters transactional mail. That one difference decides most of this comparison, and it bites harder the better your product gets at engaging people.

- Source: https://www.buildbase.app/compare/knock-vs-buildbase
- Section: Comparisons
- Author: Dharmendra Jagodana
- Published: 2026-11-12

## In short

Knock is notification infrastructure: email, text messages, mobile push, chat and an in-app feed behind one API, billed per message sent. BuildBase folds email, web push and Slack into a backend that already does auth and billing, and never meters transactional mail. Knock reaches further; our bill stays flat.

Both free tiers say 10,000. Knock means 10,000 messages; we mean 10,000
monthly active users. A single chatty week of digests spends the first
number, and leaves the second almost untouched.

That gap is the comparison in miniature. These two products meter completely
different things, and which meter you are on decides your bill long before
any feature table does.

## The one-paragraph answer

Pick Knock if notifications are a real surface in your product and you need
to reach people wherever they are: iOS and Android push, text messages, an
in-app feed, Microsoft Teams and Discord as well as Slack. That is their
whole product and they are good at it. 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 anyway. Knock reaches further. Our bill does not
move when your engagement does.

## What each one actually is

Knock is notification infrastructure. It sits between your application and
the providers that actually deliver, so you write one workflow and Knock fans
it out to SendGrid or Postmark for email, Twilio or Telnyx for text messages,
APNs and FCM for mobile, Slack, Microsoft Teams or Discord for chat, and its
own feed for in-app. You bring the provider accounts. Knock brings the
orchestration, the per-user preference set and the templates.

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

So Knock is a layer you add. BuildBase is the thing underneath that already
had to solve auth, billing and workspaces to be useful at all.

## Pricing, verified 12 November 2026

Knock meters messages sent. The free plan is $0 and includes 10,000 messages,
500 in-app guide recipients and 500 agent credits, with 30-day log retention
and Knock branding left in place. Starter is $250 a month for
50,000 messages, 2,500 guide recipients and 2,000 agent credits. Past those
allowances it is $0.005 per message, $0.05 per guide recipient and $0.01 per
agent credit. Enterprise is negotiated, and it is the only tier where you can
ask to be billed per notified recipient instead of per message. SAML, SCIM,
i18n and a HIPAA BAA live on that tier too.

There is nothing between $0 and $250, and competitors' roundups make much of
that. They are right to. The step from a side project to a product with one
paying customer costs $250 a month on the day you take it.

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. The Free plan carries
10,000 monthly active users, 50 workspaces and 1GB of storage, with no card
and no trial, because there is nothing to trial into. The paid plans get a
7-day trial, also without a card.

> **Key takeaway:** Only three things bill over their allowance on BuildBase: workflow runs, web
> analytics events and storage. Everything else, email and web push included, is
> a hard allowance that stops rather than charges. You cannot receive a surprise
> notification bill from us. You can hit a ceiling.

## What the meter counts

This is the part worth slowing down for, because it is where the two bills
diverge and it has nothing to do with the sticker price.

Knock charges for a message sent. Every notification is billable, which means
the meter runs faster as your product gets better at engaging people. A
digest that goes to 40,000 users is 40,000 messages whether anyone opens it.

BuildBase meters marketing email only.
[Transactional](/guides/transactional-email-landing-in-spam) and system mail
is never counted and never capped - not password resets, not invites, not
billing alerts, not a workflow telling someone their export finished. The quota
exists to cap the cost of a campaign blast, not to charge for the mail your
product has to send to work.

Work it through at 250,000 transactional messages a month. Knock Starter is
$250 for the first 50,000 and $0.005 each for the remaining 200,000, which is
$1,000, for $1,250 a month. The same volume of transactional mail on
BuildBase Scale is $99 a month, because none of it is on a meter.

That is more than twelve times the bill, and it is also an unfair comparison
unless your channels fit inside ours. Which brings us to the part that matters more than
the money.

| Feature | BuildBase | Knock |
| --- | --- | --- |
| What the bill tracks | A plan. Transactional mail unmetered | Messages sent, $0.005 each past the allowance |
| Free tier | Free plan: $0, 10,000 MAU | Free: $0, 10,000 messages sent |
| Entry paid plan | $19/mo (Launch) | $250/mo (Starter), plus usage |
| Channels | Email, web push, Slack | Email, text, mobile push, chat, in-app |
| Mobile delivery | Web push only, VAPID per org | APNs and FCM |
| Scope | Notifications inside 20 modules | Notification infrastructure only |

The channels row decides more evaluations than the pricing row, and it should.

## Where Knock wins

> **Where Knock wins:**   **Mobile push.** Knock delivers to iOS and Android through APNs and FCM. We
>   do web push only. That reaches a browser and an installed web app, and
>   nothing beyond them. If your product has a native app, this comparison is
>   over at this line and the pricing never enters into it.
>
> **Text messages as a channel.** Knock routes them through your own Twilio or
> Telnyx account, so you keep the deliverability relationship with the carrier
> while they handle the orchestration sitting on top of it. We do not offer
> that channel. Email, web push and Slack is the whole outbound list here.
>
> **Chat beyond Slack.** Microsoft Teams and Discord are first-class channels
> for them. Ours is Slack alone, configured once per organization with an
> incoming webhook URL and a list of event categories you tick. If your
> customers live in Teams, that gap is the answer.
>
> **The preference model.** Knock keeps a per-user preference set covering
> channels, categories and individual workflows, with send-time preferences and
> a hosted no-code preference center they maintain. We have unsubscribe groups
> and preference centers on the email side, and an opinion about
> [which notifications a user gets to turn off](/guides/which-notifications-users-can-turn-off).
> Theirs spans every channel at once, which is the harder version of the
> problem.
>
> **Per-customer branding and i18n.** On their Enterprise tier, templates can
> carry a tenant's own branding and be translated per locale. That is a real
> feature for anyone selling a white-labelled product.

## When each one is the wrong call

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

BuildBase is the wrong call if notifications are the product surface your
users judge you on. A support tool that has to reach a technician on their
phone, or a trading app where a text message is the whole value, is not a web
push product. We would be the cheaper wrong answer.

And there is a third option people forget: run both. Our 239
[webhook events](/blog/what-are-webhooks) are signed with HMAC-SHA256 and
carry Standard Webhooks headers, so Knock can subscribe to what happens in
your product and own delivery across the channels we do not reach. Two bills,
and no gaps in either direction.

## Migrating, if you decide to

There is no import path to build. Notification history is not state you move,
it is a log you let age out, so switching is a matter of pointing triggers at
the other system and letting the old one go quiet. The work is re-authoring
templates and re-deciding the preference model, and the preference model is
the part that takes longer than anyone estimates.

Start with one workflow that matters, run both for a billing cycle, and read
the invoice before you move the rest.
