AP-223 CPQ and Billing Consultant Accredited Professional Questions and Answers

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!

When an escalation occurs on a Revenue Cloud implementation, the question is:

Who is ultimately responsible for the success of the project?

While many roles contribute, the Project Manager (PM) is the one accountable for:

Scope

Budget

Timeline

Risk & issue management

Cross-team coordination

Customer communication

Driving escalations and resolutions

Salesforce project methodology is clear:

The Project Manager owns overall project success.

Why the other roles are not the primary accountable party:Role

Why Not Responsible for Overall Success

Technical Architect

Owns technical integrity, not project success.

Solution Architect

Owns functional solution design, not delivery metrics.

Developer

Executes tasks, not responsible for project outcome.

Customer Success Manager

Supports customer relationship but not delivery execution.

Thus, the correct answer is:

✔ B — Project Manager

Amendments in Salesforce Billing must maintain clean financial continuity. Any financial artifact still in an incomplete or unsettled state breaks future invoicing, because Billing cannot prorate, advance, or reconcile future periods correctly.

✔ B — Subscription linked to Order Product with unpaid invoice linesUnpaid invoice lines cause:

Billing to treat the subscription as financially “not settled”

Block future billing for that subscription

Incorrect Next Billing Dates

This is a documented reason for missed or incorrect invoice generation.

✔ C — Subscription linked to Order Product with draft invoice linesDraft invoice lines mean the invoice is not posted, so:

Revenue and billing are not finalized

Billing engine cannot determine the next billing boundary

Amendments generate incorrect billing periods

This absolutely causes incorrect future invoicing.

✔ D — Subscription linked to an unallocated paymentUnallocated payments interfere with:

Aging

Balance-based billing logic

Proper allocation of future charges

Billing expects charges and payments to be reconciled.

Why A and E are not correct:Option

Reason

A — Not contracting the amendment order

You must contract an amendment order, but failure to do so stops renewal/amendment flow, not future invoicing behavior.

E — Contracting from amended opportunity

This is the correct and expected process, not a problem.

Thus B, C, D are 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.

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.

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.

The user story states that sales users should inherit previously negotiated pricing when quoting for existing customers.

In Salesforce CPQ, the object that stores account-specific negotiated prices is:

Contracted Pricing (SBQQ__ContractedPrice__c)

This object overrides standard list prices during quoting based on:

Account

Product

Pricebook

Contract linkage

Therefore, in addition to migrating Accounts, Contracts, and Quotes, the missing legacy pricing data must be loaded into Contracted Pricing.

Requirement:

Provide an aggregated view of current goods and services on a contract.

This refers to consolidating all active entitlements, subscriptions, assets, and amendments.

Salesforce Revenue Cloud feature for this:✔ E. Customer Asset Lifecycle Management (CALM)CALM provides:

A unified, aggregated view of:

Active assets

Entitlements

Subscriptions

Amendments

Renewed services

Tracks lifecycle changes from:

Orders

Amendments

Cancellations

Upgrades

Represents the source of truth for what the customer owns today.

Why not the others?Option

Why Incorrect

A. Amendments

These modify contracts but do NOT aggregate current products.

B. Orders

Represent transactions, not current state.

C. Subscriptions

Only subscription items, not full lifecycle items or non-subscription goods.

D. Renewals

Only track renewal processes, not aggregated state.

Only CALM provides an aggregated, contract-aligned view of all customer entitlements.

User Story“As a pricing manager, bulk discounts must include previously purchased quantities for pricing calculations on the quote to reward loyal customers.”

This refers to historical purchases influencing tiered or volume discounts.

In Salesforce CPQ, the only native feature that supports “include prior purchases when calculating discount tiers” is:

✔ Discount Schedules with Cross Orders enabledThis setting tells CPQ to:

Look at existing subscriptions, assets, orders, and previous quote lines

Aggregate prior quantities

Apply tiered volume discount based on the total owned quantity + new quantity

But for Cross Orders functionality to work…

✔ Historical Subscriptions / Assets must existSo you must migrate historical:

Contracts

Subscriptions

Assets (if asset-based ordering)

Without that data, CPQ cannot aggregate historical quantities.

Correct answer: B and E✔ B — Populate Contracts, Subscriptions, and Assets with historical dataCPQ needs these to calculate previously purchased quantities.

✔ E — Discount Schedules with Cross Orders checkedThis is the actual feature that uses prior purchased amounts to determine discount tiers.

Why the other options are not correct:Option

Why Incorrect

A — Custom Action

Unnecessary. CPQ has native Cross Orders behavior.

C — Summary Variable

Summary variables do not summarize external historical purchases.

D — Migrate Orders & Invoices

Not required for CPQ pricing. Only Subscriptions/Assets matter.

For a large Enterprise Revenue Cloud (Salesforce CPQ + Billing) implementation, the key themes in all Salesforce delivery guidance and project best practices are:

Governance and change control

Design-first, then build

Raising scope-impacting changes through the Project Manager

Architect accountability for solution integrity, PM accountability for scope/timeline/budget

Let’s walk through why C is correct and why the other options conflict with typical Salesforce CPQ/Billing implementation best practices.

1. Context of the ScenarioYou are in the Build phase and:

You already have a design with:

Multiple Lookup Price Rules implementing complex pricing.

New information emerges:

Additional pricing logic

External data stores that must be incorporated

Need to modify existing lookup rules

Need to create additional rules

Need API development (integration work)

This is not a cosmetic tweak; it is:

Scope-impacting (new integration/API work, new logic)

Design-impacting (pricing architecture changes)

Potentially timeline and budget impacting

Therefore, this triggers formal change control.

2. Why Option C is CorrectC. Communicate these changes to the project manager who will evaluate the impact to scope, timeline and budget then determine the next course of action

This aligns with standard Salesforce implementation and project governance principles:

Any change that affects scope, complexity, or integration must be raised to the Project Manager (PM)

Project Manager is responsible for:

Scope management

Timeline & milestones

Budget & resourcing

Managing change requests and stakeholder approvals

The PM will:

Evaluate impact with:

Solution Architect (for technical/design impact)

Tech leads / Dev leads (for effort estimation)

Decide:

Whether a Change Request (CR) is needed

How to re-prioritize sprints, adjust backlog

Whether additional budget / time is required

How to communicate to customer stakeholders

This preserves:

Design integrity (Architect still evaluated the solution)

Project discipline (PM governs scope/timeline/budget)

Traceability and documentation (updated design docs, backlog, CRs)

This is exactly how a large enterprise Revenue Cloud (CPQ + Billing) program is expected to run.

3. Why the Other Options Are Not AppropriateA. “Adjust as long as we ' re in build phase”A. Communication to the customer ongoing adjustment can be made as long as we ' re in the build phase.

Problems:

Implies uncontrolled scope creep:

“As long as we’re in build, we can just keep adjusting.”

No mention of:

Impact to scope, timeline, budget

Formal change control

Involvement of PM or Architect

In a complex CPQ/Billing implementation, this would:

Break governance

Risk missed deadlines and budget overruns

Create misaligned expectations with the customer

So A contradicts standard methodology and enterprise delivery practices.

B. “Implement then review with the Solution Architect”B. Implement the lookup price rules immediately then review with the solution Architect.

Problems:

Sequence is wrong:

You never build first and ask the Architect later on large-scale pricing and integration changes.

This can cause:

Misalignment with overall pricing architecture

Conflicts with other CPQ/Billing components (e.g., Amendments, Renewals, Billing logic)

Rework if the Architect has a different approach

Still no mention of PM or scope/timeline/budget impact.

This violates both design governance and project governance.

D. “Architect then immediate implementation (no PM)”D. Consult with the solution Architect first who will expedite the updates to the design documents, then implement the changes immediately.

This is closer, but still incomplete:

Good:

You involve the Solution Architect.

You talk about updating design documents.

But:

No involvement of the Project Manager.

No consideration of:

Impact to scope

Impact to timeline

Impact to budget

For “large Enterprise Revenue Cloud” projects, Architect ≠ PM:

Architect owns technical solution integrity

PM owns project plan, change control, stakeholder approvals

So D ignores formal change management which is critical at enterprise scale.

E. “If low effort, just do it; else next sprint”E. Gather more details, if it requires a low level of effort then implement immediately before starting the next sprint. Otherwise complete on the subsequent sprint.

Problems:

Consultant is unilaterally deciding based on “low effort”:

No PM.

No formal scope/time/budget impact evaluation.

This might be okay for minor cosmetic or non-functional changes in a small project, but:

Here we have:

Complex pricing

Multiple lookup price rules

External data store integrations

API development

This is never “just low effort”.

For a large enterprise Revenue Cloud implementation:

This bypasses governance, change control, and approvals.

So E promotes ad hoc scope changes, which is against standard practice.

4. How This Ties Back to Salesforce CPQ & Billing Best PracticesIn Salesforce CPQ and Billing implementations, especially when dealing with complex pricing logic and external integrations:

Complex Pricing (Lookup Price Rules):

Changes can affect:

Quote calculation performance

Sequential dependencies with Price Rules, Discount Schedules, QCP, Billing logic

May cause downstream issues in:

Orders, Invoices, Revenue Schedules, Amendments, Renewals

External Data Stores & API Development:

Introduces:

New integration patterns

Error handling, retries, timeouts

Security and governance requirements

Impacts:

Technical design

Test strategy (SIT, UAT, performance testing)

Possibly non-functional requirements

Because of that, Salesforce project documentation and implementation guidance emphasize:

Raising such changes via Project Manager

Having the Solution Architect assess and update:

Solution design

Integration architecture

Managing it formally as a change request if it affects:

Scope

Timeline

Budget

This is exactly what Option C describes at the right level of responsibility.

Document generation performance in CPQ depends heavily on template content size, not price rules or QLE performance.

✔ C — Use compressed image formatsLarge JPG/PNG images dramatically slow down:

Template rendering

PDF generation

Email attachment creation

Compressing images is a documented best practice.

✔ E — Reduce the number of line columns in the quote documentEach additional column:

Adds more data retrieval

Increases merge time

Slows PDF rendering

This is one of the primary causes of slow Quote Document generation in CPQ.

Why the other answers are incorrectOption

Why Wrong

A & B — Product rules / constraints

They affect quote calculation, not document generation.

D — Fields in QLE

QLE configuration does not affect document generation speed.

Thus C and E are correct.

Successful exit criteria for User Acceptance Testing (UAT) is:

✔ Customer Acceptance Sign-offThis means:

All test cases have passed

All critical defects are resolved

Stakeholders approve the solution

The project is cleared to move into deployment

This is documented in Salesforce Implementation Lifecycle.

Why other choices are incorrect:Option

Why Wrong

A — Change Order

Change orders happen when new scope is introduced, not an exit criterion for UAT.

C — Design Document

Completed earlier during design phase.

D — Sandbox to Prod Migration

Happens after UAT sign-off.

E — Deployment plan

Prepared before deployment, not a sign of UAT completion.

Thus B is the only correct exit criterion.

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.

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.

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

Revenue Cloud implementations should NOT replicate outdated legacy CPQ logic.

Instead, Salesforce best practices require business transformation:

Understand current and future-state processes

Challenge legacy limitations

Use standard functionality wherever possible

Remove unnecessary customizations

✔ Correct Answer: COptions A, B, and D represent anti-patterns:

Option

Why Incorrect

A — Map legacy CPQ logic

Leads to replicating outdated processes rather than improvement.

B — Customize UI to mimic legacy

Increases technical debt and destroys scalability.

D — Keep legacy CPQ

Two CPQ systems create conflicts and are not recommended.

Thus C is correct.

Invoice Scheduler Settings:

Target Date = Jan 15

Bill Usage Charges = FALSE

This means:

The scheduler will generate invoice lines for Order Products only, not usage summaries.Thus the correct rule is:

✔ A — Order Products with Next Billing Date equal to or earlier than January 15

Why the other options are wrong:Option

Why Incorrect

B — Usage Summaries

Ignored because Bill Usage Charges = False.

C — Next Billing Date equal to or after

Billing only generates lines for dates < = Target Date.

D — Next Charge Date

Not used by Invoice Scheduler.

Thus A is correct.

Before a scoping session, the consultant should understand:

A – Sample proposals → reveals quoting format, pricing models, product structure.

B – Product brochures → clarifies offerings, catalog categories, bundles.

D – Approval matrix → shows governance controls required in CPQ.

Incorrect:

C Salesforce release notes are irrelevant to understanding customer requirements.

E Financial statements do not contribute to CPQ/Billing scoping.

Correct answers: A, B, D.

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 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

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.