NotifKit vs Knock

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

The short version

Knock provides a polished developer-facing SaaS experience and hosted in-app notification components. However, as your application grows, Knock’s monthly subscription tiers and per-notification overage charges accumulate quickly, while your customer data and notification payloads reside on their servers.

NotifKit is designed for teams who want the power of a modern notification engine—cross-channel routing, per-user preferences, quiet hours, retries, and durable multi-day workflows—without the SaaS price tag or cloud dependency.

Feature comparison

Pricing & total cost of ownership (TCO)

Knock offers a free Developer tier (up to 10k messages/mo), and a Starter tier at $250/month (including 50,000 messages/mo). Additional volume is billed at $0.0050 per message overage. In addition, Knock users still pay direct provider delivery bills to Twilio, Resend, AWS SES, and APNs/FCM.

Monthly TCO by notification volume

The table below models total monthly TCO across notification scales, including standard multi-channel deliverability (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 modern products grow, notification volume scales exponentially: transactional receipts, authentication codes, comment mentions, digests, failed-payment recovery, and security alerts. With Knock, every notification adds to your monthly SaaS bill.

NotifKit removes the middleman toll. Because it runs on lightweight Redis Streams and PostgreSQL, delivering 100,000 notifications costs the exact same in software licenses as delivering 10,000,000: $0. You only pay direct provider rates (e.g. $0 via FCM push or direct Twilio carrier fees).

2. Durable workflows that survive deploys

Both Knock and NotifKit support multi-step sequences with delays, batching, and conditional branching. However, NotifKit executes workflows directly inside your infrastructure using 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 your workers restart during a deploy or a node crashes midway through a 48-hour wait, NotifKit's consumer groups and scheduled timers resume execution without dropping state or sending duplicate alerts.

3. Full data sovereignty & local observability

With Knock, querying past delivery logs or inspecting payload contents requires calling cloud APIs or browsing their web console.

With NotifKit, all delivery events, contact statuses, and dead letters live in your PostgreSQL database and Prometheus metrics stream. You can inspect dead letters via the local dashboard or resolve silent failures directly through SQL or the /v1/dlq endpoint.

When to choose what