AP-223 Salesforce CPQ and Billing Consultant Accredited Professional Free Practice Exam Questions (2026 Updated)

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

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

The requirement:

Sales reps want to view net totals per product family at the quote level.

The admin created 3 price rules with summary variables → each rule sums net totals for a product family and writes to a quote field.

However, while this works, it is NOT optimal for performance.

Salesforce CPQ documentation clearly identifies Summary Variables + Price Rules as one of the most CPU-intensive parts of the Quote Calculator, especially when multiple rules are evaluated on large quotes.

✔ Why C is the correct answerUsing Quote Line Groups provides built-in auto-summary fields, including:

Group Total

Group Discount

Group Net Total

Group List Total

etc.

And importantly:

CPQ allows summary rollups from groups to quote-level fields automatically without running price rules.

Zero price rule executions → lower CPU usage

Faster calculation because summary variables do not have to iterate across all quote lines

Native functionality is always more performant than custom rules

Cleaner design: assign each product family to its own Quote Line Group

Benefits:This matches Salesforce CPQ’s recommended best practice:

Use Quote Line Groups for logical grouping and auto-summaries instead of summary-variable-based price rules whenever possible.

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.

When Salesforce CPQ attempts to amend a contract, it relies on a very specific set of fields on:

Contract

Subscription

Asset (for asset-based models)

Quote Line (for amendment and renewal linkage)

If mandatory amendment fields are missing, CPQ's amendment engine will throw errors — most commonly:

“Attempt to de-reference a null object”

This happens because CPQ expects certain relationships and data points that do not exist in legacy-migrated records unless populated correctly.

✔ Why C is the correct answerWhen migrating historical Contracts and Subscriptions, CPQ requires certain fields to be populated, such as:

Account

StartDate

EndDate

Contract Number

Pricebook2Id

Contracted = TRUE

ContractId

Product2Id

Quantity

StartDate

EndDate

ListPrice

SalesPrice

SubscriptionType

Status = Active

TermStartDate

TermEndDate

Most importantly:

OriginalContractedListPrice

OriginalContractedSalesPrice

OriginalQuantity

OrderProductId (for order-based renewals)

AssetId (required depending on renewal model)

Contract Required FieldsSubscription Required FieldsIf any of these fields are missing or incorrectly mapped, the amendment engine fails.

CPQ amendment logic does not require a source quote line for legacy migrations, nor does it block amendments on migrated data if all required fields are present.

Thus C is the only answer consistent with CPQ documented behavior.

❌ Why the other answers are wrongA. Migrated contracts and subscriptions cannot be amended using Salesforce CPQIncorrect.

Salesforce CPQ fully supports amendment of migrated contracts/subscriptions as long as the required data is populated.

B. Amendment requires asset-based renewal methodIncorrect.

Legacy migrations can use either:

Contract-Based Renewal, or

Asset-Based Renewal

There is no requirement to switch to asset-based renewal.

D. Legacy data missing lookup to source quote lineIncorrect.

A lookup to the original Quote Line (SBQQ__QuoteLine__c) is not required for amendments.

It is only needed to support:

Contracted pricing logic reuse

Certain renewal pricing behaviors

Some reporting use cases

Missing this field does not block amendments and does not cause this error.

INVEST criteria is a standard Agile user story quality framework.

Correct breakdown:

I — Independent

N — Negotiable

V — Valuable

E — Estimable

S — Small

T — Testable

Thus D is the correct choice.

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.

Salesforce Billing documentation states:

Posted Invoices cannot be edited, deleted, or reverted to draft.

Corrections must be performed through Cancel & Rebill.

Correct process:

Cancel & Rebill the posted invoice

The system automatically creates:

A Credit Memo for the incorrect invoice

A New Debit Invoice (unposted)

Admin corrects the Order / Order Product

Generate & post a new corrected invoice

Why the other options are incorrectOption

Issue

B. Change Posted → Draft

Impossible. Posted invoices cannot revert to draft.

C. Delete Invoice

Posted invoices cannot be deleted.

D. Credit the invoice manually

Does not follow the required cancel–re bill flow; also would not automatically issue corrected invoice.

Therefore A is the only Salesforce-compliant corrective action.

Efficient UAT in Revenue Cloud requires:

✔ B — Define acceptance criteria with the customerEnsures clarity on what “pass” means.

✔ D — Train UAT testers on the new functionalityUAT fails quickly if testers don’t know how to use CPQ/Billing.

✔ E — Finalize test plans before the build is completedEnsures UAT is ready and structured once the sandbox is available.

Incorrect options:

A: Consultants should NOT execute tests on behalf of customers.

C: Not all issues in UAT require change orders; many are defects to be corrected.

The three customer teams that must be involved in Revenue Cloud scoping are:

✔ A — Information (Product / Pricing owners)They define product catalog rules, pricing models, and offerings.

✔ B — Technology (IT/Architecture)Ensures integration, data migration, security, and platform alignment.

✔ C — Sales OperationsOwns quoting flows, approvals, discounting, sales motions, and user experience.

These teams define core CPQ processes.

Why others aren't required at scoping:Team

Why Not Required

D — Accounting/Finance

Essential for Billing scoping, but not required for CPQ-only scoping unless Billing is in scope.

E — Customer Service

Usually relevant for Service Cloud and CALM, not initial CPQ scoping.

F — Human Resources

Irrelevant to CPQ and Billing.

Thus A, B, C is correct.

When a Revenue Cloud project is escalated, the Project Manager is the role accountable for:

Overall project success

Scope, timeline, budget

Risk management

Issue resolution

Stakeholder coordination

Salesforce implementation methodology is clear:

The Project Manager owns project outcomes.

Thus D is correct.

The consultant discovers:

Multiple triggers

Workflows

Flows

Possibly recursion or conflicting automations… on the Opportunity, which is foundational for CPQ.

Salesforce Revenue Cloud Best Practice:Use one automation type (preferably Flow) to avoid conflicts, recursion, performance issues, and unpredictable ordering.

Too many automation types cause issues with:

CPQ Quote Sync

Opportunity → Quote event handling

Performance and CPU limits

Unpredictable execution order

Therefore:

✔ A — Recommend using a single automation type for best performanceThis aligns with:

Salesforce Well-Architected Framework

Salesforce CPQ implementation guidelines

General platform automation best practices

Why other options are incorrect:Option

Why Not Correct

B

Large Quote Threshold affects calculator performance, not Opportunity automation.

C

Multiple automation types is the problem, not the solution.

D

Accepting the current messy automation is not recommended before CPQ implementation.

Thus A is correct.

Setting Legal Entity on:

Order Product

Order Product Consumption Schedule

Must be scalable, bulk-safe, and future-proof.

The most performant and Salesforce-recommended approach is:

No additional DML required

Runs before insert and update

Bulk-safe

Better performance than Workflow or Process Builder

No need to use QCP, which only affects Quotes—not Orders or Schedules

✔ Before-Save Flow (Record-Triggered Flow)Thus D 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.

User Story:

“Sales users should be able to create new quotes with rate cards and account-specific discounts that honor originally negotiated pricing.”

This means the system must pre-store customer-specific negotiated prices.

In Revenue Cloud, the object used for this is:

✔ Contracted PricingContracted Pricing stores:

Account-specific price overrides

Custom discounting

Negotiated flat rates

Validity windows

When a new quote is created, Salesforce CPQ automatically applies Contracted Pricing to the relevant products.

Why the other options are incorrect:Option

Why Incorrect

B — Subscription

Tracks ongoing services, not negotiated pricing.

C — Order Product

Not used for quoting or negotiated rates.

D — Entitlements

Applies to support or warranty, not pricing.

Salesforce upgrades Preview sandboxes before production. To ensure testing is done on the next release before go-live:

✔ A — Review status.salesforce.com for release and sandbox cutoff datesThis tells you:

When sandboxes will upgrade

Deadlines for refreshing to get onto Preview

Release milestones

✔ C — Determine whether your sandbox is on a preview or non-preview instanceThis determines your next action:

Preview instance → sandbox upgrades early

Non-preview → sandbox upgrades after production

This is essential to test the implementation before production is upgraded.

Why B and D are incorrectOption

Why Incorrect

B — “All sandboxes upgrade at the same time”

False: preview vs non-preview sandboxes upgrade at different times.

D — “Submit a ticket to support to upgrade sandbox”

Salesforce does not move or upgrade sandboxes via support case. Release timing follows the published schedule only.

Final Answer: A, C

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 three core principles of scoping a Revenue Cloud (CPQ + Billing) project are:

✔ A — Alignment with customer on CPQ & Billing terminologyCPQ/Billing have specific terms (bundles, subscriptions, MRR, usage, amendments).

Shared vocabulary is essential for project success.

✔ C — Lead with business requirements and processSalesforce methodology stresses understanding:

Selling motions

Billing processes

Amendment/renewal lifecycle… before discussing configuration or technology.

✔ D — Think transformation before customizationRevenue Cloud succeeds when customers improve processes rather than recreating legacy systems.

Why the incorrect options fail:Option

Why Incorrect

B. Add new technology to existing process

Bad practice. Revenue Cloud encourages redesigning outdated processes, not replicating them.

E. Interview customer first before knowledge sharing

Opposite of best practice. Discovery is collaborative; knowledge sharing happens early.