Usage-Based Pricing Is the Future
If you watch startups long enough, you notice that ideas often come back in new forms. Something that seemed outdated suddenly becomes the obvious way to do things again once technology changes.
Usage-based pricing is one of those ideas.
It's actually older than software. Utilities have used it for more than a century. Electricity companies charge you for the power you consume. Water companies charge for gallons used. Phone companies used to charge by the minute.
But when software moved to the internet in the 2000s, we switched to subscriptions. You paid $20 a month, or $99 a month, and you got access to the product. That model worked well for a long time. It was simple and predictable. Investors liked it because recurring revenue looked stable.
But subscriptions were always a bit artificial.
Some customers used a product constantly. Others barely touched it. Yet both paid the same amount. To compensate, companies invented pricing tiers with arbitrary limits. Ten reports on the basic plan. One hundred reports on the next plan. If you needed eleven reports, suddenly you had to upgrade.
Everyone could tell the system was a little fake.
Now the internet is slowly moving back to a much older idea: charging people based on what they actually use.
AI Broke the Old Model
The main reason this shift is happening is AI.
Traditional SaaS had near-zero marginal cost. Once the product existed, adding another user didn't cost much. But AI products are different. Every request to a model consumes compute. Every generated image, transcription, or response has a real cost behind it.
That means costs scale with usage.
If you charge a flat monthly fee for an AI product, you create a problem. Some customers will barely use it. Others will run thousands of requests per day. The heavy users can quickly become unprofitable.
Usage-based pricing fixes this immediately. Customers pay for the resources they consume.
This model also feels more honest. When someone uses a product a lot and gets enormous value from it, they pay more. When they use it occasionally, they pay less.
Customers like this because it lowers the barrier to trying something new. Instead of committing to a large subscription upfront, they can start small and grow naturally.
Companies like it because revenue grows with customer value.
In other words, incentives line up.
And when incentives line up, systems tend to last.
The Hard Part Is Billing
If usage-based pricing is so sensible, you might ask why it didn't take over earlier.
The reason is implementation.
Subscription billing is simple. Charge a credit card once a month and you're done.
Usage-based pricing requires infrastructure. You have to measure usage events. You need to track API calls, requests, compute time, storage, or whatever unit your product uses. Then you have to convert those events into invoices. You also have to handle credits, overages, free allowances, upgrades, downgrades, and enterprise contracts.
Billing bugs are some of the worst bugs a company can have. If you overcharge customers, they lose trust. If you undercharge them, you lose money.
So most startups historically built their own billing logic on top of Stripe. Over time that turned into a surprising amount of code. You'd end up with webhook handlers, billing tables, usage aggregators, entitlement systems, and migration scripts.
Founders hate writing this kind of software.
The irony is that pricing is extremely important. It's one of the highest leverage things a startup can experiment with. Changing pricing can completely change how people use your product.
But because billing logic is buried deep in application code, changing it is painful.
Ideally pricing should be flexible. You should be able to experiment with different models without rewriting half your backend.
That's the problem Autumn solves.
Autumn: Infrastructure for Pricing
Autumn is essentially infrastructure for pricing.
Instead of writing complex billing logic yourself, you define your pricing model inside Autumn and connect your application to it through a simple API.
Autumn sits between your application and Stripe. It manages subscriptions, usage tracking, feature limits, and billing logic in one place.
Your application does three simple things:
- Define pricing plans and features
- Record usage when customers use the product
- Check whether a user is allowed to access something
Everything else is handled automatically.
Autumn tracks usage limits, manages customer subscription states, and enforces feature access rules.
Instead of maintaining multiple webhook systems and billing tables, developers can handle pricing with just a few API calls.
This might sound like a small improvement, but it removes a huge amount of complexity from a startup's codebase.
And more importantly, it makes pricing flexible.
When a company wants to experiment with a new pricing model, they don't need to rip out large sections of billing infrastructure. They can change it inside Autumn and deploy immediately.
Why AI Startups Need This
AI companies benefit especially from this approach.
Most AI products don't have a single pricing model. Instead they combine several:
- a base subscription
- a monthly usage allowance
- overage charges
- prepaid credits
Building all of this manually is messy. And AI startups often change pricing frequently as they learn how customers actually use their product.
Autumn was designed for exactly this situation.
It supports subscriptions, usage-based pricing, credit systems, and hybrid models without requiring custom billing infrastructure.
In effect, it lets founders treat pricing as configuration rather than code.
That's a big shift.
Because it means startups can experiment with pricing the same way they experiment with product features.
A Stripe-Like Moment for Pricing
The easiest way to understand Autumn is by comparing it to Stripe.
Before Stripe existed, accepting payments online was painful. Developers had to deal with banks, payment gateways, merchant accounts, and complicated APIs.
Stripe turned payments into something you could implement with a few lines of code.
Autumn is doing something similar for pricing.
Instead of every startup building its own billing infrastructure, they can use a shared layer designed specifically for modern software businesses.
And as AI products continue to spread, this layer will become increasingly important.
Because AI changes the economics of software.
Costs now scale with usage. Pricing has to scale with usage too.
The companies that figure this out fastest will build better businesses.
And the tools that make this easy will quietly become part of the infrastructure of the next generation of startups.
Autumn looks very much like one of those tools.