Mastering the Salesforce Advanced Configurator: A Deep Dive Tutorial

Welcome to The Cloud Update! Today, we’re taking a comprehensive look at the Salesforce Advanced Configurator. If you’re looking to manage complex product configurations and enforce sophisticated business logic directly within Salesforce Revenue Cloud, you’re in the right place.

This tutorial will guide you through creating a Constraint Model (CML) from scratch, exploring various rule types, and demonstrating how they come alive in a real-world scenario using a “Robot Bundle” example.

Let’s unlock the power of the Advanced Configurator to build the precise quoting experience your business needs!

Table of contents

Getting Started: Setting the Stage

Before we dive in, this tutorial assumes you have a foundational understanding of Salesforce and Revenue Cloud concepts, including product bundles and attributes. Our main goal is to show you how to use the Advanced Configurator to bring dynamic logic to these existing structures.

We’ll cover:

Creating and structuring a new Constraint Model (CML).
Bringing in your product’s attributes and options.
Implementing a wide array of rule types to control configuration behavior.

Step 1: Creating Your Constraint Model in Salesforce

The journey begins by setting up a new constraint in your Salesforce environment.

Navigate to Constraints: In Salesforce, find and open the “Constraints” object.
Create a New Constraint:
- Give your constraint a descriptive Name (e.g., “Robot CML”). The API name will likely auto-fill.
- Set the Usage Type to “Constraint.”
- For Context Definition, ensure you select the active pricing context definition in your environment (e.g., “Pricing Transaction CD One”).
- Save your new constraint.
Open the Constraint Builder: Once saved, a constraint version will be created. Click on this version to open the Constraint Builder. This is where the magic happens – where you’ll define your model and rules. Initially, it will be an empty canvas.

Step 2: Structuring Your Model in the Constraint Builder

With the Constraint Builder open, our first task is to lay the groundwork for our product.

Create a New Type: This “Type” represents your main product bundle.
- Click “New Type.”
- Name it after your bundle (e.g., “RobotBundle”).
- Click “Create.” This establishes the parent container for your bundle’s logic.
Define Type Variables (Attributes): Now, let’s bring in the attributes associated with your product.
- Select your newly created Type (e.g., “RobotBundle”) from the list on the left.
- At the bottom, click “Define Type Variables.”
- You can manually create variables, but the powerful option is to Auto generate variables based on Product Catalog Management (PCM).
  - Look up and select your product bundle.
  - The system will pull in all attributes already defined for that bundle in Salesforce.
  - Select the attributes you want to include and save. Your Type will now list these attributes. Default values from PCM will be respected, though you can set defaults here (PCM usually takes precedence).
Define Relationships (Product Options/Components): Next, we add the selectable product options or components within your bundle.
- With your main Type still selected, switch from the “Variables” tab at the bottom to “Relationships.”
- Click “Define Relationships.”
- Again, you can leverage the Auto generate them from PCM option.
  - Select “Product Catalog Management” as the reference library.
  - Look up and select your product bundle.
  - All available product options for that bundle will appear. Select those you need and save.
  - This creates relations under your main Type and also defines individual types for each option further down the list. The example code already lists these relations and individual types.
Define Type Association: The final structural step is to link your CML model directly to the Salesforce product record.
- Ensure your main Type (e.g., “RobotBundle”) is selected.
- Switch to the “Associations” tab at the bottom.
- Click “Define a type association.”
  - For Object Entity, select “Product.”
  - For Object to Map, look up and select your actual product bundle record (e.g., the “Advanced Delivery Robot Bundle”).
  - Save this association.
Save Your Model: At this point, you have the basic structure of your constraint model. Click the main “Save” button in the Constraint Builder.

Important: Remember to Deactivate your model before making CML changes and Activate it to test your rules. The Constraint Builder UI helps with the initial setup, but the detailed rules are often written directly in the CML editor accessible within the constraint version record.

Here’s a look at the structural part of our example CML, defining the RobotBundle type and its attributes/relations, along with the types for related components:

type RobotBundle { @(defaultValue = “Tracked”) string MobilityType = [“Wheeled”, “Tracked”, “Legged”]; @(defaultValue = “Semi-Autonomous”) string Operating_Mode = [“Semi-Autonomous”, “Fully Autonomous”]; string TerrainAdaptationLevel = [“Medium”, “Low”, “Heavy”]; string Payload_Capacity_Requirement = [“Light”, “Medium”, “Heavy”]; int MaxPayload; relation heavydutyroboticarm : HeavyDutyRoboticArm; relation standardroboticarm : StandardRoboticArm; relation wifimodule : WiFiModule; relation fivegmodule : FiveGModule; relation fourgmodule : FourGModule; relation basicsafetykit : BasicSafetyKit; relation advancedsafetykit : AdvancedSafetyKit; relation emergencystop : EmergencyStop; relation leggedbase : LeggedBase; relation wheeledbase : WheeledBase; relation trackedbase : TrackedBase; relation basicsensorsuite : BasicSensorSuite; relation advancedsensorsuite : AdvancedSensorSuite; // Rules will be added here } type HeavyDutyRoboticArm; type StandardRoboticArm; type WiFiModule; type FiveGModule; type FourGModule; type BasicSafetyKit; type AdvancedSafetyKit; type EmergencyStop; type LeggedBase; type WheeledBase; type TrackedBase; type BasicSensorSuite; type AdvancedSensorSuite; // Types for Transaction Scope rules type Warranty; type ExtWarranty;

Step 3: Implementing Configuration Rules – The Core Logic

This is where you bring your product configuration to life. We’ll walk through various rule types using the provided CML code.

Rule Type 1: Basic Constraint Table

Purpose: Enforces direct, static relationships between two or more attributes. Think of it as a lookup table for valid combinations. If a selected combination isn’t in the table, the constraint fails, and an error message is typically shown.
Example:
The “Payload_Capacity_Requirement” must directly correspond to a specific “TerrainAdaptationLevel” as defined in the table:
- “Light” payload requires “Low” terrain adaptation.
- “Medium” payload requires “Medium” terrain adaptation.
- “Heavy” payload requires “Heavy” terrain adaptation.
CML Code (inside RobotBundle Type):

    constraint(table(Payload_Capacity_Requirement, TerrainAdaptationLevel,
                 {"Light", "Low"},
                 {"Medium", "Medium"},
                 {"Heavy", "Heavy"}),
               "Payload Capacity Requirement must match Terrain Adaptation Level");

Testing:
- When you configure the bundle, selecting “Light” for Payload_Capacity_Requirement will necessitate that TerrainAdaptationLevel is “Low.” If you attempt to set TerrainAdaptationLevel to “Medium” or “Heavy” while Payload_Capacity_Requirement is “Light”, the constraint will fail, and the message “Payload Capacity Requirement must match Terrain Adaptation Level” will be displayed, preventing an invalid configuration. The configurator might also auto-set the corresponding value if the UI is designed to do so based on the first selection.