NotifKit vs Knock

Knock is a cloud-hosted developer notification API billed on message volume and active users. NotifKit is a self-hosted engine on your own PostgreSQL + Redis, with no usage fees, no vendor lock-in and full operational transparency.

The short version

Knock offers a polished developer SaaS and hosted in-app notification components. As you grow, its subscription tiers and per-notification overage add up quickly, and your customer data and payloads live on their servers.

NotifKit gives teams a modern notification engine (cross-channel routing, per-user preferences, quiet hours, retries, durable multi-day workflows) without the SaaS price tag or cloud dependency.

Feature comparison

Pricing & total cost of ownership (TCO)

Knock has a free Developer tier (up to 10k messages/mo) and a Starter tier at $250/month (50,000 messages/mo included), with overage at $0.0050 per message. Provider bills (Twilio, Resend, AWS SES, APNs/FCM) come on top.

Monthly TCO by notification volume

Monthly TCO by volume, with a standard channel mix (10% Twilio SMS @ $0.0079, 70% Resend/SES Email @ $0.0001–$0.0008, 20% FCM Push @ $0):

Key differences deep-dive

1. Predictable economics without a notification tax

As products grow, notification volume climbs fast: receipts, authentication codes, mentions, digests, failed-payment recovery, security alerts. With Knock, every one adds to your monthly bill.

NotifKit removes the middleman. On Redis Streams and PostgreSQL, 100,000 notifications cost the same in software licences as 10,000,000: $0. You pay only provider rates (e.g. $0 via FCM push, or Twilio carrier fees).

2. Durable workflows that survive deploys

Both support multi-step sequences with delays, batching and conditional branching. NotifKit runs them inside your infrastructure on Redis Streams and PostgreSQL locks:

import { workflow } from "notifkit";

workflow("payment-recovery", async ({ step, event }) => {
  const { invoiceId, amount } = event;

  // Day 0: Immediate email notification
  await step.notify({
    template: "invoice-failed",
    channels: ["email"],
    data: { invoiceId, amount },
  });

  // Wait 48 hours for retry or customer update
  await step.wait("48h");

  const paid = await step.waitForEvent("invoice.paid", {
    timeout: "24h",
    match: { invoiceId },
  });

  if (!paid) {
    // Escalate to urgent SMS with fallback to push
    await step.notify({
      template: "urgent-payment-action",
      channels: ["sms", "push"],
      fallback: true,
      priority: "high",
      data: { invoiceId, amount },
    });
  }
});

If workers restart during a deploy, or a node crashes mid-way through a 48-hour wait, consumer groups and scheduled timers resume without losing state or sending duplicates.

3. Full data sovereignty & local observability

With Knock, past delivery logs and payloads are only reachable through cloud APIs or their web console.

With NotifKit, delivery events, contact statuses and dead letters live in your PostgreSQL database and Prometheus metrics. Inspect dead letters in the local dashboard, or chase silent failures with SQL or the /v1/dlq endpoint.

When to choose what