AP-223 Sample Questions Answers

Salesforce Billing’s Hold Billing field on Order Product works exactly as follows:

When Hold Billing = Yes, Salesforce Billing does not generate invoice lines for that Order Product.

Once the user sets Hold Billing back to No, Billing:

Calculates the missed invoice periods

Creates catch-up invoice lines so billing is not lost

Correct Behavior (per Documentation)This means:

✔ Invoicing is suspended

✔ Catch-up invoice lines are created for the entire period Hold Billing was active

Thus, C is the correct and documented behavior.

Why the other answers are incorrectOption

Description

Why Incorrect

A

Prevents invoice document generation and emails

Misleading: the function specifically stops invoice line creation for the order product; it does not manage email notifications.

B

Hold Billing auto-resets on activation

False. Hold Billing is a manual field and does not auto-clear.

D

Only invoices after Hold Billing is set to No are created

Incorrect—Billing creates catch-up invoices for missed time.

Thus, C is completely aligned with Salesforce Billing behavior.

A governance structure is essential in every Revenue Cloud implementation.

It ensures:

✔ C — Clarity on roles & responsibilitiesAvoids confusion, ensures accountability.

✔ D — A communication plan between implementation team & customerCritical for issue management, design reviews, sprint planning.

✔ E — Alignment on assigned workEnsures no duplication, no missed tasks, and smooth execution.

Why A and B are incorrect:Option

Reason

A

Governance does not mean the team works independently.

B

Governance does not assign extra work to the customer.

Thus C, D, E is correct.

Scenario SummaryUniversal Containers sells a bundle “Corporate IT Solutions.”

Inside it is a product option: Hardware Firewall.

Requirement:

If the customer previously purchased that Hardware Firewall (historical purchase),

Then hide the product option inside the bundle during configuration.

This is a Configuration Rule

Using Selection/Filter logic to hide options

The rule must trigger as soon as the bundle loads, because the product option must be hidden before the user interacts with the bundle.

What type of Product Rule?Which Evaluation Event is Correct?Salesforce CPQ Product Rule Evaluation Events:

Event

When it Fires

Typical Use

Load

When the configuration page loads the first time

Hide/show options, preselect options, set initial values

Edit

On any user modification

Rerun rules based on changes

Load and Edit

Both events above

When both initial setup and change handling are required

Save

When the quote line editor is saved

Validation rules that block save

We need the product option to be hidden immediately when configuring the bundle.

It is not dependent on user edits.

It uses historical purchase data (Opportunity Product / Asset / Subscriptions).

In this requirementTherefore, the rule should fire at initial load only, not waiting for user interaction.

Always → not a valid Product Rule Event type in CPQ.

Save → too late; user would see the option before it's hidden.

Load and Edit → unnecessary; we do not need edits to trigger this rule.

Edit → would fail because hiding must occur before user interaction.

Why Not the Others?Salesforce CPQ Documentation AlignmentCPQ Product Rules documentation states:

Use Load when you want the rule to evaluate immediately when the configurator opens, typically for hiding, filtering, or preselecting options.

This matches the required behavior perfectly.

The question:

Which feature is needed to split Order Products into different Invoice Runs?

In Salesforce Billing, the feature that controls how order products are separated into different invoice runs is Invoice Group.

✔ Why Invoice Group is the correct answerThe Invoice Group field on:

Order Product

Order

Invoice

is used to:

Separate order products into different invoices within the same invoice run, or

Ensure specific order products are invoiced in different invoice runs entirely.

The Billing Engine evaluates Invoice Group when generating invoices:

Order Products with different Invoice Group values → will be generated on different invoices or different invoice runs, depending on the configuration.

This is the official Salesforce Billing mechanism for splitting invoice generation.

Salesforce Billing uses Usage Summary to combine usage records per:

Billing period

Order Product

Rating characteristics

To simplify future usage uploads after amendments, Billing requires a stable reference to group or map usage lines.

✔ Matching ID is designed exactly for this purpose.It is:

Unique

Persistent across amendments

Used by external rating or mediation systems

Can be used as an External ID

Other fields cannot uniquely support usage upload reconciliation.

Thus, E is the correct answer.

Efficient UAT requires:

B – Define acceptance criteria upfront

D – Train UAT testers on new Revenue Cloud processes and CPQ/Billing functionality

E – Finalize test plans before build phase completes to ensure readiness

Options A and C are incorrect:

Consultants should NOT execute tests for the customer (UAT = customer validation).

Not every issue in UAT is a change request; many are defects that must be fixed.

All answers you provided are confirmed correct based on Salesforce CPQ & Billing documentation and implementation methodology.

Send the next set whenever you're ready!

This use case describes a three-dimensional pricing model where the price of a product is determined by length × width × height. These values are user selections (likely stored on Quote Line fields), and CPQ must determine the correct price based on a matrix of dimensions.

Salesforce CPQ documentation identifies Lookup Tables used with Price Rules as the standard method for implementing matrix or multi-attribute pricing.

✔ Why Price Rule with Lookup Table is the correct answerSalesforce CPQ Lookup Tables allow you to store pricing data externally from the product record and return the correct price based on multiple inputs.

Lookup tables can key off of multiple dimensions, e.g.:

Length

Width

Height

A price rule performs the lookup at calculation time and sets:

List Price, or

Custom price field

Create custom fields on Quote Line:

Length__c

Width__c

Height__c

Build a Lookup Table with key columns:

Length range

Width range

Height range

Resulting price

Build a Price Rule that uses:

Price Conditions → to map entered dimensions

Lookup Query → to fetch matching price

Price Action → to set the Quote Line's Unit Price

Relevant capabilities:Typical CPQ design for dimensional pricing:This is exactly the pattern Salesforce recommends for multi-attribute pricing.

❌ Why the other options are incorrectA. Percent of TotalUsed for:

Support fees

Add-on fees based on parent productsNot for dimensional pricing.

B. Multi-Dimensional Quoting (MDQ)Used for:

Term-based pricing (Year 1, Year 2, Year 3)

Usage tiers over time

MDQ does not support 3-dimensional physical attributes.

C. Discount ScheduleSupports:

Volume tiering

Quantity-based pricing

Does not support multi-attribute dimensional pricing.

Your CPQ org is performing poorly because:

30 Process Builders running on Quote & Opportunity

Heavy customization

Excessive automation layers

Salesforce best practice for Revenue Cloud:

Remove technical debt BEFORE designing the CPQ/Billing solution.

Thus:

✔ C — Baseline performance and fix technical debt firstReasons:

CPQ depends heavily on synchronous calculations

Custom automations drastically increase sync time

Process Builder is deprecated; should be migrated to Flow

Poor performance must be cleaned before CPQ design

Why others are wrong:Option

Why Incorrect

A — Upgrade CPQ

Upgrading cannot fix org-level technical debt.

B — Mark issues out-of-scope

Avoiding technical debt leads to project failure.

D — Extend customization

Adding code on top of a broken process worsens performance.

Thus C is correct.

A Revenue Cloud consultant leading scoping must have:

A – Excellent communication: Key for translating technical and business requirements.

B – Planning/monitoring/review skills: Required to drive structured discovery workshops.

E – Awareness of design pitfalls & mitigation: Ensures a scalable CPQ/Billing architecture.

Options C and D are irrelevant: competitor knowledge or sales quota experience are not key skills for scoping a CPQ/Billing project.

When Price Rules are insufficient for complex pricing logic, Salesforce CPQ documentation directs consultants to the Quote Calculator Plugin (QCP) as the next escalation point.

QCP enables custom JavaScript logic executed inside the CPQ Quote Calculator, allowing manipulation of:

List price

Net price

Quantity

Custom logic loops

Conditional calculations beyond standard rule capabilities

Flows or Apex should not manipulate pricing during calculation because they run outside the CPQ calculator, causing inconsistent pricing results.

Hence the correct next step is QCP.

Requirement:

Product may be taxable or tax-exempt depending on a custom field (Industry).

In Salesforce Billing:

Tax rules determine whether a product line is taxable or exempt.

Tax rules can be driven by custom logic using:

Custom fields

Flow

Apex

Determination scripts

Therefore:

✔ C. Use automation to set the Tax Rule based on the custom field.Why not the others?Option

Why Incorrect

A. Tax Treatment

Outputs tax result, but the rule determining taxability is the Tax Rule, not Tax Treatment.

B. Billing Rule

Controls invoice schedule, NOT taxability.

D. Revenue Recognition Rule

Controls revenue, not tax.

Thus C is the only valid solution.

The Salesforce CPQ calculation sequence includes:

Internal Initialization

QCP: onInitialization()

CPQ: Calculate Formulas (pre-calculation)

Price Rule Evaluation: Before Calculate

QCP: onCalculate()

Price Waterfall (Pricing Engine)

QCP: AfterCalculate()

Option D matches this exact order:

internal initialization → on Initialization → calculate formulas → Before Calculate → calculate quantities → On Calculate → Price Waterfall → After Calculate

ARR__c exists on Quote Line (SBQQ__QuoteLine__c) and must appear on:

Opportunity Line Item for pipeline reporting

Salesforce CPQ automatically syncs Quote → Opportunity Line Item when:

The field exists on both objects

The Field API Name and Field Type match

This requires zero automation, no flow, no price rules.

These three patterns negatively impact Revenue Cloud scalability and performance:

✔ A — Multiple automation types on a single objectTriggers + Workflows + Flows create:

CPU limit issues

Debug complexity

Recursion

Unpredictable execution order

This is a major anti-pattern.

✔ B — External API calls during pricing sequenceQCP or Price Rules must never call external APIs because:

They block calculator execution

Cause timeouts

Dramatically slow down quote save time

This is a severe performance issue.

✔ C — Extensive custom fields on Quote LineEvery Quote Line field:

Increases calculation payload size

Increases JSON transmitted to the calculator

Slows down Quote Calculation

Impacts large quotes significantly

Why D and E are not performance design flawsOption

Why Not a Design Problem

D — Quotes with 200 lines

CPQ supports scaling to far more than 200 lines with proper configuration.

E — Invoices with 200 lines

Billing handles this volume normally. Performance issues arise at thousands of lines.

The requirement:

"Bulk discounts include previously purchased quantities for pricing calculations."

This refers to cross-order discounting, where historical quantities affect pricing on the new quote.

To support this:

✔ B – Contracts, Subscriptions and Assets should be populated with historical dataCPQ reads existing Subscriptions/Assets to determine previously purchased quantities.

Historical install base must be migrated for correct discounting.

✔ E – Discount schedules with Cross Orders checkedSalesforce CPQ includes an OOTB feature:

Discount Schedule → Cross Orders = TRUEThis allows the quantity tiers to consider historical purchases.

Incorrect options:

A Custom Action unnecessary unless data is external (not indicated here).

C Summary variables cannot aggregate off-contract historical quantities.

D Migrating invoices is not required for quantity-based pricing.

Thus, the validated answers are B and E.

The requirement is:

When configuring a bundle, if the customer has previously purchased a hardware firewall, the Hardware Firewall product option should be hidden during bundle configuration.

This means the Product Rule must evaluate immediately when the bundle configuration UI loads, so that the option is hidden before the user begins configuring.

Salesforce CPQ documentation clarifies the evaluation events for Product Rules:

Evaluation Events in CPQ Product RulesEvaluation Event

When it Fires

Use Case

Load

Fires immediately when the configurator opens

Use this when hiding options or preselecting options based on external or historical data, Assets, Subscriptions, etc.

Load and Edit

Fires on initial load and every time the user makes changes

Use when rules may need re-checking with every MODIFY step.

Save

Only fires when clicking Save

Use when validating configuration before saving (e.g., preventing invalid combinations).

Always

Fires during all events including load, edit, and save

Rarely used; typically only for enforcement rules.

You need the option hidden right when the configurator loads.

The rule uses historical data (previously purchased hardware firewall).That data does not change in real time during the configuration session.

There is no need to re-check during every selection or on save.

Why Load is the correct answer:Therefore, using Load provides:

Optimal performance

Immediate user experience consistency

No unnecessary re-evaluations

Overkill; runs multiple times unnecessarily.

Negative impact on performance in large quotes/bundles.

Why the other options are incorrect:❌ A. Always

Hiding an option at save time is too late.

The user should not see the firewall option at all if they already purchased it.

❌ B. Save

This re-evaluates the product rule every time the user interacts.

Not required because the “past purchase” condition does not change during configuration.

Adds unnecessary processing.

❌ C. Load and Edit

A partner leading a Revenue Cloud Scoping session requires:

✔ A — Strong communication skillsEssential for facilitating workshops, documenting requirements, and aligning stakeholders.

✔ B — Effective at planning, monitoring, reviewingScoping is structured, requires:

Agenda control

Risk identification

Note capture

Validation cycles

✔ E — Understanding design pitfalls & mitigationCritical in CPQ + Billing, where poor scoping leads to:

Wrong pricing model

Incorrect renewal logic

Billing edge cases

Data migration problems

A good partner surfaces these risks early.

Why the wrong answers are incorrect:Option

Why Incorrect

C — Knowledge of competitor products

Not relevant to scoping Salesforce Revenue Cloud.

D — Experience with quota-carrying sales roles

Helpful but not foundational to scoping complex CPQ + Billing architecture.

Final answer for Q49 = A, B, E

Salesforce CPQ scoping guidance always starts with Business Process Mapping to understand:

Lead → Opportunity → Quote → Contract → Order → Billing → Renewal lifecycles

How CPQ/Billing should support the business

Products, documents, e-signature, and order management all come after process mapping.

Thus A is correct.

Error:

“Attempt to de-reference a null object” while amending migrated contracts/subscriptions.

This is the classic CPQ issue when legacy contract/subscription data is missing required fields.

Subscription Start / End Dates

Quantity

Price fields

Billing Frequency

Term

Amendment-related fields (AmendmentStartDate, etc.)

Subscription Product

Related Order Product

Related Asset (if asset-based)

During amendment, CPQ expects:Missing or incorrectly populated fields cause CPQ code to attempt to reference null values → null pointer exception.

Thus:

✔ C. Required fields are missing or incorrectly populated

Why the other options are incorrect:Option

Why Incorrect

A. Migrated contracts cannot be amended

False. Salesforce explicitly supports amendments on migrated data if fields are populated correctly.

B. Asset-based renewal required

Not required—CPQ supports quote-based and asset-based renewal models.

D. Missing lookup to source Quote Line

Not required for legacy subscriptions; CPQ amendments work without source quote lines.

Thus C is the only valid root cause.