Novu

Novu is an open-source notification and agent communication infrastructure built for developers who need to reach users across every channel without stitching together a patchwork of provider-specific SDKs and webhook handlers. It provides a single unified API and a consistent conversation model that works whether you’re sending a transactional email, triggering a push alert, or routing an AI agent’s reply through Slack and back.

The platform covers two major use patterns. For product teams, Novu delivers a full notification stack: an embeddable real-time Inbox component, a visual no-code email editor, a digest engine that batches multiple events into a single message, a user preferences component, and a workflow orchestration engine for defining multi-step, multi-channel notification sequences — all wired to 70+ pre-built provider integrations for email, SMS, push, and chat.

For teams building AI agents, Novu offers its Agent Communication Infrastructure (ACI) — a bidirectional messaging layer that normalizes inbound messages from Slack, Microsoft Teams, Telegram, WhatsApp, and Email into a single conversation model, routes them to your agent, then delivers the agent’s response back out. You integrate once rather than maintaining a separate webhook handler per platform, and your agent logic stays completely portable.

Novu is open-core: the notification infrastructure is MIT-licensed, while enterprise features — advanced RBAC, SSO, audit logs, and compliance tooling — live in a separately licensed enterprise directory. The platform is actively maintained by a full-time engineering team and ships releases on a roughly biweekly cadence across its core API, SDK packages, and React/React Native components.

What You Get

• Embeddable Inbox Component - Drop a real-time notification center into any React or Next.js app with six lines of code via @novu/react or @novu/nextjs, with built-in support for archiving, unread filtering, snooze, and search.
• Unified Multi-Channel Notification API - Trigger notifications across In-App, Email, SMS, Push, and Chat through a single API call without writing channel-specific logic or managing separate provider clients.
• Digest Engine - Batch multiple events that fire within a configurable window into a single consolidated message, reducing notification noise without requiring custom aggregation logic.
• No-Code Block Email Editor - Design responsive, dynamic transactional emails visually using the Maily-based block editor — no HTML table authoring or raw template syntax required.
• User Preferences Component - Embed a ready-made preferences UI that lets each subscriber control which channels they receive notifications on and set snooze windows, without building that UI yourself.
• Workflow Orchestration Engine - Define multi-step notification workflows in code via @novu/framework with branching conditions, delays, and per-channel fallbacks, then sync them to the dashboard without redeployment.
• Agent Communication Infrastructure (ACI) - Connect any AI agent you’ve built to Slack, Teams, Telegram, WhatsApp, and Email through a unified conversation model that normalizes inbound messages, routes them to your agent, and delivers replies back out — one integration instead of one per platform.
• 70+ Provider Integrations - Pre-built connectors for 19 email providers (SendGrid, SES, Resend, Postmark), 37 SMS providers (Twilio, Vonage, Infobip), push providers (FCM, APNS, OneSignal), and chat platforms including Slack, Discord, MS Teams, Telegram, and WhatsApp.

Common Use Cases

• Building a SaaS notification center - A B2B product team embeds the @novu/react Inbox component in their dashboard, configures Slack and email workflows via the visual editor, and lets users adjust preferences — all without building any notification UI or infrastructure from scratch.
• Sending transactional emails at scale - An e-commerce team uses the Novu block editor and Resend/SES provider to send order confirmations, shipping updates, and password resets with dynamic variables, skipping SMTP server management entirely.
• Connecting an AI agent to real communication channels - A team deploys a Claude-based agent and uses Novu ACI to receive Slack messages, route them to the agent, and deliver replies back to the same Slack thread — handling threading, formatting, and reactions automatically.
• Managing multi-channel security alerts - A fintech platform uses Novu’s workflow engine to send SMS OTPs via Twilio, push alerts via FCM for mobile devices, and Slack messages for admin notifications — all from a single trigger with per-channel fallback logic.
• Digesting high-volume activity notifications - A project management tool uses Novu’s digest engine to batch per-comment or per-mention events into a single daily summary email per user, avoiding notification fatigue without writing custom aggregation code.

Under The Hood

Architecture Novu’s backend is structured as a Nx-managed monorepo with distinct application boundaries across an API service, background worker, WebSocket server, inbound mail handler, and webhook processor — each deployed independently. The API service follows a feature-module pattern built on NestJS, with each domain (events, workflows, subscribers, inbox, agents) encapsulated in its own module containing controllers, use-case classes, and DTOs. Core notification delivery is event-driven: HTTP triggers enqueue jobs onto BullMQ queues processed by the worker service, decoupling API latency from delivery throughput. The newer Agent Communication Infrastructure introduces a conversation runtime layer that normalizes inbound messages from Slack, Teams, Telegram, WhatsApp, and Email into a unified AgentConversation model before routing them to registered agent handlers, then delivers replies back through channel-aware adapters — an architectural pattern distinct from the outbound-only notification flow.

Tech Stack The backend runs on Node.js 22 with NestJS and Express, using MongoDB as the primary operational store and PostgreSQL accessed via Prisma for workflow definitions and structured data. ClickHouse handles analytics and delivery telemetry. BullMQ over Redis drives asynchronous job processing across the worker and WebSocket services. The embeddable client SDK (@novu/js) is a plain TypeScript module that opens a WebSocket connection using a provider-agnostic socket abstraction, keeping the inbox component framework-agnostic at its core. React and React Native wrappers are layered on top. The @novu/framework package lets developers define workflows as typed TypeScript functions that are served as HTTP endpoints and synced to the Novu cloud or self-hosted API. Biome handles linting, formatting, and import validation across the entire monorepo in a single pass.

Code Quality The codebase demonstrates strong typing discipline throughout, with TypeScript strict mode enabled and dedicated DTO classes with class-validator decorators for every API boundary. Test coverage is extensive at the unit and integration levels — the API service alone has over a hundred spec files alongside end-to-end tests covering controller flows. The chat adapter package includes thorough integration specs with HTTP mocking and snapshot-based assertion to guard against regressions in the ACI normalization layer. Biome enforces consistent import ordering and formatting without per-file configuration drift. Error handling follows NestJS conventions with typed exception classes and a global exception filter that maps domain errors to HTTP status codes consistently, though some legacy modules retain earlier patterns.

What Makes It Unique Novu’s most architecturally distinctive contribution in its current form is the Agent Communication Infrastructure — a bidirectional messaging abstraction that normalizes the wildly divergent webhook formats, threading models, and reply semantics of Slack, Teams, Telegram, WhatsApp, and Email into a single AgentConversation interface. This lets an AI agent integrate once and communicate across all those channels without platform-specific handling. The @novu/framework package’s code-first workflow model is also notable: workflows are plain TypeScript functions with typed step definitions, served as HTTP endpoints that Novu’s engine calls during execution, enabling full programmatic control — branching, delays, variable hydration — without a YAML DSL or GUI-only configuration. Together these make Novu viable not just as a notification delivery layer but as a communication substrate for agent-native product architectures.

Self-Hosting

Novu uses an open-core licensing model. The core notification infrastructure — including the API, worker, WebSocket server, embeddable Inbox component, multi-channel provider integrations, workflow engine, and Agent Communication Infrastructure — is licensed under the MIT License, which permits unrestricted commercial use, modification, and redistribution. The enterprise directory at the root of the repository, as well as enterprise-specific subdirectories within the dashboard application, are covered by Novu’s proprietary Enterprise Edition license. This license does not permit redistribution, commercial hosting for third parties, or modification without prior written approval from Novu Corporation. Enterprise features include advanced RBAC, SSO integrations, audit logging, and compliance-oriented tooling — none of which are required to run the self-hosted platform at typical scale.

Running Novu yourself is operationally non-trivial. A complete self-hosted deployment requires MongoDB for the operational data store, PostgreSQL (or MySQL) for workflow definitions, Redis for BullMQ job queuing and caching, ClickHouse for analytics and delivery telemetry, and S3-compatible object storage for attachments. The Docker Compose configuration included in the repository manages these dependencies for local development, and a Kubernetes Helm chart is provided for production deployments. You are fully responsible for availability, backup, version upgrades, and horizontal scaling of every component — the monorepo’s microservice structure means you run and monitor six or more discrete services in production. Teams without dedicated infrastructure experience should factor in meaningful operational overhead.

Compared to Novu’s managed cloud offering, self-hosting gives up automatic upgrades, managed backups, SLA guarantees, and the support tier that comes with commercial plans. The cloud tier also includes hosted EU data residency, which self-hosting can replicate geographically but requires deliberate configuration. Enterprise features — SSO, advanced RBAC, audit logs — require a separate commercial agreement regardless of whether you run self-hosted or cloud. For teams whose primary requirement is control over where data is stored, self-hosting is fully viable; for teams that want enterprise compliance features alongside that control, a conversation with Novu’s commercial team is necessary.