Announcing Knock

Today we're thrilled to announce the public launch of Knock's product notifications infrastructure for developers.

For the last nine months we've been working with a select group of beta customers who have upgraded their notifications with Knock. Now—after several successful deployments and millions of notifications sent to users in production—we are opening Knock up for anyone to sign up and upgrade their notifications today.

Here’s more on what we're building, why we're building it, and where we're going from here.

Why product notifications need a 3rd-party API

Ten years ago the hardest part of notifications was delivery: how to reliably get an email or a text message to a user. A group of great platform APIs—Twilio, SendGrid, Postmark—came along and solved this problem. Now that we can send a notification to any channel with a single API call, the hardest part of notifications isn’t delivery, it’s managing against over-delivery. It’s orchestrating a system that communicates with the right frequency on the right channel at the right time.

My co-founder Chris and I met at Frame.io where we lived this challenge firsthand. We saw how important notifications were to delivering customer value. They unblock workflows, they power approvals, they help users get things done without having to constantly check your app. Look at the products you use daily—Slack, Linear, Notion, Figma—they wouldn't look the same without notifications.

As we worked to deliver a great notifications experience to our customers, we became frustrated with the state of tooling available to product and engineering teams. We spoke to friends working at other companies and heard the same problems:

• Time-consuming to build. Building great product notifications is hard and takes time. Batching and digesting requires building event-based batching support (or resorting to buggy cron jobs.) In-app notification feeds and inboxes requires investing in per-user state stores and real-time infrastructure. Respecting users preferences requires support for non-working hours and factoring preferences into your notification engine. We spoke to teams that wanted to deliver a great experience for their customers to drive long-term retention, but found it hard to prioritize the work relative to the features that help win near-term sales.
• Hard to scale. Notification systems are write-heavy with a faster growth rate on low cardinality data than other types of application data. The demand on that data increases over time as you layer in complex notification functionality (such as batching and digesting) and introduce and scale cron tasks across your customer base. We heard from teams that struggled to scale their notifications while maintaining high reliability, impacting the business critical workflows that notifications drive: sign up flows, user invites, access requests.
• Not accessible to the team. In an in-house system, product notification logic and templates live in one place: your backend repo. If you’re on the product team, this makes it hard to know exactly what you’re sending to customers. Teams know they should keep an inventory of notifications and evaluate their effectiveness, but building that tooling on top of a notification system is a huge undertaking. The end result: poor visibility into the engine that drives customer engagement.

We started Knock to build the product we wish we had in our past roles.

Knock: product notification infrastructure for developers

Knock is an API and a dashboard for powering delightful product notification experiences. It helps you ship faster, iterate on your product messaging, and scale your notifications for the long-term.

Here’s what we optimized for as we built Knock.

Speed

We built Knock to help our customers deliver great notification experiences in a fraction of the time it takes to do so in-house.

With Knock you can ship a fully-featured in-app feed in under an hour with our pre-built, customizable components. Our customers use Knock to power feeds, inboxes, and task centers.

We’ve also done the legwork of channel configuration for you, even for 3rd-party apps such as Slack and Teams. This makes it easy to add new channels as you add new surfaces to your app and as your customers ask to be updated where they work.

In Knock, all of your notification logic and templating is accessible in our dashboard. Your whole team can see your product notification logic and iterate upon it.

Flexibility

Notification workflows are often very specific to the use case of a particular product. That’s why we built Knock to be a set of primitives you can use to construct the notification system you want.

We provide pre-built functions to batch and delay messages (with more functions coming soon.) Instead of having to build that logic yourself, you just focus on the role it should play in your messaging workflows.

This same flexibility is available in our preferences model. You can set preferences by channel, notification type, notification category, or any combination of the three.

import { Knock } from "@knocklabs/node";
const knock = new Knock(process.env.KNOCK_API_KEY);

const preferences = await knock.users.getPreferences(user.id);

await knock.users.setPreferences(user.id, {
  categories: {
    collaboration: {
      channel_types: {
        email: false,
        in_app: true,
        push: false,
      },
    },
    "direct-messaging": {
      channel_types: {
        email: true,
        in_app: true,
        push: false,
      },
    },
  },
});

We’ve also added support for objects to support non-user recipient use cases. Notify a Slack channel that’s mapped to a resource (and not a user) in your product or ship per-resource feeds (such as the per-page updates feed in Notion.)

Developer-first

Before we started using Knock, we spoke to a lot of teams trying to use marketing automation tools to power product notifications, with varying degrees of success. We built Knock from the ground up with one thing in mind: developers building product notifications.

Knock gives you isolated environments and a git-like versioning workflow for your product notifications. This means you’ll never be left wondering whether you’re making changes to a notification in production, and that you’ll always have a full audit log of your changes.

We’ve also invested heavily in observability. You can see through the Knock notification engine from your API request all the way to the calls we make to the downstream delivery provider. We believe you shouldn’t have to choose between using a 3rd-party service and having full observability into your notification engine.

Where we’re headed

When we first launched Knock in beta, we thought it would be useful for teams that didn’t want to build a notification system themselves. While Knock is easy to use, we’ve since realized that Knock’s real value is in making notification systems more powerful, more flexible, and more accessible in the long-term.

VendorPM uses Knock to power real-time workflows that drive responsiveness between supply and demand in their marketplace. Standard Metrics uses Knock to power in-app experiences that foster investor-founder collaboration. SuperHi uses Knock to ship new products faster by offloading a time-intensive part of getting to market: building notifications.

“Knock helped us ship a best-in-class solution to our problem in under an hour. It was mind-blowing how quickly we got it working in our product.” — Kevin Hsu, Head of Product at Standard Metrics

"Adding notifications to products is hard. Knock has been invaluable for our product development and has saved us a ton of time.” — Rik Lomas, Founder & CEO at SuperHi

"We came across Knock when we were looking to batch notifications. With Knock, we were up and running in no time. The product is intuitive, the docs are great, and the team at Knock went above and beyond to make us successful.” — Ali Rizvi, Software Engineer at Gamma

Here’s what we’re building next.

• Your notification analytics layer. View your notification analytics live within Knock (instead of via data export) and use Knock as a Segment source to bring notifications analytics into your own data warehouse.
• Richer ways to express your workflows. Today workflows are built in the Knock dashboard. Later this year you’ll be able to describe and invoke workflows directly in the API and via infrastructure-as-code providers like Terraform.
• New workflow engine inputs. Power your Knock notifications with event-data from a CDP such as Segment and bring in other data sources such as location-based data to power in-location experiences.
• User-segmentation and announcements. Send one-time messages (product announcements, surveys) over the product channels you power with Knock.

The best part about using Knock is it’s always improving. Because notifications is all we do, we can obsess over it to a degree that wouldn’t make sense for an in-house team.

You get the benefit of everything we mentioned above and everything else that’s to come—all without major code changes on your end. This helps you deliver a more thoughtful messaging experience to your users, powering customer engagement and long-term retention.

How we’ll get there

Our mission is to help software communicate with its users. We want to give every team the tools they need to power great notifications. It’s a long road and we have a great team behind us at Knock helping along the way.

Today we're announcing $2.7M in funding led by Afore Capital along with an amazing group of funds and operators, including Bri Kimmel @ WorkLife, Farooq Abbasi @ Preface, Guillermo Rauch, Scott Belsky, Adam Gross, John Kodumal, Nate Stewart, Charley Ma, and Zach Holman, to name a few.

If you're interested in trying out Knock, you can sign up for an account today. The best place to start is the docs.

You can also send us a note at [email protected] if you have questions and want to get in touch.

Knock on 🖖