How Meteroid Helped Us Build Hostly Faster
When we started building Hostly, one of the things we tried to be careful about was where we spent our engineering time.
There are plenty of parts of a SaaS product that you can build yourself, but that does not necessarily mean you should. Billing turned out to be a good example of that.
Billing became complicated quite quickly
Hostly is usage-based, because the underlying infrastructure is usage-based as well.
We meter CPU, memory, storage and network traffic independently, and wanted our pricing to reflect that rather than forcing users into fixed resource bundles.
At the same time, each plan has a minimum monthly commitment. That minimum can be covered by any combination of the resources a customer uses.
The basic idea is simple enough, but implementing it properly is not just about adding up a few numbers. You also need subscriptions, invoices, payment handling, entitlements, checkout flows and some way for customers to manage all of this themselves.
We initially started writing parts of that logic ourselves.
“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
[Image: Hostly pricing or usage overview]
Why we chose Meteroid
There are a lot of good tools for subscription billing, but our pricing model narrowed the field quite a bit.
What we liked about Meteroid was that usage-based billing did not feel like an extra feature added on top of a subscription system. Metering, pricing and entitlements were already part of the core model, which was much closer to what we needed.
Meteroid supported commitments for individual metrics, while Hostly needed one minimum commitment across the entire plan. A customer might satisfy that minimum mostly through compute, mostly through storage, or through a mix of several resources.
Rather than working around that limitation, we discussed the model with the Meteroid team. They proposed adding a floor price at plan level while keeping the individual components independently metered, which matched what we were trying to achieve.
They managed to get this (for us) crucial feature shipped within weeks for us to try out.
“What we appreciated most was that we could talk about the actual pricing model instead of trying to reshape it around the billing software.”
[Image: CPU + Memory + Storage + Egress → shared monthly minimum]
One less system to build
Meteroid now covers a large part of the billing side of Hostly, including metering, pricing, subscriptions, checkout, entitlements and the customer portal.
That saved us quite a bit of development time, but the larger benefit is probably the code we do not have to own going forward.
Billing has a lot of edge cases, and very few of them are specific to what makes Hostly useful. We would rather spend that time on deployment, infrastructure and the overall experience of getting an application online.
In that sense, using Meteroid fits quite well with how we are building Hostly in general: build the parts where we have something specific to add, and use existing tools where someone has already solved the problem well.
For us, billing was one of those cases.
