Every infrastructure startup eventually hits the same wall: the product is ready, the pricing model makes sense on a whiteboard and then someone has to actually build the billing logic. For Hostly, that wall showed up earlier than expected.
Who is Hostly
Hostly is a German startup that lets developers deploy and run Docker images without managing servers, Kubernetes, or infrastructure configuration. It lets developers deploy a Docker image to a public subdomain in minutes. It’s infrastructure for Devs who want to ship, not manage Kubernetes clusters. That simplicity is the whole pitch, and it had to extend to how customers get billed.
The challenge: a pricing model too complex to hand-roll
Hostly’s pricing is deliberately simple for customers: CPU, memory, storage, and egress, each priced independently. Implementing that simplicity correctly behind the scenes, however, required fairly sophisticated billing logic. Every customer also commits to a minimum monthly spend, a single “floor” that could be covered by any combination of those four metrics.
But because Hostly is self-serve by design, “billing” really meant a full monetization engine: entitlements to enforce what each plan actually allows in real time, a checkout flow to turn a signup into a paying customer without any manual steps, and a customer portal where users could manage their own subscription, payment details, and invoices without ever contacting support.
Like many teams before them, Hostly’s first instinct was to build this themselves. It didn’t take long to realize how deep that rabbit hole goes. As co-founder Michael Zigldrum put it after evaluating the alternatives:
“We actually started to write our own billing logic, but then realized, there must be someone that already did this. Turns out: for metered billing, only Meteroid has a good concept in our opinion.”
Michael Zigldrum, co-founder of Hostly
Building the missing piece, together
There was one gap: Meteroid’s commitment/capacity model supported a minimum spend on a single metric, not a floor shared across several. For Hostly, that was the whole model, a customer needed to be able to satisfy their 9€ monthly minimum through any mix of compute, memory, storage, or egress.
Rather than treat this as a dead end, it became a scoping conversation. Meteroid proposed a solution, a floor price set at the plan level, sitting on top of independently priced components, and the two teams agreed on a delivery date and Meteroid shipped accordingly.
The result
Hostly is now moving to Meteroid, with a full monetization stack running turnkey behind the scenes — metering, entitlements, checkout, and customer portal — built around a pricing model that reflects exactly how its infrastructure is consumed. None of it required custom billing code maintained in-house, which means Hostly’s team spends its time on the product, not on reinventing subscription and payment plumbing. It’s the kind of outcome we built Meteroid for: teams shouldn’t have to choose between a pricing model that fits their business and the sanity of not maintaining their own monetization engine.
Building a usage-based pricing model with multiple metrics and commitment tiers? Talk to us