Salesforce CPQ and Billing Consultant Accredited Professional AP-223 Exam Dumps: Updated Questions & Answers (December 2025)

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.

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

In every Salesforce CPQ implementation, Product Bundles are one of the core configuration capabilities that must be discussed during scoping and discovery—even if the customer does not initially think they need them.

✔ Why the correct answer is BB. Yes, bundle configuration should be introduced and it's up to the customer to decide whether they need it or not.

This aligns fully with Salesforce CPQ implementation best practices, discovery methodology, and the guidance in CPQ documentation and study resources.

Why bundles must be discussed in scopingSalesforce CPQ Bundles are used to solve many common quoting problems:

Grouping products together

Managing optional/required components

Handling feature selections

Automating inclusion, exclusion, or quantity logic

Supporting configuration rules

Ensuring sales reps configure solutions correctly

Improving quote accuracy

Providing guided selling experiences

Because bundles fundamentally shape:

Product catalog architecture

Pricing structure

Rules design

Quote line generation

Amendment/Renewal behavior

Order + Billing outputs

…they must be addressed early during discovery and scoping to avoid major redesign later.

Salesforce implementation playbooks emphasize:

Introduce all CPQ capabilities during discovery.

Allow the customer to confirm whether a capability meets their use cases.

Document decisions in the solution design before build.

Therefore, bundles should always be a topic of discussion, but the customer chooses whether they need them based on business requirements.

❌ Why the other options are incorrectA. “Bundle configuration is necessary and should always be implemented.”Incorrect because:

Not all customers need bundles.

Some catalogs are simple, flat, or priced per unit with no component logic.

Salesforce CPQ documentation does not state bundles are mandatory.

C. “If they don’t use bundles now, they won’t need them later.”Incorrect because:

Customers often evolve pricing and product strategies.

Many legacy quoting tools do not support bundles, so current-state ≠ future-state.

CPQ discovery must capture future-state needs.

D. “Assume no bundle configuration unless customer brings it up.”Incorrect because:

Customers often don’t know what CPQ bundles can do.

CPQ consultants are responsible for educating customers on capabilities.

Failing to introduce bundles leads to:

Incorrect product catalog design

Broken pricing logic

Large rework later in the project

This contradicts CPQ best-practice discovery methodology.

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.

The Order Management Plugin (OrderPlugin2) in Salesforce CPQ allows architects to override the default behavior of CPQ when generating Orders from Quotes.

According to CPQ developer documentation, the plugin can override:

Order start date

Order end date logic (in limited ways)

Order product behaviors

The key supported override is specifically:

Setting the Order Start Date programmatically

When dealing with large quotes, Salesforce CPQ may hit platform governor limits (CPU time, SOQL limits, etc.) during save and recalculation.

Salesforce CPQ provides the Large Quote Threshold setting, which instructs CPQ to switch to a more efficient calculation mode once the quote line count exceeds the threshold.

The Salesforce documentation states:

Large Quote Threshold should be set to a number below the volume that triggers governor limits during testing.

It is not set arbitrarily; it must be based on empirical volume testing results.

This avoids synchronous processing of too many quote lines and forces CPQ to optimize its calculation path.

Therefore, option D is the correct implementation.