r/Akka • u/Material_Big9505 • 16h ago
I Built an Open-Source Contextual Ad Network with Scala & Apache Pekko Cluster(and Go)
An open-source ad network that targets content, not people.
Promovolve is an attempt to get back what magazine advertising had: relevant ads matched to what the reader is actually reading, with no cookies, no user profiles, no cross-site tracking, and no degradation of the reading experience. The page’s content is the only targeting signal. An article about hiking gets ads for hiking gear because of what it is, not because of who is reading it.
Being open source is not incidental: transparency is the product. Publishers and advertisers can inspect the auction, pricing, and pacing logic themselves and verify there is no hidden manipulation, something no closed ad network can offer.
Under the hood, the core API and distributed auction platform are built with Scala and Apache Pekko Cluster, providing a resilient, stateful distributed runtime for serving and budget management. The project also includes Kubernetes deployment manifests, making it straightforward to run in a clustered environment or adapt it to your own infrastructure.
Although Go is used for the BFF, the core platform is entirely built with Apache Pekko Cluster and written in Scala. The reason Go sits in front of the Pekko Cluster is pragmatic.
Go has an excellent ecosystem for HTTP servers, authentication, and user management. Those concerns are largely domain-independent and can evolve separately from the core advertising platform.
The core Ad API, on the other hand, is where the domain complexity lives: auctions, pacing, serving, campaign state, and distributed coordination. That’s where Apache Pekko Cluster shines, so I kept that entire layer in Scala.
The split isn’t because Pekko can’t handle HTTP. It’s because the HTTP-facing user management layer and the distributed advertising engine have very different concerns, and separating them keeps the core platform focused on the domain.
These days it’s common to build a microservice platform by combining a long list of technologies. I wanted to challenge that assumption and show that it isn’t always necessary. My goal was to keep the core platform inside Apache Pekko Cluster and see how far that architecture could go.
If Scala isn’t your thing, you can build the same architecture in Java using Apache Pekko.
https://github.com/promovolve/promovolve
My assumption is that as AI changes how people discover information, many casual searches will be answered directly by LLMs rather than leading users to websites.
The people who still choose to visit a page rather than just ask an LLM are making an intentional decision. That makes those visitors much more valuable to advertisers. If publishers continue to treat that audience as inventory to be maximized at all costs, they risk damaging one of their most valuable assets: the trust of readers who actively choose to be there.
With Promovolve, the creative is generated from what the landing page is actually trying to communicate, while remaining fully editable by the advertiser.
Instead of optimizing a banner purely to get the click, the ad is designed as the beginning of a three-page narrative that naturally leads into the landing page. The message before and after the click stays consistent.
Publishers review the advertiser, the creative, and the landing page. Only approved campaigns are eligible for delivery. The goal is to treat ads as part of the publisher’s editorial experience, not just as inventory to fill.
