We bought the hard middle and built the edges.
One of our clients runs a services app for people who live in apartment buildings. Residents use the mobile app to report problems and hear back. Property managers and admins use a web dashboard to run their buildings and send announcements.
Notifications are how those two sides talk to each other. This post covers how we built that part of the system: what it had to do, the decisions we made along the way and why, and how it fits together today.

What we needed
Four channels: push, email, SMS and an in-app feed.
Three ways to trigger them. Events (a resident files a report, or its status changes), a schedule (a daily survey reminder at 08:00) and people (an admin sending an announcement).
Choices that stick. Every resident picks their channels, and every notification has to respect that, including types we haven’t built yet.
Messages to groups: everyone, one building’s residents or one building’s staff.
A small team, with nobody whose job is running notification infrastructure.
We haven’t measured throughput or latency, so this post doesn’t make claims about either.
The decisions
Buy delivery, don’t build it
Building it ourselves meant queues and workers for each channel, provider integrations, retry rules for each provider, delivery logs, an in-app feed with live updates and a preferences engine. That’s months of work a resident never sees.
We picked Novu, a notification platform that runs the workflows and calls the providers for us: Expo for push, Amazon SES for email, Twilio for SMS, plus its own in-app inbox. Novu is open source, but we use the hosted version, Novu Cloud. The free tier covered us, and nobody on our side has to patch and run it.
The trade-off: we depend on one vendor, and there’s no backup provider per channel yet.
Keep sending and syncing apart
Novu can only reach people it knows about: their email, their phones, their channel choices, the building they live in. That information changes all the time. People move in and out, reinstall the app and switch email off.
So we split the work into two paths:
The send path is quick and simple. When something happens, our API asks Novu to send, once for each channel the user has switched on.
The sync path keeps Novu’s copy of every user up to date. It runs in the background, so a slow update never holds up a notification.
This was the most useful decision we made. Each path can fail and recover without touching the other.
Our database stays in charge
Preferences are saved in our own database (Postgres) first and then copied to Novu, never the other way round. Channels also start switched off until a user confirms their choices. We’d rather miss a notification than text someone who never agreed to it.
Make syncing reliable, not fast
A classic way to lose updates: save a change to the database, then tell a queue about it, and have the process crash in between. To avoid that, every change is written to an outbox table in the same database, as part of the same save. Once a minute, a job moves pending changes onto a RabbitMQ queue, and a worker brings Novu up to date for that user.
Two things keep this calm. Several changes to the same user in a short time collapse into one update. And a change that keeps failing is set aside after five tries and reported to Sentry, instead of retrying forever.
One queue, not one per channel
The textbook design gives each channel its own queue, so a slow SMS provider can’t hold up push. We didn’t need that, because Novu makes every provider call. Our one queue carries only sync jobs, never notifications.
We do split by channel, but inside Novu: each type of notification has a separate workflow for each channel. If the email fails, the push still goes out.
How it works

Two paths: sends go straight to Novu, and changes to users go through the outbox, queue and worker.
Something happens: a report is filed, a status changes, the daily survey job runs or an admin sends an announcement.
Our API checks which channels the user has switched on and asks Novu to send on each. An announcement goes to a Novu topic, such as one building’s residents, and Novu fans it out.
Novu delivers through Expo (push), Amazon SES (email), Twilio (SMS) and its in-app inbox.
Separately, every change to a user, a phone or a building lands in the outbox.
Once a minute those changes go onto the queue, and the sync worker updates Novu.
The in-app feed lives in Novu as well. The one thing we control there is access: the app gets a signed session from our API, so each user can read only their own feed.
What it’s like to run
Everything of ours runs in one Docker Compose stack on a single EC2 server: the API, RabbitMQ and the sync worker. Novu, Expo, SES and Twilio are managed services. Deploys run through GitHub Actions, and database changes are applied before the new version starts, so a failed migration leaves the running app alone.
There’s one worker today. If user changes ever need to reach Novu faster, we add more workers, and the queue already supports that. Notifications themselves never wait on the worker. For monitoring we use Sentry for errors, Novu’s activity log for deliveries and RabbitMQ’s dashboard for the queue.
Message templates are defined in code, so a wording change goes through code review and ships with the code that sends it. The cost is that nobody outside engineering can edit templates in Novu’s dashboard.
What we learned
Sending was the easy part. The real engineering was keeping a vendor in step with who our users are, where they live and what they agreed to.
Two paths beat one. Separating send from sync made each one simpler to reason about and to fix.
Start channels switched off. It’s easier to keep consent than to win it back.
What we’d add next: delivery status copied back from Novu, so the dashboard can show “delivered” and not just “sent”; a backup provider per channel; and production deploys defined in the repo the way staging is.
When this design fits
This setup suits a team for whom notifications support the product rather than being the product, and whose volume a vendor’s free or low tier covers. Building more yourself starts to make sense when per-message pricing hurts, when you need a channel the platform doesn’t support, or when data rules keep message content off someone else’s cloud. Self-hosting Novu sits in between. We haven’t run Knock or Courier in production, so we won’t compare them.
Related reading
The other half of a notification system is what users see. Our posts on AI chatbot UX best practices and onboarding and empty states cover the feed and inbox states. For more of our engineering posts, see our RAG pipeline architecture and Astro vs Next.js for marketing sites.
FAQ
We used neither. Our queue only carries sync jobs, never the notifications themselves, so RabbitMQ running next to the API was plenty. It gave us durable queues and a limit on retries with no extra infrastructure. If our own workers were calling every provider at high volume, we'd think harder about it.
Every send carries an ID built from what it's about: the report, its new status and the channel. If a request is retried, Novu sees the same ID and doesn't send twice. On the sync side, several changes to one user collapse into a single update.
Novu retries provider calls for us. We don't have a backup provider per channel yet, so a long SES or Twilio outage delays those messages. On our side, failed sync jobs back off and retry, then get set aside after five tries with an alert in Sentry.
We don't. Novu's inbox stores them, along with read state and live updates. We only issue each user a signed session, so they can read nothing but their own feed.
Buy when notifications support your product but aren't what you sell, and a free or cheap tier covers your volume. Build the sync layer either way, because no vendor can know your users for you.
Keep your own database as the source of truth and push changes to the vendor through an outbox. Every change to a user's channels, phones or building queues one update, and the worker rebuilds that user's full state in the vendor, so every workflow respects their choice, even ones added later.
Engineering
Building notifications into your product?
Tell us what you need to send and to whom. We'll walk you through what we'd buy and what we'd build.
We bought the hard middle and built the edges.
One of our clients runs a services app for people who live in apartment buildings. Residents use the mobile app to report problems and hear back. Property managers and admins use a web dashboard to run their buildings and send announcements.
Notifications are how those two sides talk to each other. This post covers how we built that part of the system: what it had to do, the decisions we made along the way and why, and how it fits together today.

What we needed
Four channels: push, email, SMS and an in-app feed.
Three ways to trigger them. Events (a resident files a report, or its status changes), a schedule (a daily survey reminder at 08:00) and people (an admin sending an announcement).
Choices that stick. Every resident picks their channels, and every notification has to respect that, including types we haven’t built yet.
Messages to groups: everyone, one building’s residents or one building’s staff.
A small team, with nobody whose job is running notification infrastructure.
We haven’t measured throughput or latency, so this post doesn’t make claims about either.
The decisions
Buy delivery, don’t build it
Building it ourselves meant queues and workers for each channel, provider integrations, retry rules for each provider, delivery logs, an in-app feed with live updates and a preferences engine. That’s months of work a resident never sees.
We picked Novu, a notification platform that runs the workflows and calls the providers for us: Expo for push, Amazon SES for email, Twilio for SMS, plus its own in-app inbox. Novu is open source, but we use the hosted version, Novu Cloud. The free tier covered us, and nobody on our side has to patch and run it.
The trade-off: we depend on one vendor, and there’s no backup provider per channel yet.
Keep sending and syncing apart
Novu can only reach people it knows about: their email, their phones, their channel choices, the building they live in. That information changes all the time. People move in and out, reinstall the app and switch email off.
So we split the work into two paths:
The send path is quick and simple. When something happens, our API asks Novu to send, once for each channel the user has switched on.
The sync path keeps Novu’s copy of every user up to date. It runs in the background, so a slow update never holds up a notification.
This was the most useful decision we made. Each path can fail and recover without touching the other.
Our database stays in charge
Preferences are saved in our own database (Postgres) first and then copied to Novu, never the other way round. Channels also start switched off until a user confirms their choices. We’d rather miss a notification than text someone who never agreed to it.
Make syncing reliable, not fast
A classic way to lose updates: save a change to the database, then tell a queue about it, and have the process crash in between. To avoid that, every change is written to an outbox table in the same database, as part of the same save. Once a minute, a job moves pending changes onto a RabbitMQ queue, and a worker brings Novu up to date for that user.
Two things keep this calm. Several changes to the same user in a short time collapse into one update. And a change that keeps failing is set aside after five tries and reported to Sentry, instead of retrying forever.
One queue, not one per channel
The textbook design gives each channel its own queue, so a slow SMS provider can’t hold up push. We didn’t need that, because Novu makes every provider call. Our one queue carries only sync jobs, never notifications.
We do split by channel, but inside Novu: each type of notification has a separate workflow for each channel. If the email fails, the push still goes out.
How it works

Two paths: sends go straight to Novu, and changes to users go through the outbox, queue and worker.
Something happens: a report is filed, a status changes, the daily survey job runs or an admin sends an announcement.
Our API checks which channels the user has switched on and asks Novu to send on each. An announcement goes to a Novu topic, such as one building’s residents, and Novu fans it out.
Novu delivers through Expo (push), Amazon SES (email), Twilio (SMS) and its in-app inbox.
Separately, every change to a user, a phone or a building lands in the outbox.
Once a minute those changes go onto the queue, and the sync worker updates Novu.
The in-app feed lives in Novu as well. The one thing we control there is access: the app gets a signed session from our API, so each user can read only their own feed.
What it’s like to run
Everything of ours runs in one Docker Compose stack on a single EC2 server: the API, RabbitMQ and the sync worker. Novu, Expo, SES and Twilio are managed services. Deploys run through GitHub Actions, and database changes are applied before the new version starts, so a failed migration leaves the running app alone.
There’s one worker today. If user changes ever need to reach Novu faster, we add more workers, and the queue already supports that. Notifications themselves never wait on the worker. For monitoring we use Sentry for errors, Novu’s activity log for deliveries and RabbitMQ’s dashboard for the queue.
Message templates are defined in code, so a wording change goes through code review and ships with the code that sends it. The cost is that nobody outside engineering can edit templates in Novu’s dashboard.
What we learned
Sending was the easy part. The real engineering was keeping a vendor in step with who our users are, where they live and what they agreed to.
Two paths beat one. Separating send from sync made each one simpler to reason about and to fix.
Start channels switched off. It’s easier to keep consent than to win it back.
What we’d add next: delivery status copied back from Novu, so the dashboard can show “delivered” and not just “sent”; a backup provider per channel; and production deploys defined in the repo the way staging is.
When this design fits
This setup suits a team for whom notifications support the product rather than being the product, and whose volume a vendor’s free or low tier covers. Building more yourself starts to make sense when per-message pricing hurts, when you need a channel the platform doesn’t support, or when data rules keep message content off someone else’s cloud. Self-hosting Novu sits in between. We haven’t run Knock or Courier in production, so we won’t compare them.
Related reading
The other half of a notification system is what users see. Our posts on AI chatbot UX best practices and onboarding and empty states cover the feed and inbox states. For more of our engineering posts, see our RAG pipeline architecture and Astro vs Next.js for marketing sites.
FAQ
We used neither. Our queue only carries sync jobs, never the notifications themselves, so RabbitMQ running next to the API was plenty. It gave us durable queues and a limit on retries with no extra infrastructure. If our own workers were calling every provider at high volume, we'd think harder about it.
Every send carries an ID built from what it's about: the report, its new status and the channel. If a request is retried, Novu sees the same ID and doesn't send twice. On the sync side, several changes to one user collapse into a single update.
Novu retries provider calls for us. We don't have a backup provider per channel yet, so a long SES or Twilio outage delays those messages. On our side, failed sync jobs back off and retry, then get set aside after five tries with an alert in Sentry.
We don't. Novu's inbox stores them, along with read state and live updates. We only issue each user a signed session, so they can read nothing but their own feed.
Buy when notifications support your product but aren't what you sell, and a free or cheap tier covers your volume. Build the sync layer either way, because no vendor can know your users for you.
Keep your own database as the source of truth and push changes to the vendor through an outbox. Every change to a user's channels, phones or building queues one update, and the worker rebuilds that user's full state in the vendor, so every workflow respects their choice, even ones added later.
Engineering
Building notifications into your product?
Tell us what you need to send and to whom. We'll walk you through what we'd buy and what we'd build.
