---
title: "Quote to Cash"
type: playbook
evidence_type: method
category: "Revenue Systems"
publisher: "LeanScale"
date_modified: 2026-07-27
word_count: 3514
topics: ["pricing-packaging", "revenue-operations"]
canonical_url: https://knowledge.leanscale.team/playbooks/quote-to-cash-playbook/
source: "LeanScale Knowledge Hub — https://knowledge.leanscale.team"
license: "Free to quote and cite with attribution to LeanScale."
---

# Quote to Cash

**Evidence type:** method (what we prescribe)

Every Quote to Cash project moves through the same four phases. Know what you produce in each one — and know that this is a project you win or lose in the Blueprint. 1 Blueprint Research the systems, the paper, and the calls. Turn every selling motion into scenarios and a field guide.

## Four phases, one motion.

Every Quote to Cash project moves through the same four phases. Know what you produce in each one —
and know that this is a project you win or lose in the Blueprint.
1
Blueprint
Research the systems, the paper, and the calls. Turn every selling motion into scenarios and a field guide.
Output Scenario map + field guide
2
Build
Configure the CPQ to the scenarios, wire it to billing, let the document drive the stage — push or IKEA instructions.
Output Live CPQ + billing wired
3
Enable
Diagrams, this podcast, office hours — and a named client-side admin who owns the back end.
Output Enabled team + owner
4
Maintain
Guard the guardrails, watch pricing/packaging drift, and get them ready for where they're heading.
Output A system that stays true
Start Here

## Kick off a project in one paste.

Don't dig through the GitHub repo. Copy this prompt, drop in the customer name, and send it to your Claude.
It clones the template, reads the AGENTS.md , and walks the Blueprint checklist with you.
paste into Claude
Copy prompt
# Quote to Cash — kick off
Clone the LeanScale Quote to Cash template repo for my customer [Customer Name] .
Then read AGENTS.md and run the Blueprint checklist:
1. Confirm access to the connected systems (CRM, CPQ, billing).
2. Inventory the stack — CRM, CPQ/quoting, CLM, document handling, billing/subscriptions.
3. Pull the sales-call transcripts and the trailing 3 months of order forms & contracts.
4. Map every selling motion into scenarios — new business, renewals, expansions, ramp, pilots.
5. Draft the field guide — every property one "create quote" button touches.
Ask me anything you need before you start.
What you get

### Skills + an AGENTS.md

A README, the playbook, and configs for both Salesforce and HubSpot . The AGENTS
file gives Claude the checklist so the kickoff is a guided walkthrough, not a scavenger hunt.
1
Phase 1

## Blueprint.

This is the whole game. Before you touch a single
field, get an amazing lay of the land — how they sell, what they sell, how they configure it, and every
piece of paper it produces. Then turn all of it into scenarios and a field guide. Be almost obsessively thorough:
this project is won or lost right here.
1.1 · Research & the Lay of the Land

### Plug in, then inventory.

Most of the current-state is visible from their systems before you ever get on a call. Send research agents
at everything external and everything you can reach, and come back with a complete inventory of what's in play.
The inputs you plug in
Sales-call transcripts — Gong or any transcript of the team talking products & pricing. Gold for how they frame it with a customer, and the groundwork for guided selling when there's no CPQ yet
The paper — trailing 3 months of order forms & contracts (not full historicals), one of every motion : enterprise, SMB, renewal, expansion. Dump into PDF reading to see how contracts are structured
The CRM + billing schema — fields, properties, automations. You can read most of how they do quote-to-cash straight from this
Bring engineers in early — so they get familiar with the systems and start mapping what drives what
The systems to inventory
CPQ / quoting system — or none at all (that changes everything downstream)
CLM — contract lifecycle management
Document handling — PandaDoc, DocuSign, or old-school PDFs in Drive
Billing & subscriptions — Stripe, Maxio, Reel It, NetSuite
The documents themselves — MSA, SLA, DPA, order form / SOW. Identify every one, and whether changes route through legal or an approval chain
Surface early
The things they aren't thinking about yet — auto-renewals, early renewals, and expansions .
Most teams have these strung together by hand. Streamlining them is where quote-to-signature gets faster.
scenarios -->
1.2 · The Standard

### Every selling motion becomes a scenario.

This is the core move, and it's what we do that no off-the-shelf CPQ does for you. Take every way they sell —
including renewals and expansions, not just new business — and turn each into a scenario . A scenario drives
its own guided-selling questions and its own set of available products. That's the guardrail.
New Business
Land
Enterprise
SMB / velocity
Paid pilot / POC
Free POC → convert
Renewals
Keep
Standard (manual review)
Auto-renewal
Early renewal
Co-termed renewal
Non-standard term (e.g. 7-mo)
Expansions
Grow
Co-termed expansion (proration)
Term reset — AE-only, full deal replacement + credit-back
Add-on / upsell
Complex / Non-standard
Watch out
Ramp deal — multi-year, price & products vary by year
Short-term non-recurring (intern/summer)
Pilot + fast follow
The guardrail
Select a scenario and the CPQ only offers what that scenario allows — so a rep can't drift and
sell an incompatible combination. One client built exactly this: each motion had subcategories, each subcategory its
own guided-selling questions and product set. We haven't seen it done this way in any off-the-shelf setup.
1.3 · The Pipeline

### The document drives the stage.

Best practice: the generation, sending, and completion of the document is what drives stage automation —
all the way from evaluation to the handoff. Enterprise motions add a procurement / finance / deal-desk gate.
Quote-to-Cash pipeline · document-driven
Opportunity · stage automation
Quote built Evaluation →
Doc sent Proposal Sent →
Negotiation →
Enterprise Deal Desk / Procurement →
Doc signed Closed Won →
Provisioning handoff
Document status advances the stage automatically — proposal sent moves it to Proposal Sent ,
signature moves it to Closed Won , and closed-won kicks the deal desk check into the provisioning /
onboarding / finance handoff.
1.4 · Guided Selling

### The engine — and how one click ripples out.

Guided selling is a Q&A form. Done right, a rep fills it out in the blink of an eye and never touches the
document. But the important part is everything that one click triggers downstream.
1
Select a product → get only its compatible configurations
Complexity isn't the number of products — it's the configurations . One product with 20 configs is complex; some combinations can't be sold together. Guided selling enforces the compatible set (the "cart + 200 peripherals" problem, solved).
2
Set the terms per line item
Are line items individual with their own terms? Recurring vs non-recurring? Different billing start / invoice dates? Guided selling walks the rep through it so the quote is accurate and CRM-compatible.
3
Fire the downstream CRM flags
A term reset looks up what's being replaced, then on submit flags the replaced deal in HubSpot/Salesforce and the credit owed back for the pre-paid remainder. That downstream effect is the whole point.
4
Feed the billing system
The CPQ hands the billing platform the invoice schedule — individual line items, their terms, their start dates. CRM-compatibility is the most overlooked piece : people build a beautiful CPQ that can't hand the CRM the revenue detail it needs.
1.5 · Tool Selection

### What we recommend, and why.

Two things decide the tool: the complexity of the selling motion and the complexity of the product
configuration . Pricing model (usage-based vs flat-rate) decides the billing side. Baseline: Salesforce
for CRM, Clay for enrichment.
If · complex motions or complex product config
Deal Hub (or Nue)
The logical choice 9 times out of 10 for enterprise-grade selling. Its Subscribe acquisition is the play to do PLG and sales-led under one roof — as it consolidates into one system.
Else · basic motions & basic configs
Native — or a custom extension UI
Native HubSpot quoting / Revenue Hub, or native Salesforce CPQ. Want more control, guardrails, approvals without leaving the UI? A custom extension UI — where an AI can build the quote from a chat because it has CRM scopes + a CPQ context doc.
Watch out
The "all-in-one" that isn't. Maxio acquired a CPQ but never folded it in — on paper it's one
platform, in reality it's stitched together via APIs with different logins and subscription tiers. And on
PLG : it lives on the billing side. No system does sales-led + PLG really well — pick Deal Hub
for sales-led, solve PLG through billing.
1.5b · Billing

### The billing platforms we see.

Stripe
Most common
Easy to set up & use
Weak for B2B SaaS — subscriptions, renewals, one-time line-item discounts don't translate
Needs someone hands-on in the back end
Reel It
The favorite
Simplified, cleanly integrated to HubSpot & Salesforce
Sits on top of Stripe (payment gateway) or replaces it
Just needs amount + discount — vs. custom-object chaos
Maxio / NetSuite
Enterprise
Maxio typically pairs Stripe as the gateway
Can it handle a ramp deal invoice schedule? Test it — NetSuite couldn't off standard objects
We don't touch Stripe→RevRec or QuickBooks reconciliation
1.6 · The Field Guide

### ~25 revenue fields off one button.

When a rep clicks "create quote," dozens of revenue fields populate at once. Build the field guide — the
full data model of everything that one button touches, what changes now, what it changes in the future, and
what it changes in the past — and map each field to the motion that drives it.
ARR Annual recurring
MRR Monthly recurring
ACV Avg contract value
TCV Total contract value
Upsell ARR Expansion up
Downsell ARR Contraction
Credits ARR Given back
Proration Co-term expansion
Discount Amount / %
The nuance
On an early renewal you stamp both deals — the one renewing early and the one being renewed on —
so you can read what was sold before, what's sold now, and the uptick in ARR. A 7-month deal breaks native
ARR math entirely, so you build the non-standard scenario with custom properties that compute it correctly.
1.7 · Discovery & the Bolt-ons

### Who to loop in, and what rides on top.

Systems get you most of the current-state; a day with the sales team gets you the rest — walk me through how you
sell it, what you enter, how you build a proposal, how you build a contract. Loop in a cross-functional team, and
scope the two things that bolt onto quote-to-cash.
Loop in

### Commissioning

We don't calculate commissions — but we're part of the formula . Catalog what's commissionable, and name fields right (one client called a field "commission" instead of quota-retiring revenue).
Bolt-on

### Convert the POC

A paid 1-month pilot usually isn't a customer (it inflates churn and isn't recurring). Track POC success, who's involved, and the follow-up cadence — like we did for UBIC — don't just spin up a new-business deal.
The Deliverable

## What Blueprint hands over.

Two artifacts come out of Blueprint, and everything in Build is downstream of them. Get these signed off before
you configure a single thing.
The Scenario Map
Every selling motion, broken into scenarios. For each scenario: the guided-selling questions,
the products it's allowed to offer, the terms, the document it produces, and what happens in the next period
(does the 3-month pilot convert to a 12-month? auto-renew? renegotiate?). This is the blueprint the CPQ is
configured against.
The Field / Rep Guide
The full data model of every field and property the CPQ touches on "create quote." What gets
populated, what changes now, what changes in the future, what changes in the past — and which motion drives
each one. Derek built exactly this for a client. It's the map the engineering team builds to and the doc the
client's admin inherits.
Use it
Feed the Scenario Map and Field Guide to Claude as the reference for what Build produces. Each
engagement's version looks a little different — but the shape of the deliverable is always these two.
2
Phase 2

## Build.

Configure the CPQ to the scenarios, wire it to billing,
and let the document drive the stage. How much you can automate depends on the tool's API — and if you can't push,
you write the IKEA instructions.
2.1 · Configure the CPQ

### Push it, or write the IKEA instructions.

The scenarios from Blueprint are the config — each drives its guided-selling questions and its allowed
products. Whether we deploy it directly comes down to the tool's CLI / API surface.
If · the CPQ has a real API / CLI
Plug in and push
We build the config programmatically — scenarios, products, guided-selling logic, the CRM field mappings — and deploy it. Native HubSpot / Salesforce is easiest here; RevOps keeps full visibility.
Else · closed / GUI-only tool (many CPQs)
The IKEA instructions
Produce step-by-step install instructions for the engineering team to click through — exact, ordered, screenshot-grade. Same standard, more hands-on execution.
2.2 · Wire Billing & Stage Automation

### CPQ → CRM → billing, and the document drives it all.

The revenue plumbing
Custom properties that compute ARR even for non-standard terms (the 7-month deal)
The ~25 revenue fields stamped on quote creation, mapped to each motion
CPQ → billing invoice schedule — line items, terms, start & invoice dates
Renewal tracking — auto-renew vs manual, opt-outs, notice & cancellation periods
Document-driven stage automation
Generate → Send → Complete drives the stage forward
Proposal sent → Proposal Sent ; signed → Closed Won
Enterprise: a procurement / finance / deal-desk gate before close
Closed-won → the provisioning / onboarding / finance handoff
The billing trap
Ask the hardest question up front: can the billing system service a ramp deal — an invoice
schedule with three years of different prices across ten products? One client's NetSuite couldn't off standard
objects; two heavily-customized custom objects later, moving to Reel It (which just needs amount + discount) meant
70–80 hours to decouple . The tool you pick for billing has real downstream cost.
2.3 · Migration & Cutover

### The safest way to flip the switch.

The riskiest part of Build. Decide whether you launch every motion at once or roll it out by motion — and never
rip the old system out from under them.
Big / cross-functional rollout
Split by motion
AEs, new business & expansions first; CS / account management & renewals second. Less to break at once, and each team adopts on its own clock.
New price book / new CPQ
Parallel-run ≤ 30 days
Keep both options open so nothing breaks or goes un-serviceable. 30 days is the max — the goal is to move everyone over inside that window, faster if adoption allows.
1
Name the client-side admin owner first
Someone on their side takes full ownership of the back end — add a product, make a change, troubleshoot — and can answer questions fast during the window.
2
Run new alongside old, then move everyone over
Both systems live during the parallel window. LeanScale stays online to support & monitor the first couple of weeks .
3
Watch for moving targets mid-build
Price, packaging, or a motion can change mid-build and force a pivot. One client changed their price book twice — a 2-week build became 3 months to go live.
4
Cut over Friday ~2pm
Let it bake over the weekend, hot-fix before Monday. Brief the broader team the Wednesday before .
3
Phase 3

## Enable.

Ship three things every time — documentation, a podcast,
and live office hours — and make sure a named client-side admin owns the back end after you leave.
📄 Documentation
Read
Process diagrams — where you start in the CRM
How to set the document up, publish & send
The approval process & what needs one
What reps can & cannot touch
🎧 Podcast
Listen
Every enablement gets one (ElevenLabs)
People retain audio they'd skim as text
This page's brief is the template
🎙 Office hours
Live
Hyper-care around the cutover
Admin training on the back end
Answer the real questions in the room
3.1 · The Hyper-care Cadence

### One week of white-glove.

Wed · before
Pre-brief
Walk the broader sales team through what's changing before it lands.
Fri · 2pm
Cutover
Go live, then let it bake over the weekend.
Mon · after
Office hours
First live day — catch anything that surfaced.
~2 weeks
Support & monitor
Stay online through the parallel window, then close out hyper-care.
3.2 · Reps fill a form — they don't edit the document
If Build is right, the guided selling speaks for itself . It's a Q&A a rep can complete in
the blink of an eye, and the guided selling plus quoting config takes them 98% of the way there .
On the document side there are only a few things they should ever touch. Everything else is generated — and
locked.
3.3 · Clone the repo into their brain
We clone this Quote to Cash repo for each customer . Every scenario, field, and tool
decision becomes part of their agent's context going forward — so the next project on that account, and every
ad-hoc change, starts faster. Enablement isn't a handoff; it's compounding context.
4
Phase 4

## Maintain.

A Quote to Cash system drifts the moment anything about
how they sell changes. Guard the guardrails, watch for the triggers, and get them ready for where they're heading.
4.1 · Ad-hoc Triggers

### What breaks a Quote to Cash system.

#1 — Reps editing the document
The number-one failure. Give reps too much edit access to the document itself and someone
"just changes this number" — now the contract doesn't sync to the CRM , you have two versions of the
truth, and people start pointing fingers. Their role is guided-selling, quoting, and sending — not editing.
Config drift & moving targets
The messy paper — reps structure quoting tables differently and edit one sentence each; lock it to the scenario
The stitched "all-in-one" — re-verify APIs & logins still hang together after vendor changes
Field naming — the "commission" field that should be quota-retiring revenue
4.3 · When to Revisit

### And prep them for where they're going.

Read the company's maturity — pre-seed, Series A, Series C — and where it's heading. Don't just build for how they
sell today; make sure the tool can handle how they'll sell in six or twelve months.
Event-based
Revisit when the motion changes
A new selling motion, or a new product line
Pricing / packaging change, or a new commission plan
A billing-system change that reshapes invoicing
Trajectory-based
Pre-build for the next stage
Moving upmarket into enterprise? Get them ready for ramp deals , more pilots , and redlined agreements — either pivot fast or preset it so they can turn it on. Sometimes the readiness is in the tool selection itself.
What You Hand Over

## The assets, in one place.

The team gets this landing page with the brief, a one-paste prompt, and the template repo behind it. The client
gets a Scenario Map and Field Guide to sign off, a wired CPQ, and an admin who owns it.
For the team

### Skills, configs, context

Per-platform build skills (SF + HubSpot), READMEs, IKEA install guides, gotchas, and the common ad-hoc work — enablement for our team and our agents.
The bet
Quote to Cash is one of our most complex projects — and our most defensible. The team diagnoses the motions,
builds the scenarios, and wires the revenue plumbing to one standard . Do it right and the guided
selling speaks for itself.
✓
Closeout

## Debrief the project.

When a Quote to Cash engagement wraps, spend sixteen
minutes with the debrief agent. Teamwork already knows what got built and when. This is for the
part none of our systems can see — the call that could have gone either way, the thing the customer
wanted that you refused, the near-miss that never became an incident, and above all the places
this playbook turned out to be wrong. What comes out of it gets written back into this page.

### Before you start

Two minutes of thinking beats sixteen minutes of recall. Have these in your head —
you don't need notes, and you definitely don't need a script.
Motions and scenarios — how many selling motions this customer had, and how many scenarios that turned into.
Whether the document drove the stage — or whether their process forced it the other way round.
Where the CPQ → CRM → billing chain nearly broke — the specific handoff, not the general answer.
Sixteen minutes, one sitting. It's a voice conversation, so your browser will
ask for microphone access — use headphones or the agent will hear itself. Chrome is the safer bet
over Safari.

#### What this is, and isn't

It's a craft debrief , feeding straight back into this playbook.
It is not an assessment. Nothing here goes near performance review.
It's attributed — Anthony reads it with your name on it.
"This took two weeks longer than it should have because of X" is the most useful thing
you can say . Say it.

#### If it doesn't load

No mic prompt? Check the padlock in the address bar — the browser may have blocked it.
Agent talking over you? Headphones. It's hearing itself through your speakers.
Still stuck? Message Anthony rather than burning fifteen minutes on it.
The transcript takes a moment to generate after you hang up. You'll get a recap
emailed to you.

### Hand over the artifacts too

The debrief asks what you built that's worth reusing. This is where you actually hand it
over — dashboards, field maps, flows, templates, scripts, spec docs. Files land in the
project's Drive folder; links go into the artifact register so the next person can find them.
Thirty seconds, and do it while the project is still in your head.
“I'll upload it later” is exactly how assets end up trapped on an account.
Add an artifact →
LeanScale · Delivery OS
The Quote to Cash playbook — the internal standard for turning a customer's quote → contract → billing →
recognized revenue into one guided, instrumented system across Salesforce and HubSpot. Blueprint, Build, Enable, Maintain.

## Canonical

https://knowledge.leanscale.team/playbooks/quote-to-cash-playbook/