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.

A Revenue Cloud project often requires enhanced document capabilities beyond native Salesforce CPQ or Billing.

✔ A — Contract RedliningRequires document collaboration, versioning, and clause-level redline—not native in CPQ.

AppExchange apps like Conga, Nintex, DocuSign CLM support this.

✔ B — WatermarksNot supported natively by CPQ Quote Templates or Billing invoice templates.

Requires 3rd-party document generation.

✔ D — Electronic SignatureSalesforce does not provide native eSignature.

Common tools: DocuSign, Adobe Sign.

Why the wrong answers are incorrect:Option

Why Incorrect

C — Invoice Generation

Salesforce Billing does generate invoices natively.

E — Attachments

Salesforce Files/Attachments are natively supported; no AppExchange needed.

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.

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.

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.

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.