Introduction
In this article, I'll expose an issue we had in one of my freelance missions, what we learned from it and how it started our journey towards building our own system.
Disclaimer: I am one of the co-founders of Notifizz, a unified notification platform that leverages AI to give marketing teams autonomy in handling their notifications.
The problem
Our architecture was composed of several microservices. One of them was handling the notifications: receiving requests and calling whatever third party service was responsible for sending a message.
Marketing teams designed notifications to achieve certain goals: alerting a customer of a new invoice, reminding him of an important task, informing about a new functionality... Each notification exists , or should exist, to achieve a business goal.
Obviously, there is no guarantee that a notification will allow the company to achieve whatever goal they set right away. You track an objective related to a notification, and you see if users do the action you intended them to do from that notification.
What if it doesn't work? Or doesn't work well enough? Marketing might want to make a few changes. Adjust the wording. Perhaps send the notification at a different moment in the process. Or maybe send an email AND an in-app message...
And that's the first hurdle. For every change, marketing needs to either have a little bit of experience with certain tools (we used mailgun for example, which isn't the most straightforward piece of technology for non-devs) or send a ticket to the dev team to implement the changes. The marketing team is completely dependent on the dev team. It loses time and possibly keeps a suboptimal campaign live while the dev team finds the time to do the changes and push it to prod.
A solution?
So we thought (back in 2023), what if the marketing team had complete control over their campaigns? What if they were completely independent from the dev team? How would that look like?
You still need developers in the loop, obviously. But we thought that we could create everything we needed in our application beforehand (events, endpoints...) like building blocks, and let the marketing team construct their campaigns like this.
Our application would emit events. For instance, a new invoice is created -> event invoice.created, emitted from the microservice responsible for invoicing. That microservice would publish this event and its payload to a pub/sub topic.
So far, so good. But now you need an interface right? Because marketing wants to create a campaign to alert clients about the invoice. And the marketing team doesn't know anything about code, or what's an API or a microservice... And they need something flexible so that they add a new field if necessary, or update the wording...
So we thought about adding Make. Make lets you create scenarios and chain modules in a sequence. It takes an input (in our case, it would take our pub/sub' subscription) and you can chain different modules to manipulate data.
And because you can create custom modules in Make, we created modules that allowed us to call our API, so we could enrich the original event payload input with data from some of our other microservices. That way, we thought, even if marketing is missing a field, they will use one of our pre-designed modules and add it themselves, without the devs! Genius!
Right? Input's data -> call one or several modules to enrich -> call our notification microservice to send the notification.
Well, it was a disaster.
Why it didn't work
First, the payload you get from the event is a JSON, and it needs to be parsed for the Make scenario to know it and manipulate it. So right off the bat, you're adding a JSON concept into a process that's supposed to be developers free.
Second, if you call our API, you need to think about security. So you need to pass a token, or an api key or something from Make to make sure your data is not being called from anyone. Another concept that's not marketing friendly.
Third, you actually need a lot of JSON manipulating in that use case inside Make. Too much for a non technical person to use. The whole point was to make sure you didn't need to be a developer to use that process.
A "simple" scenario could look like this

Fourth, the variety of tools used complicated things. Because everything was spread out across different tools (templates were in Mailgun, the team used Intercom, Mailchimp, plus Make ...), it was impossible to teach the marketing team to be fully autonomous in the process. It would have been way too costly to train them on these tools to handle everything like we expected. It wasn't their job anyway.
Fifth, we also needed to handle different environments. Obviously, you don't send your notifications to production right off the bat. You need to test them locally, then test them in a deployed environment then finally you push it to production. In our case, we needed to have a different scenario for each environment (different pub/sub subscription/topic, different modules).
What we learned
Lack of control
No-code, at least in 2023 the way we used it became a growing problem saying: You need to adapt everything to us and our way of things, not the other way around. And it became clear that the level of complexity would be way too expensive to implement and maintain with the available tools in order to achieve the marketing autonomy goals we had.
The expertise needed
You can't remove developers entirely from that loop. At one point or another, you need a developer to implement some code (an endpoint to enrich, a new event, a new field in an existing event ...). So the problem became more of: how do we clearly separate dev tasks from marketing tasks so that each team does what it's good at, without making each other lose too much time?
To do that, we think, we need to have a centralized interface where everything was easier to follow and monitor. In one place, designing your email, in-app or intercom messages, track deliverability, events and their payloads and where in the development process is the campaign.
Lack of visibility
Marketing teams have very little visibility on the number of notifications that are being sent throughout the application and in other marketing campaigns. We realized that our marketing team knew quite well about the actions they took to bring in new clients but very little about the users inside the app. And that was mostly due to the fact that there were a lot of different tools involved. The development team became, de facto, responsible for a lot of notifications inside the app, from designing, to wording, to tracking its effects.
Conclusion
This is what started our journey into building Notifizz. There is no doubt that what we did at the time was not perfect. Decisions were taken that could have been better. Technical choices that could have been wrong. In the end, the system worked, but couldn't work for the audience we had in mind. But it opened new doors, with the idea that maybe we could do better by building our own product.
Top comments (8)
Good write-up. A useful boundary for this kind of self-service is letting marketing edit copy and timing while keeping event schemas, credentials, retries, and environment selection in prebuilt, validated blocks. A sandbox plus a preview of the final payload can catch a lot before production. Which part of that separation helped most when you built Notifizz?
Thanks! Prebuilt blocks were basically our Make setup: custom modules built ahead of time. It didn't work as expected in the end because we could never predict every field a campaign would end up needing.
What helped most with Notifizz was flipping it around: marketing builds the whole campaign, and anything missing (an event property, an enricher to fetch data) becomes a task the devs pick up. The boundary gets drawn per campaign instead of upfront. Meaning that at some point, once the events are all created and the enrichers available, marketing doesn't need a developer in the loop anymore.
And yes on the sandbox: until a campaign is live in production, only verified test addresses receive anything, so the team can test with real events safely.
That per-campaign boundary is a useful lesson. Letting marketing assemble the campaign while developers add only the missing events or enrichers sounds more flexible than trying to predict every field in advance. The verified-address sandbox also gives the team a way to test the real event path before launch. Thanks for sharing the details.
Offloading notification pipelines to visual orchestrators like Make hides retry amplification, rate-limit cascading, and dead-letter state behind opaque execution quotas until burst traffic hits. Once fan-out latency spikes or downstream webhooks throttle, you end up rebuilding idempotency keys and backoff queues outside the platform anyway. Glue code still owns reliability.
Agreed, and that’s pretty much the route we took with Notifizz: the reliability work doesn’t go away, so it might as well live in one place you own instead of being spread across scenarios.
We ran into it ourselves: a replayed job could create a second notification for the same user and the same step. Now both creation and sending are keyed on a deterministic id, claimed atomically before anything goes out. If a send crashes between the provider call and its confirmation, we skip it rather than retry: for notifications, a duplicate felt worse than a rare miss.
Retries are bounded with exponential backoff, failed jobs are kept briefly for diagnosis, and calls to the customer’s own endpoints (to fetch data at send time) are time-boxed and cached.
I’m writing a follow-up on exactly this: what gets complicated after the MVP.
invoice.created doing the honest work while make ate the rest of the budget is a funny split. what replaced it in the end, a queue or a small service of your own?
Haha that's so right!
Well, it the end, because the whole thing ended up working anyway, it never became a priority to fix or improve. And like so many good dev stories, it's now this blob that we have to maintain. But I'm not giving up on replacing this mess at some point 😅
a blob that works is hard to argue with. it only gets replaced the day it breaks.