Count what your quoting engine still uses before you plan the move

Salesforce CPQ is closed to new customers but still runs, so an inventory of rules, scripts and templates should decide when you move to Revenue Cloud Advanced.

Old CPQ Extractor Classifier Direct mappings Redesign Gap list Scope sheet 12 months of quotes changes shape no equivalent now, later or stay
Old configuration is extracted, classified three ways, and merged into one scope sheet with a move decision.
On this page
  1. Maps directly, changes shape, no equivalent
  2. Counting what’s there and what still runs
  3. The spreadsheet
  4. 290 items, then a year of quotes
  5. Let the gap list pick the date

Last month Salesforce stopped selling CPQ to new customers. For an org that already runs it, nothing changed that day. Quotes still calculate, renewals still generate, and support is still there. End of sale and end of life are different events, and only the first one has happened.

What did change is the mood. Migration timelines are getting drawn, and the ones that start from the vendor’s calendar have it backwards. Before a plan, I want a spreadsheet: every price rule, product rule, calculator script, quote template and integration in the old engine, each tagged with what happens to it in Revenue Cloud Advanced.

Maps directly, changes shape, no equivalent

Each item gets one of three classes.

“Maps directly” means the same idea exists on the other side and the work is mostly re-entry. A price rule that looks up a discount from a table is the usual case.

“Changes shape” means the outcome survives and the mechanism doesn’t. You redesign it, test it again, and whoever maintains it has to learn the new tool.

“No equivalent” means nothing on the target does this job as built. Someone has to decide whether to rebuild it in code, change the business process, or drop it.

This is where the common item types tend to land. Treat it as a starting guess and check it against your own org, since the target product is still adding features every release.

Old item Closest target Usual class
Price rule with a lookup table Pricing procedure with a decision table Maps directly
Price rule that chains off other rules Ordered steps in a pricing procedure Changes shape
Product rule (validation, selection) Configurator rules Changes shape
Quote template Document generation template Changes shape
Calculator script None like for like No equivalent
Integration reading managed package objects Standard quote and order objects Changes shape

Calculator scripts get their own warning. They’re JavaScript running inside the managed package’s calculation, and people wrote them because the declarative rules couldn’t express something. Whatever is in there is the logic that didn’t fit.

Counting what’s there and what still runs

The raw counts are easy. Each block below is one SOQL query that runs as is in the Developer Console query editor.

Active price rules, by where they run:

SELECT SBQQ__TargetObject__c, COUNT(Id) total
FROM SBQQ__PriceRule__c
WHERE SBQQ__Active__c = true
GROUP BY SBQQ__TargetObject__c

Active product rules, by type:

SELECT SBQQ__Type__c, COUNT(Id) total
FROM SBQQ__ProductRule__c
WHERE SBQQ__Active__c = true
GROUP BY SBQQ__Type__c

Calculator scripts, then quote templates:

SELECT Id, Name, LastModifiedDate
FROM SBQQ__CustomScript__c
SELECT Id, Name, LastModifiedDate
FROM SBQQ__QuoteTemplate__c

Integrations don’t live in any CPQ object, so I list those by hand.

Usage is harder, because CPQ doesn’t record which rules fired on a quote. Templates are the exception, since every generated document points back at its template:

SELECT SBQQ__QuoteTemplate__c, COUNT(Id) docs
FROM SBQQ__QuoteDocument__c
WHERE CreatedDate = LAST_N_MONTHS:12
GROUP BY SBQQ__QuoteTemplate__c

For rules, I infer usage from what they depend on. Product rules attach to products through configuration rules, and price rules test fields through price conditions. If the products and field values a rule needs haven’t appeared on a quote line in a year, the rule hasn’t done anything in a year. So I pull what was quoted in the last 12 months, where each active product rule is attached, and what each active price rule tests:

SELECT SBQQ__Product__c, COUNT(Id) line_count
FROM SBQQ__QuoteLine__c
WHERE CreatedDate = LAST_N_MONTHS:12
GROUP BY SBQQ__Product__c
SELECT SBQQ__ProductRule__c, SBQQ__Product__c
FROM SBQQ__ConfigurationRule__c
WHERE SBQQ__Active__c = true
SELECT SBQQ__Rule__c, SBQQ__Object__c, SBQQ__Field__c, SBQQ__Value__c
FROM SBQQ__PriceCondition__c
WHERE SBQQ__Rule__c IN (
  SELECT Id FROM SBQQ__PriceRule__c WHERE SBQQ__Active__c = true
)

The quote line query will hit row limits in a busy org, so run it a month at a time. The Bulk API won’t take a GROUP BY, so the other route is to export the raw lines and count them in the sheet. And inference is only inference. A rule whose conditions are always true looks “used” whether or not anybody would miss it. For those I ask the pricing team, which is slower and more accurate.

The spreadsheet

One row per item, seven columns. This is the layout as CSV so you can paste it straight into a sheet.

item,type,count,used_last_12_months,target_equivalent,class,effort_days
Volume discount lookup,price rule,1,yes,Decision table in pricing procedure,maps directly,0.5
Regional uplift chain,price rule,6,yes,Ordered pricing procedure steps,changes shape,5
Accessory compatibility check,product rule,14,yes,Configurator rules,changes shape,8
Legacy distributor bundle rules,product rule,22,no,,retire,0
Tiered freight calculation,calculator script,1,yes,None,no equivalent,TBD
Standard quote PDF,quote template,1,yes,Document generation template,changes shape,4

count lets you group near-identical rules into one row instead of pretending 22 rules are 22 decisions. used_last_12_months is the column that shrinks the project. Anything marked no gets retire in the class column and an effort of zero, and you turn it off in the old engine now.

Leave effort as TBD on the no-equivalent rows. A number there is a guess, and it’ll get added up with the real ones.

290 items, then a year of quotes

Picture a manufacturer I’ve invented, Brackenridge Tools, numbers and all. It sells industrial hand tools through direct reps and distributors. The inventory comes back with 212 price rules, 64 product rules, 3 calculator scripts and 11 quote templates. That’s 290 items, which looks like a two-year program.

Then twelve months of quotes go in. 168 of the 290 touch nothing that has been quoted in a year: discontinued product lines, a distributor program that ended, templates for a business unit that was sold. That leaves 122.

Of those, 86 map directly. Another 27 change shape, mostly product rules and the templates. And 9 have no equivalent: the three scripts, plus six price rules that only work because of them.

One of the nine is a calculator script that prices freight in tiers, by total shipment weight and destination zone, across every line on the quote. It reads a custom rate table, splits the charge back across lines for margin reporting, and has a special case for pallets. It’s about 400 lines of JavaScript, and nobody has written down what it’s supposed to do.

The 86 are a few weeks of careful data entry. The 27 are a real backlog with estimates you can trust. The 9 are where the schedule lives, because each one needs a design decision before it needs a build, and the freight script alone needs finance, logistics and sales operations to agree on what the rule is.

Let the gap list pick the date

The scope sheet at the end comes down to one line: how many no-equivalent items there are, and whether each has an owner and a decision.

If the gap list is empty or trivial, move soon. You’re paying to maintain a product that won’t get new investment, for no reason.

If it’s nine items and three of them are core to how you price, wait, and spend the waiting on those. Write the specs. Check each new release of the target against the list, since some gaps close on their own. Retire the 168 in the meantime.

If the gaps are the business, stay put for now and say so out loud, with the list as the reason.