Playbook · Quote to Cash

The Quote to Cash playbook.

Everything an architect or engineer needs to run one of these projects end-to-end — Blueprint → Build → Enable → Maintain. One of the most complicated motions we run: quote → contract → billing → recognized revenue. Start with the five-minute audio brief, then open the repo.

4Phases
Deal HubDefault CPQ · 9/10
~25Revenue fields
SF + HSBoth CRMs
Watch or listen first · 5 min

The audio brief.

One narrator, five minutes, the whole shape of the project — now with the deck that runs alongside it. Play it before you open anything else; it's the fastest way to get into the right mindset for a Quote to Cash build. In a hurry? Change the speed under the deck — it sticks next time.

0:00 / 0:00
Speed
1 / 1
Chapter 1 Narrated brief · generated with ElevenLabs · Download ↓
Chapters
The whole idea

Turn a tangle of quotes, contracts, and invoices into one guided path — where how they sell decides how the paper gets written, billed, and booked.

The Shape

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.
OutputScenario 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.
OutputLive CPQ + billing wired
3
Enable
Diagrams, this podcast, office hours — and a named client-side admin who owns the back end.
OutputEnabled team + owner
4
Maintain
Guard the guardrails, watch pricing/packaging drift, and get them ready for where they're heading.
OutputA 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 
# 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

A customer-specific repo

The clone becomes part of the customer's brain — every scenario, field, and tool decision from this project informs their agent going forward.

Inside it

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.

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. Togo 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 builtEvaluation→ Doc sentProposal Sent→ Negotiation→ EnterpriseDeal Desk / Procurement→ Doc signedClosed 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.

ARRAnnual recurring
MRRMonthly recurring
ACVAvg contract value
TCVTotal contract value
Upsell ARRExpansion up
Downsell ARRContraction
Credits ARRGiven back
ProrationCo-term expansion
DiscountAmount / %

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

Cross-functional

Reps from sales, ops, finance, and legal/contracts. You also need a single decision-maker — a sales leader or legal — who decides what reps can and can't edit.

Bolt-on

Deal Desk

Everything from (sometimes before) closed-won to the provisioning / onboarding / finance handoff — making sure the deal is accurate, complete, and good to go.

Bolt-on

Commissioning

We don't calculate commissions — but we're part of the formula. Catalog what's commissionable, and name fields right (Togo 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 Togo. 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? Fountain'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. Fountain 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 kicks off maintenance.

Any one of these ripples through the whole quote-to-cash setup — the CPQ, the guided selling, the revenue fields, the billing, and the commission data.

Trigger

Pricing change

New prices, new pricing model — reflows the CPQ and the revenue math.

Trigger

Packaging change

New bundles or product combinations — new configurations to allow (or block).

Trigger

A new / changed motion

A new way to sell, renew, or expand needs its own scenario and guided-selling path.

Trigger

Rule changes

New guardrails, approval thresholds, or what a rep is allowed to configure.

Trigger

Commission-plan change

New commissionable fields, or a change to what drives commission, bonuses, or SPIFFs.

Trigger

New product line

Potentially new scenarios, documents, billing logic, and reporting cuts.

4.2 · The Gotchas

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

This landing page + brief

The playbook overview and the 5-minute audio brief — the front door for anyone running the project.

For the team

The one-paste prompt

Clone-for-customer → AGENTS.md drives the Blueprint checklist. Claude rips the repo and starts the walkthrough.

For the client

Scenario Map + Field Guide

The two Blueprint deliverables — signed off before Build, inherited by their admin after.

In the repo

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.

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 →