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

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

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

A solid governance structure is a required component of every Salesforce Revenue Cloud implementation (CPQ + Billing). Salesforce's project methodology stresses governance for:

Clear roles and responsibilities

Alignment across business and technical teams

Controlled communication flows

Coordinated delivery

Risk and issue management

Change control

Let's evaluate each option:

✅ A. To get agreement on the roles and responsibilities of the implementation team and customerThis is one of the core purposes of governance.

The RACI structure (Responsible, Accountable, Consulted, Informed) is part of governance setup and ensures:

No duplication of work

No gaps in ownership

Clear escalation paths

✔ This is correct.

❌ C. To ensure the implementation team can work independently with little customer inputThis is the opposite of governance.

Revenue Cloud projects require constant alignment with the customer across:

Catalog structure

Pricing rules

Billing cycles

Renewals

Integration design

Customer involvement is essential.

✖ Not a valid reason.

❌ E. To assign more work to the customerGovernance is not a method to increase customer workload.

It ensures collaboration, not burden shifting.

✖ Incorrect.

✅ B. To establish a communication plan between teams and coordinate the workGovernance defines how:

PMs communicate

Status reports occur

Risks/issues are escalated

Decisions are documented

This is a fundamental governance objective.

✔ Correct.

✅ D. To ensure the implementation team is aligned with the customer on assigned workExactly.

Governance guarantees alignment on:

Scope

Requirements

Sprint commitments

Priorities

Change requests

✔ Correct.

✔ Final Verified AnswerA, B, D

These are the three factors that increase scope during legacy data migration for Revenue Cloud:

✔ A — Extracting from multiple sources takes more time and resourcesIf legacy data is spread across multiple CRMs, ERPs, billing engines, or flat files, this increases:

Extraction complexity

Mapping effort

Data cleansing time

This always expands project scope.

✔ B — Fragmented or incomplete information must be aggregated and validatedIf legacy data is dirty or inconsistent:

Amendments fail

Renewals break

CPQ calculations are wrong

Billing proration becomes inaccurate

Data validation + cleanup = additional scope.

✔ D — Large data volumes take longer to loadFull loads of:

Order Products

Subscriptions

Assets

Contracts

…can take hours to days, requiring:

Batch loading

Testing

Restart planning

Performance tuning

This clearly expands scope.

Why C and E are not correct:Option

Reason

C — External objects eliminate migration

Completely false. CPQ/Billing cannot use external objects for core processes such as pricing, contracting, amendments, renewals, invoicing.

E — Amendments/Renewals require customizations

Not a migration consideration; it is a design topic, not a factor that expands migration scope.

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.

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.

SKU rationalization reduces catalog complexity and improves CPQ performance by merging duplicate or similar products.

✔ A — Same product names with different attribute valuesUse Product Options, Attributes, or Configuration Attributes instead of separate SKUs.

✔ C — Same product names with different bulk discount levelsUse Discount Schedules instead of duplicating products.

✔ E — Same product names commonly found in the same bundleUse one product with options/rules, rather than multiple redundant SKUs.

Why others are incorrect:Option

Why Wrong

B — Same products with different serial numbers

Serial numbers belong on Assets, not separate products.

D — Same names with different terms

Use Subscription Term or Term picklist, not separate SKUs.

Thus A, C, E is correct.

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.

The Salesforce Safe Harbor statement exists to remind customers:

They should only make scoping, planning, design, and purchasing decisions based on current, available functionality, not forward-looking statements or roadmap presentations.

Salesforce does not guarantee:

Release timing

Exact feature delivery

Backward compatibility

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.

Salesforce CPQ performance can degrade with:

Too many price rules

Sequential calculator complexity

Recursion

90 rules is high, so optimization is needed.

✔ B. Implement Lookup Price RulesLookup Price Rules reduce:

Rule count

Condition logic

Maintenance complexity

A lookup table collapses many price rules into one rule, significantly improving performance.

✔ C. Use Quote Calculator Plugin (QCP)QCP replaces multiple price rules with:

A single JS module

Faster calculations

More flexible logic

Improved performance, especially with:

Complex math

Multi-stage calculations

External data lookups

QCP is the recommended performance strategy when price rules become too heavy.

Why the other options are incorrect:Option

Why Incorrect

A. Request increased limits

Salesforce does not increase CPQ calculator limits via support.

D. Apex triggers instead of price rules

Not allowed; quote line editor uses client-side calculator, not Apex.

E. Replace rules with nested bundles

Does not solve pricing logic complexity and may worsen configuration performance.

Thus, B and C are correct.

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.

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.

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.

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.

To save a new credit card Payment Method for future payments, the correct Salesforce Billing process is:

Correct documented methodFrom the Account Page:

Go to the Payment Methods related list

Click New Payment Method – Credit Card

Enter card details

Card is tokenized (via Payment Gateway)

Saved for future payments

This is exactly what option D describes.

Why the other answers are incorrectOption

Why Incorrect

A. Tokenize button

Outdated UI/legacy workflow; new UI and gateways tokenize automatically.

B. Payment credit cards related list

Not the standard Billing object structure; Salesforce Billing uses Payment Method object, not "Payment Credit Card".

C. Enter card details + encryption

PCI does not allow storing full credit card numbers in Salesforce even with Platform Encryption — credit cards must be tokenized via gateway, not stored directly.

Therefore:

The only correct Salesforce Billing approach is D.

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