How do you actually get paid when every customer runs their own instance?

I’ve been working through a simple question while building DeBOS:

How do you actually get paid when every customer runs their own instance?

This matters more than it sounds — because if we don’t solve this cleanly, decentralized apps never really go mainstream.

Most SaaS apps tie billing to users or accounts. If someone doesn’t pay, they get locked out. That works in a centralized world, but it doesn’t translate well when each customer is running their own system.

So I went a different route.

When I send an invoice, I generate a payment link using ArcBlock’s Payment Kit and attach the instance ID directly in the metadata. When the payment goes through, a webhook fires and hits my control plane.

From there, it updates automatically.

No matching emails. No chasing payments. No guessing who paid. The system already knows exactly which instance it belongs to.

Each instance checks in with a heartbeat and pulls its current status. If it’s paid, nothing changes. If it’s not, it drops into read-only mode.

Not locked out. Not broken. Just restricted.

And that part matters.

Real businesses don’t just stop because billing hiccups. They still need access to their data. They still need to run. So instead of killing the app, DeBOS just prevents new writes until things are handled.

Why This Matters for Devs

This isn’t just about DeBOS — it’s about a cleaner way for developers to get paid.

No seat pricing. No user-based billing. No heavy billing system.

You tie payment to the instance, and let the system enforce itself.

Removing the Last Barrier

Most users don’t want to think about wallets, keys, or anything crypto-related.

So we don’t make them.

We offer a white-glove setup: we spin everything up, get them running, and over time hand off ownership through a passport.

From their perspective: they’re just using software.

Under the hood: they own their system, control access, and benefit from decentralized identity — without getting buried in jargon or complexity.

That’s really the shift.

Developers get paid cleanly. Users get ownership without friction.

And the system just runs.