Industries-CPQ-Developer Practice Test Questions

Explanation:

In Salesforce Industries CPQ (previously Steelbrick CPQ), the Cart or Basket is the central object holding the products and pricing information during configuration. When troubleshooting why nothing renders in the cart after adding products, you want to check the API calls responsible for fetching the current state and details of the cart.

getBasketDetails is the method typically called to retrieve the current contents and details of the Basket/Cart. If this call returns empty or errors, the UI will have nothing to render.

postCartsItems sounds like a method to post or add items to the cart but would not be the first point to check if the cart is not rendering.

createCart would be responsible for creating a new cart but not retrieving existing cart data.

getCartsItems is close but less commonly the exact method used in Industry CPQ APIs. The standard method to fetch basket content is getBasketDetails.

Reference:
Salesforce Industries CPQ Developer Guide and API documentation highlight the use of getBasketDetails as the key method to fetch cart details for rendering.
Developer forums and troubleshooting guides for Industry CPQ also recommend checking the response of getBasketDetails when the cart appears empty.
If the getBasketDetails API call fails or returns an empty basket, it indicates why the cart UI has no products to display.

Explanation:

In Vlocity (Salesforce Industries) Document Generation, merge fields (tokens) use double percent signs (%% %%):
- Syntax: %%ObjectAPIName.FieldAPIName%% (e.g., %%Account.Name%%)
- These tokens are replaced with real data during document generation.

Why Not Other Options?
- A. %field% → Single percent signs are for older tools like Conga, not Vlocity.
- B. {{field}} → Handlebars.js syntax (used in OmniScript, not DocGen).
- D. {%field%} → Jinja/Liquid syntax (used in Marketing Cloud).

Example:
To insert an Account Name in a Word/PDF template:
Client Name: %%Account.Name%%

Explanation:

Salesforce Industries CPQ offers robust frameworks to manage product eligibility, validation, and compatibility through rule-driven logic and relationship checks. The three core implementations are:

1. Advanced Compatibility Implementation
Enables advanced logic to define compatibility rules between products
Often used to enforce complex conditional constraints (e.g., product A can’t be sold with B unless C is also selected)

2. Default Rules Implementation
Predefined rule structure that handles basic validation use cases
Includes rule types like Availability, Compatibility, and Validation at product config level

3. Product Relationship Validation Implementation
Leverages Product Relationships (like requires/excludes/dependency)
Helps enforce what products can or cannot be selected together based on defined metadata

Why the Others Are Incorrect:
D. Validation Rules Implementation – 🔺 Not a standard Vlocity framework term (confused with Salesforce CRM-level validation rules)
E. Default Product Validation Implementation – ❌ No such named implementation exists in Vlocity
F. Custom Validation Framework – 🔺 While you can build custom logic, this isn’t a formal “provided” implementation

Explanation:

In Salesforce Industries CPQ (Vlocity), when adjusting the price of a child product, you're not directly modifying the base price. Instead, the system leverages Pricing Elements to layer adjustments on top of the base price. These elements preserve the original price and apply deltas through well-defined calculation logic.

Here’s how it works:
When a price is adjusted—for example, when a user applies a manual discount or configuration-driven adjustment—a new Pricing Element (like a one-time charge, recurring charge, or adjustment) is created.
These pricing elements are stored and referenced during cart recalculations via Price Calculation Matrix rules or Adjustment Classes.
So rather than overwrite the base, the CPQ engine adds an additional pricing layer, which offers flexibility for promotions, rules, and pricing transparency.

Why the Other Options Are Incorrect:
A. "The base price is overridden…" ❌ – The base price remains untouched; the CPQ engine preserves it as the anchor for pricing logic.
B. "The change… can be a percentage or amount" ❌ – While true in terms of adjustment types, this isn’t the mechanism for price updates. The update happens via pricing elements, not direct modification.

Explanation:

In Salesforce Industries (Vlocity) CPQ, product attributes are stored as:

JSON data in the vlocity_cmt__AttributeMetadata__c field on the Product2 object.
This JSON structure allows flexible attribute definitions (e.g., dropdowns, checkboxes) without requiring custom fields per attribute.

Why Not the Other Options?
B. Incorrect → While name/value pairs exist in the JSON, they aren’t stored on a separate Attribute2 object.
C. Incorrect → Attributes are not individual fields; they’re consolidated in the JSON field.
D. Incorrect → Binary attachments are used for files (e.g., images), not attribute data.

Explanation:

An Advanced Rule in Salesforce Industries CPQ (formerly Vlocity) is part of the powerful Rules Engine. These rules are used to control:

Product eligibility
Configuration validations
Pricing adjustments
Attribute dependencies
And more…

When you define an Advanced Rule, it consists of:

✅ Filters
Optional criteria that narrow when the rule fires.
For example: “Only fire this rule if Account Type = Enterprise.”

✅ Actions
What happens if the rule fires (e.g. hide a field, disable a product, adjust pricing).

✅ How Many Filters Are Allowed?
Filters are optional.
You can have:

0 filters (the rule always evaluates)
1 filter
Many filters (AND/OR logic)

So the correct range is 0, 1 or more filters.

Why Other Options Are Incorrect
✅ A. 1 → Incorrect
Not required to have exactly one filter.

✅ B. 1 or more → Incorrect
You can have zero filters.

✅ D. 0-3 → Incorrect

There’s no hard limit of only 3 filters; you can define as many as needed.

Explanation:

Salesforce Communications Cloud (part of Salesforce Industries) includes both of these key business capabilities:

Order Management
End-to-end order orchestration (activate, modify, cancel services).
Supports complex telecom/service provider workflows.

Contract Management
Manages customer agreements, terms, and renewals.
Integrates with CPQ for pricing and discounts.

Explanation:

The CpQAppHandler is a key component in Salesforce Industries (Vlocity) CPQ architecture. Here’s what it is and does:

✅ C. A specialized global Apex class that includes methods to perform CPQ functions
CpQAppHandler is a global Apex class provided as part of the Vlocity-managed package.
It exposes methods used for performing critical CPQ operations, such as:

Retrieving Product Offerings
Calculating prices
Running validation rules
Executing configuration logic

Because Salesforce Industries CPQ relies on a metadata-driven architecture, many UI components or Integration Procedures call CpQAppHandler Apex methods to execute CPQ logic server-side.

Example usage:
You might see something like this:
Cpq.CpQAppHandler appHandler = new Cpq.CpQAppHandler();
List items = appHandler.getQuoteLineItems(quoteId);

The class is used by:
OmniScripts
Integration Procedures
UI components
Pricing and validation engines

Why the Other Options Are Incorrect
✅ A. The remote method used to filter products from the shared catalog → Incorrect
Filtering products from the shared catalog is typically handled via queries or integration procedures—not a single remote method called CpQAppHandler.

✅ B. An Angular directive within the persistent cart templates that contains CPQ logic → Incorrect
CpQAppHandler is not a front-end directive. Angular directives exist in the Vlocity UI templates, but they’re unrelated to the Apex class.

✅ D. An integration procedure invoked by the persistent cart that performs CPQ functions → Incorrect
CpQAppHandler is Apex code, not an Integration Procedure. However, Integration Procedures may invoke CpQAppHandler methods under the hood.

Explanation:

When working in the Vlocity Cart (the Industries CPQ cart interface), several rule types exist to control how products are:

Required
Excluded
Validated for compatibility

The specific rule type that runs in the cart line items panel to determine required/excluded products and compatibility is:

✅ A. Configuration Validation (Compatibility) Advanced Rules
These rules check relationships and compatibility between products in the cart.
They determine:

If certain products are incompatible (must not be ordered together)
If certain products are required when another product is chosen
Whether combinations violate business rules

Often used for:

Telecom bundles (e.g. you can’t sell a certain device without a compatible data plan)
B2B configurations
Complex product relationships

These rules execute during cart operations, such as:

Adding/removing products
Changing quantities
Modifying configurations

If an incompatibility is detected:

The cart shows error or warning messages
The user is prevented from proceeding until conflicts are resolved

Why Other Options Are Incorrect
✅ B. Evaluation Context Rules → Incorrect
Evaluation Context Rules execute in the context of pricing and eligibility but are not the primary mechanism for determining compatibility or required/excluded products in the cart UI.

✅ C. Qualification Context Rules → Incorrect
These determine eligibility for offers/products based on customer context (e.g. Account type, location) but don’t handle compatibility or required/excluded logic inside the cart.

✅ D. Configuration Validation (Compatibility) Context Rules → Incorrect

There’s no rule type specifically called “Configuration Validation (Compatibility) Context Rules.” That’s a mixing of terms from two different rule types.

Explanation:

The Product Hierarchy Maintenance job:
- Runs ResolveProductHierarchyBatchJob.
- Optimizes product relationships (e.g., bundles, options).
- Saves to vlocity_cmt__CachedHierarchy__c for performance.

Why Not Other Options?
- B: No cache copy occurs; updates data store directly.
- C: Handled by ProductAttributesBatchProcessor.
- D: Attribute regeneration is a separate job.