
Multi-Tenant Architecture: 3 Models & 8 Best Practices
Learn how multi-tenant architecture works, compare database isolation models, and explore six components & eight best practices for shared infrastructure.
Quote-to-cash explained: the 8 Q2C steps, how it differs from order-to-cash and CPQ, which tools own each step, and where usage-based AI pricing breaks it.
A rep closes a deal on Friday with a custom discount, a usage allowance double the standard plan, and an overage rate the customer pushed hard for. By Monday, those terms live in a PDF, a CRM record, and the rep's memory, and three teams are about to re-enter them into three different systems.
Quote-to-cash is the process that's supposed to keep that from going wrong. When it works, the price on the quote, the access in the product, and the number on the invoice all match. When it doesn't, finance chases billing disputes while engineering flips account settings by hand.
This guide covers the eight steps of the quote-to-cash process, how Q2C compares with order-to-cash and CPQ, which systems own each step, and where the process gets harder once you sell usage, credits, or AI features.
Quote-to-cash (Q2C or QTC) is the end-to-end business process that takes a deal from the first configured quote through contracting, fulfillment, invoicing, payment collection, and revenue recognition.
It's the bridge between the front office and the back office. Sales works the deal in the CRM, finance closes the books in the ERP, and Q2C covers everything in between that turns a promised deal into cash that's collected and revenue that's recognized.
Several teams own a piece of it. Sales and RevOps handle configuration, pricing, and quoting, legal owns the contract, engineering or operations provisions what the customer bought, and finance runs billing, collections, and revenue recognition.
That spread is why Q2C problems are hard to see from any one seat, since each team's piece can look fine on its own while the handoffs between them leak time, accuracy, and revenue.
The quote-to-cash process runs through eight steps, from configuring what the customer is buying to recognizing the revenue and renewing the deal.
Configuration is where the rep picks the right mix of products, plans, add-ons, and options for the customer. The product catalog defines what can be sold together, so a clean catalog keeps reps from building bundles the product can't deliver.
With AI and usage pricing, configuration also means choosing credit allocations, token limits, and model tiers, and each of those has to exist somewhere the product can read it later.
Pricing applies the right price list, tiers, volume discounts, and negotiated terms. A lot of Q2C errors start here, because discount rules often live in spreadsheets and approvals happen in email threads.
Usage-based pricing and hybrid plans add more variables, like included usage, overage rates, committed spend, and prepaid credits, and all of them have to carry through to billing exactly as priced.
The quote turns the configuration and pricing into a formal proposal the buyer can review and accept. Quotes usually pass through an approval workflow when discounts or non-standard terms cross a set threshold.
The question that matters downstream is whether every line on the quote maps to something the product and billing system can deliver. If sales quotes per-department budgets and the product only tracks one balance per customer, the quote is promising something nobody has built yet.
The contract turns the accepted quote into a binding agreement that covers pricing, terms, service levels, and renewal conditions. Contract lifecycle management (CLM) tools handle redlines, approvals, e-signature, and storage.
Enterprise contracts often add terms the standard catalog never had, like committed spend, ramp schedules, negotiated overage rates, and team-level allocations. Those custom terms are the ones most likely to get lost between signature and setup.
Once the contract is signed, the order is created, and the customer gets what they bought. For physical goods that means shipping, and for software it means provisioning: creating the account, turning on the right features, and setting the right limits.
Plenty of teams still handle this with a person reading the contract and toggling settings in an admin panel, which is the issue behind what happens after a deal goes closed-won in Salesforce.
Every manual step between signature and access is a window where the product doesn't match the deal.
Billing generates invoices from the contract terms, covering subscription fees, one-time charges, prorations, and usage. For usage-based deals, invoice accuracy depends on the usage metering data feeding the billing system.
An invoice is only as accurate as the data upstream of it. If the contract terms were entered wrong at provisioning, or usage events were dropped along the way, billing will produce the wrong number on schedule.
Collection covers payment processing, applying payments to open invoices, chasing late or failed payments, and handling disputes. Days sales outstanding (DSO), the average number of days it takes to collect payment after a sale, is the metric most finance teams watch here.
Accurate invoices get paid faster, and the usual reasons an invoice sits unpaid are a disputed line item, a wrong amount, or a missing purchase order number.
Revenue recognition records revenue as it's earned under ASC 606 or IFRS 15, which for subscriptions and prepaid plans is often well after the cash arrives. Renewals and expansions then send the customer back to step 1 with new terms.
Renewals are where catalog design pays off. If changing a customer's limits or allocations takes a code deployment, every contract amendment becomes an engineering ticket that waits behind the rest of the sprint.
The difference between quote-to-cash and order-to-cash is where each process starts. Quote-to-cash begins with configuring and pricing a deal, while order-to-cash begins once an order is placed or a contract is signed.
Order-to-cash (O2C) is a subset of Q2C that covers fulfillment, invoicing, payment collection, and cash application. It's the main framework for businesses with standard pricing and high order volume, where orders arrive without much negotiation.
Q2C adds the front half of the deal (configuration, pricing, quoting, and contracting), which matters most in B2B sales with negotiated or usage-based terms.
CPQ (configure, price, quote) covers only the first three steps of quote-to-cash. CPQ software helps reps configure products, apply pricing rules and discounts, and generate accurate quotes, and then it hands the accepted quote to the rest of the process.
CPQ handles only the first three steps, so a company can run an excellent CPQ tool and still have a broken Q2C process, because contracting, provisioning, billing, and revenue recognition happen in other systems, and the handoffs between them are where most errors happen.
CPQ and the rest of the process do need to share one thing: the product catalog. If the catalog sales quotes from drifts away from the one the product enforces, reps end up selling configurations the product can’t deliver.
Most quote-to-cash problems come from the handoffs between systems and teams, and they show up as quoting errors, slow deals, billing disputes, and lost revenue.
The admin load lands on sales first. Salesforce's State of Sales research found reps spend 60% of their time on non-selling tasks, such as entering notes into the CRM and chasing internal approvals.
All of these add up to revenue leakage, the revenue you earned but never billed or collected, like usage that never reached an invoice, discounts that outlived their terms, or price increases that never made it into billing.
MGI Research puts leakage at 3% to 5%of every company's revenue at minimum, and traces much of it to manual data transfers between quote and contract and integration gaps between fulfillment, billing, and finance systems.
The strongest quote-to-cash processes run from a single source of truth for products and contracts, automate the handoffs between steps, and measure where deals slow down.
Quote-to-cash software is a stack of systems, where each step is owned by a different tool and the integrations between them decide how much of the process runs without manual work.
Most of these layers are well served by established vendors, and few teams should build their own CRM, CPQ, or billing system. For more on how the billing side fits together, see this breakdown of the modern billing stack.
The layer that's easiest to miss sits between the contract and the invoice. An entitlement management system turns contract terms into what the product allows, meters what each customer consumes, and enforces limits while the product is running.
For a subscription business with simple plans, feature flags plus the billing system's plan data can cover that job. For usage-based and AI products, it's the layer doing the most work in the whole stack, and it's where Q2C breaks most often.
Quote-to-cash breaks for AI and usage-based products wherever contract terms meet infrastructure built for flat subscriptions, because usage has to be metered and limits enforced in real time, between provisioning and billing.
Traditional Q2C frameworks end at billing, which records what happened after the fact. AI products need to go beyond the eight-step model and decide whether the next request should run, based on the customer's current entitlements, credit balance, and limits.
Usage has to be metered in real time, and enforcement has to run synchronously in the request path before compute is consumed. A billing system that settles usage at the end of the cycle only sees an overage after it has already happened.
If metering is accurate but enforcement runs after the fact, an agent session running against a depleted balance keeps going until the next sync. The overage shows up correctly on the invoice, and the compute behind it was spent hours earlier.
Enforcement in the request path means:
Billing tells you what happened. Enforcement decides what’s allowed to happen. For AI products, those are two separate layers running at different points in the request lifecycle.
Enterprise AI contracts include per-team credit allocations, agent-level usage caps, department spend limits, and negotiated overage rates. Each of those terms has to map to an entitlement configuration the product can enforce, or the contract and the product run on different rules.
A failure that shows up regularly is when sales closes a deal with per-department budgets, and engineering finds out the entitlement layer was built around a single balance per customer. The contract is signed, and the product has no model for the org hierarchy it just sold.
The failure surface is specific:
Manual provisioning after signature leaves a gap where the customer expects access the product hasn't granted yet. For enterprise AI accounts, provisioning means setting up the whole structure at once, before the first request runs.
A single account might need five teams with monthly credit pools, dozens of agents with individual caps, and department overrides for when a team's budget runs out. A workflow built for simple upgrades breaks at that structure, so provisioning has to be atomic and triggered by the contract.
When metering and billing run as separate systems on different schedules, invoice totals drift away from actual consumption. The metering layer has to be the source of truth billing reads from.
Usage events typically flow through a metering pipeline into a usage store that billing reads on its own schedule. Under heavy load, some events land after the billing read and miss the invoice, so finance’s number drifts from engineering’s and reconciliation outlasts the billing cycle.
Prepaid credits create deferred revenue that's recognized as customers consume them, while expired credits (breakage) are recognized according to your accounting policy. Both depend on consumption records finance can audit.
An append-only ledger, where every credit grant, deduction, and expiry traces back to the event that caused it, gives finance that lineage. A single mutable balance column only shows today's number, with no history behind it.
Stigg's guide to credit pricing covers the ledger mechanics in more depth.
Enterprise customers want to see and control how their AI budget is consumed across teams, and a billing system that reports after the cycle closes gives their admins nothing to act on in time. Spend governance has to run inside the product as a live capability:
This is the core of AI usage control, and it lets customers manage their own consumption without pulling in your support team.
Use this list when scoping a new implementation or pressure-testing an existing one:
Building parts of the Q2C stack in-house makes sense early on, and the part that takes longest to get right is the entitlement and enforcement layer.
Mature vendors cover CRM, CPQ, CLM, and billing well, so few teams build those. Entitlements are different, because they're tied to your product's code, and a basic credit check is a reasonable first build that ships fast.
What comes after it takes much longer:
Most teams ship the simple version and then rebuild their billing infrastructure when pricing evolves, or the first enterprise contract arrives with terms it can't model.
For a single product with flat pricing and no enterprise contracts, a simple in-house entitlement check is the right call, and the decision only gets more expensive to put off as pricing grows more complex.
Think back to that Friday deal with the custom discount, the doubled usage allowance, and the negotiated overage rate. In a healthy quote to cash process, those terms get entered once, and the product, the invoice, and the revenue schedule all read them from the same place.
For AI products, that place has to be fast enough to sit in the request path. Stigg is the usage runtime that fills this role, running entitlements, credits, metering, and governance in one enforcement layer that works alongside your CRM, CPQ, and billing stack.
Stigg's newer Contract Management capability, now in beta after the Received.ai acquisition, turns a signed order form into one contract object that provisions entitlements and drives invoices, so an amendment updates both at once.
With Stigg, engineering teams can:
Each component works on its own, so teams often start with the piece that hurts most (usually provisioning or credits) and add the rest as their contracts get more complex.
If your contracts are starting to promise more than your product can enforce, talk to a human about your stack, or start with the AI quickstart in the docs.
The main difference between quote-to-cash and quote-to-revenue is where the process ends. Quote-to-cash ends when cash is collected, and quote-to-revenue ends when revenue is formally recognized under ASC 606 or IFRS 15.
With prepaid credit models, those two endpoints can be weeks or months apart.
Lead-to-cash is a broader version of quote-to-cash that starts with marketing generating and qualifying leads. It adds lead and opportunity management before the quote, then follows the same steps through contracting, billing, and payment collection.
A quote can't work as an invoice because a quote is an offer and an invoice is a request for payment. The quote tells the buyer what a deal would cost before they commit, and the invoice is issued after the sale based on the contract and, for usage-based plans, what was consumed.
Quote-to-cash is usually owned jointly, with RevOps or a deal desk coordinating it. Sales owns quoting, legal owns contracts, engineering or operations owns provisioning, and finance owns billing, collections, and revenue recognition.
Quote-to-cash for usage-based pricing needs real-time metering, an enforcement layer that checks limits before each request, and billing that invoices from metered usage.
Terms like included usage, overage rates, and credit allocations have to become enforceable entitlements from day one.