Flashnet is building a distributed execution network that helps developers run blockchain logic securely and at scale. As usage grew, the team needed a way to monetize API access and enforce limits without building custom billing code.
They explored several paths, self-hosting an open-source meter, adopting a usage-based billing platform, or wiring their own tracking logic into Stripe. What they really wanted was simpler: a way to treat pricing and limits as part of the product, not as a separate system.
That led them to Schematic, which provides the pricing and entitlement layer, and Stripe, which handles payments and invoicing. Together, they gave Flashnet a billing stack that developers don’t have to think about, and that scales as cleanly as the rest of their infrastructure.
Evaluating Options
Flashnet’s first attempt at billing was with OpenMeter, a self-hosted open-source tool. It was transparent and flexible at first, but running it in production was hard. The dashboard was limited, the setup was fragile, and event-based pricing didn’t scale.
Next, they tried Orb, which promised a more complete managed solution. Orb’s event ingestion was powerful, but it was also rigid. Every call became an event, and plans were defined entirely in terms of those events. There was no easy way to check if a user was entitled to a feature or to set rules like “this plan includes reporting.”
After weeks of work, Flashnet realized they didn’t need a deep analytics system for usage. They needed something simpler and closer to how the product worked — one that tied pricing directly to entitlements, with reliable billing handled by Stripe.
Why Stripe plus Schematic
When the team stepped back, they realized their problem wasn’t about processing more events, it was about mapping billing to product features.
Stripe was already the clear choice for payments, invoicing, and billing. hinkThe missing piece was an easy way to implement pricing logic in Flashnet itself — seat counts, usage limits, feature gates — all while staying within Stripe.
That’s where Schematic fit. It extends Stripe with a programmable pricing and entitlement layer, so developers can define what customers can do, track usage, and enforce limits automatically, while Stripe remains the system of record for billing and revenue. Developers can ask simple questions in code:
if (schematic.isEntitled(user, "archive_endpoint")) { ... }That pattern replaced hundreds of lines of custom tracking and gave them a clear source of truth for access and usage. In practice, it cuts the billing work for a new feature from a few weeks of engineering time to a few hours of configuration.
Implementation
Once the decision was made, the switch was fast. Flashnet replaced their Orb integration in a single afternoon, swapping out event-counting code for Schematic’s SDK and wiring entitlement checks directly into their API.
The team also brought Schematic’s composable dashboard components online to give internal teams visibility into usage and plan limits without custom UI work. Stripe handled payments and invoices, while Schematic synchronized plan data and entitlements behind the scenes.
Results
Engineers no longer touch billing logic. Pricing changes and new limits ship without a deploy. The product enforces entitlements automatically, driving conversions as usage limits are hit.
The same setup now supports multiple product lines and customer types, self-serve users can start instantly, while enterprise plans layer in additional features and higher limits, all backed by Stripe’s reliability.
Pairing Schematic’s pricing agility with Stripe’s billing infrastructure gave Flashnet exactly what they were missing, control without complexity.