"It's just prepaid credits, right? Customers pay upfront and draw down their balance."

This deceptively simple view of the most popular usage-based pricing model is the quiet killer of enterprise scaling. While it works perfectly for your first 50 customers, this mental model becomes a ticking time bomb as you sign larger, more complex deals.

The trouble doesn’t show up immediately. It surfaces when your first seven-figure deal closes, and your VP of Finance discovers the billing system can’t track what sales just promised. By then, you're already drowning in spreadsheet workarounds, audit flags, and customer trust issues.

At the heart of this pain is a hidden architecture decision: customer-level credits vs. contract-level credits. It might seem like a backend detail, but this choice shapes your ability to scale, adapt your pricing, and close your books cleanly.

Let’s break down what these models are—and why picking the wrong one could hurt your growth.

Customer-level vs. Contract-level credits: What’s the difference?

Before diving into which model works best for what scenario, let's clarify how each approach actually works. The differences might seem subtle at first, but they create dramatically different outcomes as your business scales.

The wallet approach: Customer-level credits

Think of customer-level credits like a gift card to a department store. Your customer buys $10,000 worth of credit, and they can spend it on anything in your product catalog:

• All credits go into one big bucket at the customer customer level
• Any product or service can draw from this shared pool
• The system doesn't track which credits came from which deal
• It's simple, flexible, and works like a prepaid balance

Real talk: This is what most billing systems default to, and for good reason—it's straightforward and works perfectly for small businesses.

The deal-based approach: Contract-level credits

Contract-level credits use a structured schema to mirror how enterprise deals are actually negotiated in the real world. When a VP of Procurement sits across the table from your sales team, they're laser-focused on specific terms: which products they're entitled to use, what discounts apply to each product line, when the commitment starts and ends, and how payment schedules align with their budget cycles. They also care deeply about overage rates if they exceed their commitment, and what happens to unused credits when the contract expires.

The contract-level model honors these nuances:

• Every credit or commit specified in the contract has its own separate ledger for finance to track
• Credits are tied to specific products, creating clear boundaries around what can be consumed
• Different contracts can have different pricing, discounts, and terms, even for the same customer
• Usage is tracked against the exact contract that covers it, creating a clean audit trail
• Amendments and expansions create their own separate tracking with clear lineage to the original agreement
• Your entire revenue stack operates at contract-level—not customer-level—ensuring what sales sells in your CRM is exactly what billing tracks and finance recognizes in your ERP without translation errors.

This is how real-world enterprise selling works. And your billing system needs to match it.

When the wallet model works well

The customer-level approach works well in several scenarios:

For  PLG motion: If you're running a pure self-serve model where customers purchase credits and consume them across your platform, the wallet model is a great fit, particularly when monthly spend is low (typically under $1K/month) and contracts aren’t justified yet.

When your products are all-one-happy-family: If all your offerings have similar margins and you're not too concerned about which product gets used, pooling makes sense.

For B2C and Simple SMB: When you're dealing with individual consumers or straightforward business relationships without complex procurement, the wallet approach delivers the good-enough experience.

The beauty here? Simplicity. Your customers understand it intuitively: "I bought $5,000 of credit, and I have $3,200 left." No complicated explanations needed.

When enterprise reality hits: The case for contract-level credits

As you move upmarket and start landing those coveted enterprise deals, the simple wallet model starts showing cracks:

Enterprise deals have structure: When a customer signs a $250K deal for AI inference with one discount rate and a separate $50K deal for data storage with another rate, they expect you to track each commitment separately. With customer-level credits, you lose clear linkage into which usage applies to which deal.

Multiple product lines become unmanageable: Your customer signs a deal for $200K of compute with a hefty discount. Six months later, they add a $100K expansion for a new product line. With customer-level credits, you'll struggle to report on each deal's performance separately, which becomes a big problem at renewal time.

Margin management gets risky: Different products have different costs. If a customer can use discounted credits from a high-margin product to consume your lowest-margin offerings, you're setting yourself up for a profitability surprise. For example, a customer negotiates a sweet discount on your core platform but isn't supposed to use those credits for premium features that include third-party costs (like OpenAI or Anthropic API calls). With customer-level credits, there's no way to prevent this without custom code.

The finance team will thank you: When your CFO needs to recognize revenue accurately or your auditors want to trace exactly how a contract was fulfilled, the per credit per contract ledger provides the clean audit trail they crave.

Marketplaces get messy fast: When customers buy through multiple cloud marketplaces (AWS, Azure, GCP), customer-level credits force you to create duplicate customer records to track separate commitments. Contract-level credits let you maintain a single customer identity with separate commitment pools, eliminating this fragmentation headache before you even reach enterprise scale.

Real-world headaches: When billing misalignment hurts

Let's explore a few painful scenarios that arise with the wrong billing model for prepaid credits:

The new product introduction problem

Your team spent months building an exciting new feature. You want to offer existing customers free credits to try it out. With customer-level credits, there's no way to isolate these promotional credits from the existing credit pool. This is extremely problematic for companies looking to offer new AI products, as the cost structure of AI features is dramatically different from their existing products.

The rollover challenge

Smart companies leverage strategic rollover policies to drive renewals and prevent churn. Maybe your core service allows 50% of the starting balance to roll over, but your free promotion credits expire completely. Without structured contract-level credit management, you can't properly calculate carryover based on contract agreements or maintain clear separation between credit pools, forcing confusing conversations with customers and creating manual headaches for your finance team.

The burn order revenue trap

Customer-level credit systems often prioritize operational simplicity over financial accuracy, relying on hardcoded burn logic (e.g., FIFO, soonest-to-expire, or lowest-cost-first). These models work fine for consumer-style prepaid use cases, but fall short in enterprise environments where customers have multiple contracts, pricing tiers, and performance obligations under ASC 606.

When credits from different contracts carry different discount rates, a lack of policy-driven, contract-aware burn order leads to revenue distortion. For example, if new credits are discounted more heavily than the original commit, consuming them first may understate revenue, violating revenue recognition rules. Without structured, contract-aware credit attribution and burn logic, finance teams must resort to manual spreadsheets, creating audit risk and blocking financial automation.

Making the right choice for your business

So, how do you decide which approach is right for you? Ask yourself these questions:

1. Where are you in your journey? Early-stage companies with simple offerings can start with customer-level credits and upgrade to contract-level later. But if you're already selling to enterprises or plan to soon, future-proof your billing now.
2. How diverse is your product line? The more varied your offerings and their economics, the more you'll benefit from contract-level tracking.
3. What keeps your finance team up at night? If they're already struggling with revenue recognition or contract compliance, contract-level credits will help them sleep better.
4. How do your customers buy? If they purchase in complex ways (multiple stakeholders, different budgets for different products), the contract model will better mirror their internal processes.
5. What's your pricing strategy? If you use sophisticated tactics like different discount tiers, varied overage rates, or product-specific promotions, you'll need contract-level granularity.

Many growing companies discover they need a hybrid approach: customer-level simplicity for self-serve customers and contract-level precision for enterprise deals. Modern billing solutions like Metronome are designed to support both simultaneously, giving you the flexibility to meet different customer segments where they are. 

If you're evaluating billing platforms, add this critical question to your RFP: 

• "Can your platform support both customer-level and contract-level credits for the same customer, with full auditability?”
• “Does your system have a structured schema to associate credits with specific contracts?”
• "Can your platform calculate and apply full and partial percentage-based rollovers, or is rollover management manual?"
• "Is your credit consumption order configurable to align with revenue recognition requirements, or is it hardcoded?"
• "Can your system restrict credits to specific products or SKUs, or do all credits draw from the same pool regardless of product?"
• "How does your platform handle mid-term amendments while maintaining the relationship to the original contract?"

The bottom line

Your billing architecture isn't just technical plumbing—it's a strategic one that touches everything from product to sales to finance to customer experience.

The customer-level "wallet" model excels at simplicity and works beautifully for straightforward businesses. The contract-level "deal-based" model provides the precision and alignment with enterprise sales demands, particularly as you scale.

The best approach aligns your billing with how your business actually sells in the real world. When your billing system mirrors your sales motion, magic happens: what your sales team promises is exactly what gets delivered, billed, and recognized.

Whether you're evaluating billing vendors or building in-house, understanding these models now will save you countless hours of custom development and manual reconciliation down the road.

After all, the best billing is the kind you don't have to think about—because it just works the way your business does.