Clipboard sends roughly 46 million notifications per month to help workplaces fill shifts. When a shift opens, a credential is about to expire, or a workplace needs coverage, Clipboard's customers rely on these notifications to arrive on time.
Clipboard's engineering and support teams are responsible for ensuring these important notifications deliver. However, when notifications failed, the team's existing messaging platform, Braze, was too slow and opaque to properly trace why it failed.
This led the team to look for a platform with better observability. They found Knock, and before long, two engineers on Clipboard's Platform team began the company-wide migration from Braze to Knock.
- Clipboard needed better visibility. Beyond an "accepted" status, they needed provider responses, lifecycle timelines, and a way for support to answer delivery questions without paging engineering.
- Knock came with the transactional primitives Clipboard had been building and maintaining on top of Braze, including delivery logs with downstream provider responses, cross-channel preferences, idempotency, batching/digests, and environment versioning.
- The Platform team made the migration easy for other teams (shared notification client, audit tooling, pre-created workflows, AI-assisted tickets).
- Results: Braze decommissioned in Aug 2026, 35,000+ lines of code removed, SMS migrated in a single cutover, centralized templates that made a mid-migration rebrand easy, and a self-serve path to debugging notifications and preferences.
About Clipboard
Clipboard helps workplaces fill shifts and helps workers find flexible work. Notifications are how they hear about urgent shifts, cancellations, and expiring credentials. At Clipboard's volume, small delivery failures add up fast. A missed text can mean a worker loses pay or a workplace goes understaffed.
Why Clipboard left Braze
Clipboard's Platform team builds the foundation that the rest of the engineering team ships on. Notifications are one of the largest systems they own: tens of millions of push notifications and millions of emails and SMS each month, most of them transactional and time-sensitive.
One question came up again and again:
Why didn't this message reach this user?
With Braze, answering it took too long. Engineers had to dig through application logs and data exports because the Braze dashboard didn't clearly show provider errors. Braze also lacked key transactional primitives like preference management, idempotency, batching, and digests, so Clipboard had no choice but to build and maintain these themselves.
Why Clipboard chose Knock
After evaluating several platforms, Clipboard's engineering team chose Knock.
Here's what stood out:
- Detailed delivery logs with downstream provider responses.
- Preference management across email, SMS, and push notifications.
- Built-in idempotency, batching, and digests.
- Git-style versioning, with changes promoted across environments.
- Tooling to eventually move all teams onto one messaging system.
In short: Knock offered better observability and flexibility than Braze, across transactional and lifecycle messaging.
How two engineers led an org-wide migration
Stefan Chrobot and Rocky Warren from the Platform team led the migration. They had two goals: no disruption to customer notifications, and as little disruption as possible to other internal teams.
Foundations before tickets
Before asking teams to migrate, they built:
- An internal audit CLI that pulls Knock content, checks naming, template variables, ownership, and best practices, and posts owner-grouped findings to Slack.
- A shared notification client wrapping the Knock SDK, with structured logging, tracing, metrics, redaction, stable idempotency keys, expiry checks, recipient chunking, and test helpers.
- Infrastructure for user sync, E.164 phone formatting, email/SMS providers, preference bridging, push tokens, feature flags, and non-production sandboxes.
They migrated the first notifications themselves, then reshaped the client API so callers only supply what's unique to each use case.
Automating inventory and migration prep
Clipboard had years of Braze campaigns and canvases, plus a few older paths that sent directly through Amazon SES and Twilio, so the first job was figuring out what actually needed to move.
The Platform team built tooling to automatically separate live workflows from delete candidates, then automated Braze to Knock workflow creation, which included cleanup, naming, HTML to Markdown, ownership tags, and more.
Engineering-wide launch
Clipboard announced a shared goal: migrate worker notifications in Q1 2026 (workplace user notifications followed in Q2) and put Braze into a conceptual read-only mode, so teams had to build any new notifications in Knock.
Teams were instructed to review their workflows, which were pre-created in Knock and came with a clear client pattern, rollout instructions, and an AI coding prompt to replace the Braze call behind a feature flag.
We made sure to make the change easy for the teams and then asked them to make the easy change: the workflow was already there, the notification client was straightforward, the rollout flag was in place, and the tickets with the AI prompt were open and assigned.
As the initiative progressed, the Platform team solved edge cases and posted progress in Slack. Some teams used the migration to cut notifications they no longer needed. Others finished workplace tickets early.
A company-wide rebrand landed mid-migration. Because content now lived in centralized, version-controlled Knock templates, the team updated notifications in one place instead of hunting through campaigns and hardcoded HTML.
SMS big-bang, then zero Braze
SMS notifications couldn't move one at a time because Braze owned the short code, and dual-writing would split customer threads. As a result, Clipboard used a global feature flag, dry-ran Knock requests while Braze still sent, then flipped production in one cutover. The switch was uneventful, as intended.
Once the team cleaned up the last flags pointing at Braze, all of Clipboard's messaging ran on Knock. Today, Engineering sends all transactional notifications through Knock workflows, Operations runs recurring campaigns with Knock broadcasts, and Product uses Knock guides for in-app surveys.
What changed with Knock
The original goal was simple: when a notification doesn't arrive, find out why.
With Knock, a failed Android push, for example, shows a full timeline (created, queued, attempted), an Undelivered status, Google's 403 / SENDER_ID_MISMATCH, and confirmation that Knock won't retry it. That's enough for an engineer to quickly fix the root cause.
They also left the migration with less code, fewer notifications, and stronger messaging hygiene. Tooling now enforces best practices and centralized templates, so errors are rarer and get fixed faster.
We also gained a great partner: the Knock team has been responsive throughout, shipping fixes and improvements faster than we expected from a vendor.
Clipboard now runs all customer messaging on one system, and any team can answer delivery questions without paging engineering.
What's next
With Braze behind them, Clipboard is building the next layer of their messaging experience on Knock. This includes:
- A notification center so workers and workplaces can catch up on what they missed.
- Richer in-app messaging for relevant nudges inside their product
- Per-tenant, fine-grained preferences so each workplace and worker controls which notifications reach them.
If your team is stuck debugging notifications or maintaining messaging infrastructure in-house, give Knock a try.
Sign up for a free account or chat with our team today.
This case study is adapted from Clipboard's engineering post: How two engineers ran Clipboard's notification migration from Braze to Knock by Stefan Chrobot.