Why AI
The notification platform market splits cleanly in two. Dev-first tools — Knock, Novu, Courier — give engineers clean APIs and ship fast. Marketing waits. No-code tools — Customer.io, Braze — give Marketing canvases and journeys. Engineering pipes data in. Both are honest about the trade-off they’re making; both leave money on the table. AI doesn’t fix this by adding a feature. It fixes it by reading the developer-side primitives so Marketing can author against them — without learning to write code, and without waiting for an engineer to translate.What we believe
The point of AI in a notification platform isn’t to generate subject-line variants. It’s to generate the orchestrator — the code that decides who receives the message, what data flows in, what the channel sends. Subject-line AI is local; orchestrator AI moves work across the team boundary. The first replaces a copywriter’s first draft; the second replaces a four-week ticket loop.The status quo
Dev-first (Knock, Novu, Courier)
Pure-API platforms. Workflows are code; orchestrations are JSON or YAML; engineering ships every campaign. Marketing files tickets; engineering implements. The AI angle, when present, is “AI-suggested templates” or “AI subject-line variants” — useful but it doesn’t change who authors the campaign. What this gets right: clean primitives, good types, predictable behaviour. What it gets wrong: it assumes engineering wants to ship every campaign, and that Marketing’s role is writing tickets.No-code (Customer.io, Braze)
Visual canvas. Marketing drags blocks: trigger, filter, branch, send. The AI here is segment suggestions, copy variants, send-time optimisation. Useful but local — none of it changes the fundamental data model. Marketing still operates on what was synced into the platform; the canvas can’t reach what wasn’t. What this gets right: marketing autonomy on the things the canvas allows. What it gets wrong: marketing dependency on the canvas’s expressive power, which is always less than what code can do. Both camps’ AI is decorative — it improves what already works, doesn’t change what doesn’t.The Notifizz alternative
The AI generates the orchestrator — the code inside a campaign that runs server-side per matching event. Marketing describes the campaign in plain language. The AI reads:- The event catalog for this org. Every event your code emits has a registered shape; the AI sees what
subscription.upgradedcarries. - The enricher catalog. Every enricher you’ve registered with its input/output schemas. The AI knows
fetchUserexists and what it returns. - The campaign description Marketing wrote.
- Reads event properties.
- Calls enrichers when the campaign description implies data Marketing didn’t pass in the event.
- Builds the recipient list.
- Branches on conditions.
| Decorative AI (other platforms) | Orchestrator AI (Notifizz) |
|---|---|
| Generates copy variants | Generates the code that decides who receives the message |
| Doesn’t change who authors the campaign | Marketing authors via natural language; AI translates to code |
| Improves marginal output quality | Removes the four-week ticket loop |
| Doesn’t see your data graph | Reads your event catalog + enricher catalog |
| Marketing still depends on Engineering | Marketing depends on Engineering only when the AI flags a gap (new event, new enricher) |
The dev-task system makes this safe
The risk anyone should worry about: AI confidently produces wrong code. Notifizz’s answer is the dev-task system. Every time the AI proposes orchestrator code, the dashboard validates it:| Dev task | Triggered when |
|---|---|
| Missing event property | Orchestrator reads event.properties.foo but no event you’ve sent has that key. |
| Undefined enricher | Orchestrator calls enrichWith("notRegistered", ...). |
| Empty recipient list | Orchestrator returns [] for typical inputs. |
| Type mismatch | Orchestrator’s typed signature contradicts the event’s actual shape. |
Live. The AI proposes; Dev resolves; the platform doesn’t ship code that touches a primitive nobody acknowledged. The AI is fast and humble — it doesn’t claim authority over what it can’t verify.
Combined with campaign versioning (every save = new version, in-flight messages run against the version they started on), the safety story is: AI-generated code can ship, but only after the catalog says it makes sense, only after a human reviewer accepts the diff, and only forward — past notifications are immune to future AI proposals.
Where it doesn’t help
Be honest about the limits.- Genuinely novel logic the AI hasn’t seen. If your campaign requires a custom queueing strategy, a non-standard fanout, or business rules that don’t map to events + enrichers + recipients, the AI’s output is a starting point at best. Write it by hand.
- Cross-org generalisations. The AI is scoped to your org’s catalog. It doesn’t transfer “what worked for another customer” — by design, since that would leak.
- Brand voice in copy. Subject-line and body copy generation is opt-in but it’s a separate concern from orchestrator codegen. Some teams use it; some prefer human-authored copy with AI-generated structure.
But what about…
AI for marketing — gimmick?
AI for marketing — gimmick?
Most “AI in marketing tools” is a gimmick — subject-line variants, copy rewrites, send-time guesses. That’s surface-level personalisation. Notifizz’s AI generates the orchestrator code itself. The test for whether “AI in a marketing tool” is real: does it remove a handoff between teams, or does it just polish output one team already produces? Subject-line AI does the second. Orchestrator AI does the first.
AI touching customer data — safety?
AI touching customer data — safety?
The AI doesn’t see customer data. It sees event schemas and enricher schemas — the catalog of names and types. The actual records flow at runtime through enrichers, after the AI’s work is done. The training surface for the AI is your platform structure, not your customer database.
Will the AI hallucinate?
Will the AI hallucinate?
Hallucinating events or enrichers that don’t exist is the most likely failure mode — and it’s exactly what the dev-task system catches. The AI proposes; the dashboard verifies against the catalog; missing references become dev tasks. You can’t promote to
Live while a dev task is open. The hallucination surface is bounded to “AI proposes, fails dev-task validation, gets sent back”.Don't trust AI in production — humans in the loop?
Don't trust AI in production — humans in the loop?
Always. The AI proposes diffs; humans review and merge. The activity log records every AI proposal with the reviewer who approved or rejected it (activity log). The path is: AI authors → dev tasks check primitives → reviewer reads diff → reviewer approves → campaign promotes. The “no human” mode doesn’t exist.
Will it replace our marketing automation specialist?
Will it replace our marketing automation specialist?
No, but it changes what they do. The work of “translate Marketing’s intent into the platform’s DSL” largely disappears — that was always a translation tax. What remains is everything that requires judgement: campaign strategy, audience design, copy quality, A/B test design, performance analysis. Specialists who liked the translation work will be unhappy; specialists who liked the strategy work will get more time for it.
Other AI features I should know about?
Other AI features I should know about?
The dev-task system is itself AI-driven — it analyses orchestrator code against the catalog and proposes resolutions. Variable suggestions in templates, copy assistance for subject lines and body, send-time optimisation are scoped extensions on top. The headline feature is orchestrator codegen because that’s the one that moves work across the team boundary; the others are quality-of-life on existing surfaces.
Where to go next
Marketing autonomy
The hero pillar — AI is one of four ingredients.
Why whole team
The platform setup that lets the AI see enough.
Orchestrator concept
Where the AI’s output runs.
Activity log
Audit trail of AI proposals + human reviews.