Section 04 — Contracts & Amendments

4.1

Use Case, User Journey & Personas

Core User Journey

Both Platforms — Shared Lifecycle

Order Activated

→

Contract Created

→

Subscription / Asset Lines

→

Mid-Term Change Request

→

Amendment Doc / Order

→

Contract & Assets Updated

CPQ-Specific Flow Detail

Order Activated

→

Contract Created
(SBQQ__Contract__c)

→

SBQQ__Subscription__c
per product line

→

Amendment Quote
(from Contract)

→

Amendment Order

→

Subscriptions Updated
(qty, price, end date)

Revenue Cloud-Specific Flow Detail

Order Activated

→

Contract Created
(standard Contract)

→

AssetLineItems
+ Assets

→

Asset Action
(Amend/Renew/Cancel)

→

Amendment Order
(auto-generated)

→

Assets & ContractLineItems
updated via Order Mgmt

Topic	Salesforce CPQ	Revenue Cloud
Primary When-to-Use	Best when the entire contract lifecycle originates in CPQ — subscriptions are tracked as `SBQQ__Subscription__c` records tied to the Contract. Amendments flow through a dedicated Amendment Quote process on the existing Contract record.	Best for asset-based ordering (ABO) scenarios where customer assets persist between transactions. RC models the "current state of what a customer owns" explicitly via `Asset` and `AssetLineItem`, with changes driven by Asset Actions rather than re-quoting.
Mid-Term Amendment Types	Add product (new Subscription line) Increase / decrease quantity Upgrade / downgrade product Early cancel (set `SBQQ__TerminatedDate__c`) Split/Co-term to contract end date	Add (new AssetLineItem) Change (qty / price update) Renew (extend term) Cancel (asset deactivated) Swap (product replacement) Suspend / Resume (lifecycle states)
Internal User Personas	Sales Rep Contract Manager Customer Success Mgr Renewals Manager Revenue Ops Analyst Sales Rep initiates amendment quote from Contract; Contract Manager validates and approves; Renewals Manager manages renewal pipeline via Renewal Opportunity.	Sales Rep Contract Admin Customer Success Mgr Order Manager Revenue Ops Analyst Order Manager drives asset lifecycle via Asset Console; Contract Admin monitors Contract and ContractLineItems; CSM may initiate changes via Experience Cloud portal integration.
External Persona	Customer (via CPQ Portal — CPQ+) Requires CPQ+ Communities license. Customer self-service is limited — typically read-only contract view. Amend actions still routed to internal rep via case or opportunity.	Customer (via Experience Cloud) RC has native Commerce + Experience Cloud integration. Customers can initiate Asset Actions (upgrade, cancel, renew) directly through a self-service portal backed by the Asset Action framework.
Key Object Anchor	Contract record with field `SBQQ__Contract__c` custom fields. `SBQQ__Subscription__c` is the child subscription record — one per product per contract term. The "source of truth" for what the customer owns.	Standard `Contract` + `Asset` object. `AssetLineItem` stores the subscription granularity. `ContractLineItem` stores what was contracted at signing. Assets represent the current state; ContractLineItems represent the committed obligation.
Co-Terming Logic	✓ Built-in co-term to contract end date setting (`SBQQ__CoTermedContractsCombined__c`). Amendment quote lines are automatically set to contract end date. Pro-rated billing delta calculated by CPQ Billing or Steelbrick Billing.	✓ Term alignment is handled by the Proration Policy and the Asset's `EndDate`. Amendment Orders carry the pro-rated charge for the remainder of the term. The Proration Engine is configurable at the Order Product level.

Subsection Summary — Use Case & Journey

Both platforms share the same logical lifecycle (Order → Contract → Asset/Subscription → Amendment → Updated Contract), but they diverge architecturally. CPQ anchors on the Subscription object and Amendment Quotes, keeping changes inside the CPQ quoting engine. Revenue Cloud anchors on the Asset object and Asset Actions, pushing amendment logic into an Order Management framework. CPQ is more intuitive for sales-led amendment flows; RC is more robust for complex, programmatic, or self-service-driven asset lifecycle management. Migration from CPQ to RC typically requires mapping SBQQ__Subscription__c → AssetLineItem + Asset and re-plumbing amendment triggers.

4.2

Licensing Requirements

Capability	Salesforce CPQ	Revenue Cloud
Base License	CPQ License `SteelBrick CPQ` / `Salesforce CPQ` user license required for all CPQ users who create or edit quotes, orders, contracts, and subscriptions. Assigned at the User level via Permission Set.	Revenue Cloud Revenue Cloud is sold as part of the Revenue Lifecycle Management (RLM) SKU. The base license enables CPQ, Contracts, Billing, and Asset-Based Ordering. Users need the Revenue Cloud User permission set.
Amendment & Renewal	CPQ Basic amendment quotes and subscriptions CPQ+ Advanced renewal management: Renewal Forecast, auto-renewal opportunity generation, Renewal Pricing settings, multi-contract renewals CPQ+ Self-service portal amendment flows (Experience Cloud) CPQ alone can do amendments; CPQ+ unlocks the automated renewal pipeline and communities-based self-service.	RC Base Full asset action framework (Amend, Cancel, Renew, Swap) RC Base Asset-based ordering and Amendment Order generation Commerce Add-on Self-service asset management via Experience Cloud + B2B Commerce Industries CPQ Some vertical-specific contract capabilities (e.g., Telco, Health) All amendment and renewal capabilities are included in the RC base license; no tiered "+"-license requirement.
Subscription Management	CPQ ✓ `SBQQ__Subscription__c` object and all subscription lifecycle fields (Start/End/TerminatedDate/Status) available with base CPQ license.	RC Base ✓ `Asset` + `AssetLineItem` lifecycle management. `AssetStatePeriod` tracks temporal subscription states. Full lifecycle (Active, Pending, Suspended, Cancelled) available in base RC.
Asset-Based Ordering (ABO)	~ CPQ does not have a formal ABO framework. Amendments are driven through Amendment Quotes — essentially a CPQ quote linked to the existing Contract. There is no standalone "Asset Action" concept. Assets exist as standard SF objects but CPQ does not natively manage them as a lifecycle state machine.	✓ ABO is core to RC's architecture. The Asset Action framework defines valid transitions on Assets (Add, Change, Renew, Cancel, Swap, Suspend, Resume). Asset state machine is managed by the Order Lifecycle Management engine included in the RC license.
Billing Integration for Proration	CPQ Basic proration logic built in. Full billing proration, invoicing, and credit notes require Salesforce Billing (separate license add-on).	RC Base Proration policies and billing rules are included. Revenue Cloud includes the Revenue Lifecycle Management billing capabilities natively without a separate billing add-on for standard use cases.
API Access for Contracts	Full Metadata + REST/SOAP API access to `SBQQ__Subscription__c`, `SBQQ__Contract__c` fields, Amendment Quote creation via API using `SBQQ.ContractManipulationAPI` Apex invocable methods. Requires CPQ license in the API context user.	Full REST API access to all RC objects. The Connect API exposes Asset Actions programmatically (`/commerce/asset-actions` endpoints). Headless amendment flows possible without a UI session. API user must have RC User permission set.

Subsection Summary — Licensing

CPQ uses a tiered licensing model where full amendment and renewal automation requires the CPQ+ upgrade. Revenue Cloud bundles all amendment, renewal, and asset lifecycle capabilities into the base RC license — no "+"-tier needed for contract management. For organizations already on CPQ evaluating an upgrade, the key licensing consideration is that RC's ABO framework replaces the need for both CPQ's Subscription Management and the separate Salesforce Billing add-on for most mid-market contract scenarios.

4.3

Data Model

SECTION 4 — CONTRACTS & AMENDMENTS DATA MODEL

SECTION 4 — TRANSACTION MANAGEMENT: ASSET DATA MODEL

Asset Ecosystem — Extended Objects Deep Dive

ASSET ACTION SOURCE

Polymorphic junction that links an AssetAction to its originating record — an OrderItem, a Work Order Line Item, or an OrderItemDetail. Enables RC to trace every asset change back to the exact source transaction regardless of which path triggered it.

Relates to: AssetAction, OrderItem, WorkOrderLineItem, OrderItemDetail

ASSET ACTION SOURCE PROMOTION

Tracks promotional pricing that was applied at the time the AssetAction was created. Preserves the original promotion context so that billing and revenue recognition can correctly account for discounted periods without altering the base price record.

Child of: AssetActionSource; links to promotion/discount context

ASSET STATE PERIOD ATTRIBUTE

Stores key-value attribute pairs on an AssetStatePeriod — e.g. a product attribute that was active during that state window (color, tier, configuration option). Enables time-accurate attribute history without re-querying the product catalog.

Child of: AssetStatePeriod; attribute name + value pairs

ASSET RATE ADJUSTMENT & RATE CARD ENTRY

AssetRateCardEntry links an Asset to a specific Rate Card Entry, binding the asset to a negotiated rate structure. AssetRateAdjustment records any manual or automated adjustment applied on top of the rate card — preserving both the baseline and the actual charged rate.

Drives usage-based billing and rate overrides at the asset level

TRANSACTION USAGE ENTITLEMENT

Defines the usage allowance contracted for an Asset — e.g. 1,000 API calls/month included before overage billing kicks in. Links the Asset to a Usage Commitment / Asset Related Object. Compared against actual usage to determine billable overage.

Key to usage-based and consumption pricing models in RC

FULFILLMENT ASSET & RELATIONSHIPS

FulfillmentAsset tracks physical or service delivery fulfillment linked to an Asset (e.g. provisioned hardware, deployed service instance). FulfillmentAssetRelationship defines parent/child hierarchy between fulfillment records. FulfillmentAssetAttribute stores configuration attributes on the fulfillment item.

Used when RC is paired with Field Service or physical provisioning workflows

Asset Relationships & Binding Objects

Object	Purpose	Key Relationships
`AssetRelationship`	Defines peer relationships between Assets (e.g. bundled components, dependent services). Separate from the parent/child hierarchy — models many-to-many asset associations	Lookup to two `Asset` records + `ProductRelationshipType`
`ProductRelationshipType`	Enum/picklist-like object that classifies what kind of relationship two assets have (Required, Compatible, Incompatible, etc.)	Lookup from `AssetRelationship`
`BindingObjectRateAdjustment`	Stores a rate adjustment scoped to a binding object (Account, Contract, or Service Account). Allows negotiated rates to be applied consistently across all assets owned by that binding object	Polymorphic lookup to `Account` / `Contract`
`BindingObjectRateCardEntry`	Links a binding object to a specific Rate Card Entry — effectively "pins" a negotiated rate card to an Account or Contract level rather than per-asset	Polymorphic lookup to binding object + `RateCardEntry`
`BindingObjectUsageResourcePolicy`	Defines usage resource policies (pooling, overage rules, entitlement caps) at the binding object level — supports enterprise usage pools shared across multiple assets under one Account	Lookup to `Account` / `Contract` + usage policy definition
`OrderAction`	RC-specific object that records the intent of an Order relative to the Asset — New, Amend, Renew, Cancel, Suspend. Distinct from standard Order Type; used by the RC platform to route Asset delta logic correctly	Lookup to `Order`; drives `AssetAction` creation on activation

RC Core Objects — Deep Dive

CONTRACT

Standard object, RC-augmented. The legal agreement covering one or more Assets. Created automatically on Order activation (if enabled) or manually. Drives renewal scheduling, auto-renewal, and billing policy linkage.

Key RC fields: ContractType__c, AutoRenewalDays__c, RenewalTerm, BillingPolicy__c

ASSET & ASSET LINE ITEM

The Asset is the central RC subscription record — what the customer currently owns. AssetLineItem carries the subscription granularity: term, quantity, pricing, and billing frequency. Both are created on Order activation.

Key RC fields: LifecycleStartDate, LifecycleEndDate, CurrentAmount, Status, RootAssetId

ASSET STATE PERIOD

A time-series child of Asset. Each change to quantity, price, or status creates a new AssetStatePeriod record — preserving the full audit history without overwriting. The complete subscription timeline lives here.

Key fields: StartDate, EndDate, Quantity, TotalPrice, Type (New / Amendment / Renewal)

ASSET ACTION

Records every lifecycle event applied to an Asset: New, Amendment, Renewal, Cancellation, Suspension. Acts as the event log that drives the creation of AssetStatePeriods. Each Amendment Order activation creates one AssetAction per changed line.

Key fields: ActionType, EffectiveDate, AssetId, OrderItemId

CONTRACT LINE ITEM

Standard child of Contract, extended by RC. Represents the contracted obligation for a specific product. Used by Revenue Scheduling for billing and by renewal automation to determine what should be renewed.

Key fields: Product2Id, Quantity, UnitPrice, StartDate, EndDate, AssetId

ORDER (AMENDMENT / RENEWAL)

Each lifecycle change creates a new Order with Type = Amendment or Type = Renewal. The Amendment Order's OrderItems carry OriginalOrderItemId — the FK back to the original purchase — enabling delta Asset updates without full record replacement.

Key RC fields: Order.Type, OrderItem.OriginalOrderItemId, OrderItem.AssetId

When Are RC Contract Objects Created?

Object	Created When	Created By	Notes
`Contract`	Order activation (if auto-contract enabled) or manually	RC platform or rep	One Contract per Order by default; can be configured to consolidate
`ContractLineItem`	Contract creation / activation	RC platform (from OrderItems)	One per OrderItem that maps to a contracted product
`Asset`	Order activation	RC platform	New Order = new Asset; Amendment Order = updates existing Asset
`AssetLineItem`	Order activation	RC platform (from OrderItem)	Carries subscription term and pricing detail for the Asset
`AssetAction`	Every lifecycle event (New, Amendment, Renewal, Cancel)	RC platform	Event log; one per affected Asset per activation
`AssetStatePeriod`	Derived from each AssetAction	RC platform	Time-series record; never overwritten — append-only audit history

CPQ Contract & Subscription Objects

Contract Standard Core contract record

SBQQ__Contract__c fields CPQ Custom

SBQQ__Subscription__c CPQ Custom

SBQQ__RenewedContract__c CPQ Custom

Asset Standard Optional / not primary

Quote (SBQQ__Quote__c) CPQ Custom

Order / OrderItem Standard CPQ-modified

Revenue Cloud Contract & Asset Objects

Contract Standard RC-augmented

ContractLineItem Standard Contracted obligation

Asset Standard RC-extended

AssetLineItem RC Standard

AssetStatePeriod RC Standard

AssetAction RC Standard

Order / OrderItem Standard RC-extended

Object / Field	CPQ — Field Detail	Revenue Cloud — Field / Object Detail
Contract	Standard `Contract` with CPQ-added fields: SBQQ__AmendmentOpportunityStage__c SBQQ__AmendmentOwner__c SBQQ__AmendmentPricebookId__c SBQQ__DefaultRenewalContactRoles__c SBQQ__DisableAmendmentCoTerm__c SBQQ__ExpirationDate__c SBQQ__MasterContract__c SBQQ__Order__c (orig Order) SBQQ__PreserveBundleStructure__c SBQQ__RenewalForecast__c SBQQ__RenewalOpportunityStage__c SBQQ__RenewalPricebookId__c SBQQ__RenewalQuoted__c SBQQ__RenewedContract__c (lookup) SBQQ__SubscriptionQuantitiesCombined__c	Standard `Contract` with RC-added fields: AutoRenewalDays__c ContractType__c (Subscription, Perpetual) EndDate / StartDate (standard, used natively) RenewalTerm / RenewalTermUnit TotalContractValue__c Status (Draft, Activated, Expired, etc.) BillingPolicy__c (lookup to BillingPolicy) PricingStrategy__c ContractLineItems linked to Contract (standard child object, extended by RC).
Subscription / Asset Record	`SBQQ__Subscription__c` — one per product per contract: SBQQ__Contract__c (M-D to Contract) SBQQ__Product__c (lookup) SBQQ__Quantity__c SBQQ__RegularPrice__c SBQQ__CustomerPrice__c SBQQ__ListPrice__c SBQQ__StartDate__c SBQQ__EndDate__c SBQQ__TerminatedDate__c SBQQ__OriginalQuoteLine__c SBQQ__RootId__c (bundle parent) SBQQ__AmendmentSubscriptionType__c	`Asset` (standard, RC-extended) — the "currently owned" record: Product2Id (lookup) AccountId Quantity CurrentAmount (current MRR/ACV) LifecycleStartDate LifecycleEndDate Status (Active, Cancelled, Suspended) AssetProvidedById RootAssetId (bundle parent) ProductCode SerialNumber Plus `AssetLineItem` for subscription granularity (term, price, discount).
Amendment Delta Calculation	CPQ calculates the amendment delta on the Amendment Quote. When a quantity changes from 5 → 8, CPQ creates a new Quote Line for the delta (+3 units) at the prorated price to the contract end date. ProrationMultiplier = (ContractEndDate - AmendDate) / TermDays DeltaCharge = (NewQty - OldQty) × UnitPrice × ProrationMultiplier CPQ manages delta — original subscription lines are NOT modified until the amendment order activates.	RC calculates amendment deltas via the Proration Engine at the OrderItem level. The Asset Action generates an Amendment Order. The delta charge (positive or negative) is recorded on the OrderItem with: OrderItemType = Amendment OriginalOrderItemId (FK to original OrderItem) StartDate = AmendmentEffectiveDate EndDate = ContractEndDate Quantity = DeltaQty (positive or negative) UnitPrice = ProratedUnitPrice RC manages delta — the Asset's current state is updated immediately when the Amendment Order activates.
Renewal Tracking	`SBQQ__RenewedContract__c` on the new Contract points back to the original Contract. The Renewal Opportunity and Renewal Quote carry `SBQQ__RenewedContract__c` references. A chain of renewals creates a linked list of Contract records.	The renewed Contract references the prior period via standard `PreviousContractId` (if used) or via the Asset's `LifecycleStartDate` / `LifecycleEndDate` timeline. `AssetStatePeriod` records form a time-series of every state the asset passed through, providing full audit history without a separate "renewed contract" chain.
Bundle / Parent-Child Relationships	`SBQQ__Subscription__c.SBQQ__RootId__c` and `SBQQ__RequiredBySubscription__c` preserve bundle hierarchy in the contract. When amending, CPQ attempts to preserve the bundle structure via `SBQQ__PreserveBundleStructure__c` on the Contract.	`Asset.RootAssetId` and `Asset.ParentId` preserve bundle hierarchy. Amendment Orders propagate changes to child assets automatically when the root asset is amended. The hierarchy is also reflected in `AssetLineItem.ParentAssetLineItemId`.
Order-to-Contract Linkage	`Contract.SBQQ__Order__c` (lookup to originating Order). `SBQQ__Subscription__c.SBQQ__OrderProduct__c` links each subscription back to its source OrderProduct. Amendment Orders are linked via `SBQQ__AmendedContract__c`.	`Asset.PurchaseDate` + `Asset.InstallDate` track lifecycle events. `OrderItem.AssetId` links each OrderItem to the resulting Asset. The Amendment Order's `OrderItem.OriginalOrderItemId` traces back to the original purchase OrderItem.

Migration Mapping Note for Architects

When migrating from CPQ to Revenue Cloud, each SBQQ__Subscription__c record maps to a combination of Asset + AssetLineItem. The key field mappings are:

SBQQ__Subscription__c.SBQQ__Product__c → Asset.Product2Id
SBQQ__Subscription__c.SBQQ__Quantity__c → Asset.Quantity
SBQQ__Subscription__c.SBQQ__CustomerPrice__c → Asset.CurrentAmount (per unit)
SBQQ__Subscription__c.SBQQ__StartDate__c / EndDate__c → Asset.LifecycleStartDate / LifecycleEndDate
SBQQ__Subscription__c.SBQQ__TerminatedDate__c → Asset.Status = 'Cancelled' + final AssetStatePeriod record

Subsection Summary — Data Model

CPQ's data model centers on the custom SBQQ__Subscription__c object as the authoritative subscription record — it is a point-in-time snapshot updated by each amendment. Revenue Cloud's model centers on the standard Asset object with AssetStatePeriod time-series history — it maintains a full temporal audit trail without overwriting records. RC's approach is more suitable for complex billing, revenue recognition, and compliance scenarios; CPQ's approach is simpler to query and report on for sales-centric use cases.

4.4

Automations

Automation	CPQ — Mechanism & Detail	Revenue Cloud — Mechanism & Detail
Contract Creation from Order	CPQ Trigger When an Order is activated (`Status = 'Activated'`), the CPQ managed package Apex trigger (`SBQQ.OrderTrigger`) automatically creates a `Contract` record if `SBQQ__Contracted__c = true` is set on the Order. Subscriptions are created simultaneously for all `OrderItem` records with subscription products. // CPQ auto-contraction setting Order.SBQQ__Contracted__c = true → triggers: 1. Contract creation 2. SBQQ__Subscription__c per OrderProduct 3. Contract.Status = 'Activated'	Order Lifecycle Flow RC uses the Order Lifecycle Management framework. When an Order transitions to `Activated` status, a Flow (or configurable lifecycle trigger) generates: Contract record (if ContractRequired on product/order type) Asset record per OrderItem with subscription type AssetLineItem per subscription OrderItem ContractLineItem per contracted item
Subscription / Asset Creation	CPQ Managed Apex Subscriptions auto-created by the CPQ `ContractManipulationAPI` during contract creation. Fields populated from `OrderItem` fields. No custom code needed for standard scenarios. One `SBQQ__Subscription__c` per subscription-type OrderProduct Bundle hierarchy preserved via `SBQQ__RootId__c` Term dates aligned to Contract StartDate/EndDate	Order Mgmt Framework Assets and AssetLineItems created via the Order Lifecycle orchestration. The Asset Creation invocable action can be called from Flow or Apex. Assets linked to Account + Product2 AssetLineItem captures pricing / term details AssetStatePeriod created for initial Active state Asset Actions (initial = "Purchase") recorded
Amendment Quote / Order Auto-Population	CPQ Amendment Button The Amend button on the Contract record triggers CPQ's `ContractManipulationAPI.amend()` method which: 1. Creates a new Quote (Type = 'Amendment') 2. Copies all active Subscriptions as Quote Lines (original price, qty, dates pre-populated) 3. Sets Quote.SBQQ__MasterContract__c = Contract.Id 4. Sets Quote.SBQQ__StartDate__c = AmendmentEffectiveDate 5. User modifies lines → re-prices delta → Order All original subscription data is pre-loaded; user only changes the delta.	Asset Action Framework User (or API) initiates an Asset Action on an Asset record. RC automatically: 1. Validates the action against allowed transitions (e.g., Active → Amend is allowed) 2. Generates an Amendment Order with: - OrderType = 'Amendment' - OriginalOrderId FK - OrderItems for each changed asset 3. Calculates proration on OrderItems 4. Routes Order through approval / activation flow No separate "quote" step required for amendments — goes directly to Order.
Proration Calculation	CPQ Engine Proration is calculated by CPQ's pricing engine during quote calculation. The proration multiplier is: Days Remaining / Total Contract Days × UnitPrice × DeltaQty Settings: `SBQQ__ProrationDayCount__c` (365 or 360), `SBQQ__DisableAmendmentCoTerm__c` on Contract. Advanced proration (partial months, daily billing) requires Salesforce Billing.	Proration Policy RC has a configurable Proration Policy object: Policy Type: Daily, Monthly, Exact Day Rounding Method: Up, Down, Nearest Effective Date Method: Order Date, Requested Date, Custom Policies assignable at Product, Product Category, or global level Proration calculated natively in the Amendment Order engine.
Renewal Opportunity Auto-Generation	CPQ+ CPQ+ has a Renewal Forecast feature. A scheduled batch job (`SBQQ.RenewalService`) runs periodically and auto-creates Renewal Opportunities N days before Contract expiration (configurable). The Renewal Quote is pre-populated from existing subscriptions. SBQQ__Quote__c.SBQQ__Type__c = 'Renewal' SBQQ__Quote__c.SBQQ__RenewedContract__c = Contract.Id // Subscription lines copied to Quote Lines // Renewal pricing applied per settings	Flow / Auto-Renewal RC supports Auto-Renewal via: Contract `AutoRenewalDays__c` field — trigger X days before end Flow-based renewal: creates Renewal Order from Asset state Manual renewal via Asset Action (Action Type = Renew) Renewal Order inherits current asset quantities and pricing No separate "Renewal Quote" required unless the business process demands it.
Auto-Cancel / Termination	CPQ Cancel is performed by creating an Amendment Quote and setting subscription quantities to 0 or setting `SBQQ__TerminatedDate__c` directly via Apex/Flow. No out-of-box automatic cancellation flow — typically handled by custom Apex or Process Builder / Flow triggered on a date field.	Asset Action Cancel is a first-class Asset Action. The Cancel action: Generates a Cancel Order (negative charge if mid-term) Sets `Asset.Status = 'Cancelled'` Creates final `AssetStatePeriod` with cancellation dates Triggers billing adjustment automatically (credit memo)
Lifecycle State Transitions (Suspend/Resume)	✗ CPQ has no native Suspend/Resume concept. Custom implementation required — typically a custom field on `SBQQ__Subscription__c` and a billing pause on the Salesforce Billing side.	✓ Native Suspend and Resume Asset Actions. When an asset is suspended: Asset.Status → 'Suspended' Billing paused per Billing Policy rules Resume restarts billing from resume date (prorated) Full state history in AssetStatePeriod

Subsection Summary — Automations

CPQ's automation model is quote-centric: every amendment or renewal flows through a Quote, which provides a review/approval checkpoint but adds process steps. Revenue Cloud's automation model is action-centric: Asset Actions generate Orders directly, enabling faster programmatic amendments — ideal for self-service portals and high-volume subscription changes. CPQ's renewal automation (CPQ+ batch job) is mature and field-proven; RC's renewal automation is more configurable but requires careful Flow orchestration. Both platforms require custom automation for complex business rules (e.g., prorated credits with approval thresholds, multi-asset bundle amendments).

4.5

Configuration (Architect Setup Level)

Effort Rating Scale

Ratings reflect Salesforce-architect effort to configure from a clean org. Low = 1–4 hrs, clicks only. Medium = 1–2 days, config + some Flow/formula. High = 3+ days, Apex/complex Flow/package settings.

Configuration Task	CPQ Setup	Revenue Cloud Setup
Subscription / Contract Settings	Low Effort Navigate to CPQ Settings → Subscriptions tab: Subscription Term Unit (Month, Year) Default Subscription Term Subscription Proration Precision (Day/Month) Proration Day Count (365 / 360) Bundle Component Subscription Type Then CPQ Settings → Contracts tab: Auto-create Contract from Order Combine Subscriptions by Quantity Default Contract Term Service Start / End Date fields	Medium Effort RC contract behavior is configured via: Revenue Settings (Setup → Revenue Settings) Enable Asset-Based Ordering toggle Default Contract Type per Product Category Term / Renewal settings on Product record (`SubscriptionType`, `SubscriptionTerm`) Order lifecycle Flow assignment (Setup → Order Settings)
Proration Policy Setup	Low Effort Configured entirely in CPQ Settings. Two settings control most scenarios: `Proration Day Count`: 360 or 365 `Subscription Proration Precision`: Day, Month, None Advanced billing proration requires Salesforce Billing Proration Rules (separate billing config — Medium).	Medium Effort RC has a dedicated Proration Policy object (Setup → Proration Policies): Create Policy records with type (Daily/Monthly/Exact) Assign Policy to Product, Category, or globally Configure rounding and effective date method Test via Proration Policy tester in Setup More granular than CPQ but requires more initial setup.
Asset Action Setup	✗ No equivalent in CPQ. Amendments are initiated via the Amend button (standard CPQ behavior, no separate action configuration needed beyond enabling the button).	Medium Effort Asset Actions must be explicitly configured: Setup → Asset Actions → Create Action Types Define valid state transitions per action (e.g., Active → Amend) Configure eligibility rules (which products support which actions) Assign Order Record Types per action type Map Asset Action → Order Type → Lifecycle Flow Typically 4–8 action types: Add, Change, Renew, Cancel, Swap, Suspend, Resume, Transfer.
Renewal Settings	Low Effort (base) / Medium (CPQ+) CPQ Settings → Renewals: Enable Renewal Forecasting Days before expiration to create Renewal Opp (CPQ+) Renewal Opportunity Stage, Owner, Pricebook Renewal Pricing Method (Same, Uplift %, List Price) Auto-Renewal toggle per Contract	Medium Effort Contract `AutoRenewalDays__c` field per Contract or Product Renewal Flow: configure Flow to create Renewal Order Renewal Order Type and pricing method Renewal uplift rules: formula field on Product / Pricing Procedure Auto-renewal notification emails via Flow
Amendment Quote Settings	Low Effort CPQ Settings → Amendments: Co-term new products toggle Amendment Quote Pricebook override Amendment Opportunity Stage / Owner Preserve Bundle Structure on Amendment Amendment Subscription behavior (Replace vs. Revised) All point-and-click in CPQ Settings.	Medium Effort Amendment behavior in RC is configured at multiple levels: Asset Action type configuration (eligible products, valid states) Amendment Order Record Type assignment Pricing Procedure for amendment price calculation Approval thresholds on Amendment Orders Co-term behavior via Proration Policy effective date setting
Order Lifecycle Configuration	Low Effort CPQ Order lifecycle is mostly handled by the managed package. Custom Order Record Types or statuses require Medium effort. The key setting is enabling "Order" in CPQ Settings and mapping Order Products to Subscription behavior.	High Effort RC's Order Lifecycle Management is powerful but complex to configure: Define Order Record Types (New, Amendment, Renewal, Cancel) Configure Lifecycle Flow per Order Record Type Define Order Status path (Draft → Submitted → Approved → Activated) Map lifecycle stages to Asset state transitions Configure rollback / failure handling in Flow Initial setup is 3–5 days for a full multi-type order lifecycle.

Subsection Summary — Configuration

CPQ wins on configuration simplicity for standard amendment and renewal scenarios — the CPQ Settings UI provides a centralized, wizard-like configuration experience with sane defaults. Revenue Cloud requires more upfront architectural decisions (Asset Action types, Proration Policies, Order Lifecycle Flows) but rewards that effort with greater flexibility for complex or non-standard amendment scenarios. Budget 2–3x more setup time for RC compared to CPQ for an equivalent standard amendment/renewal configuration; however, RC can implement scenarios that would require custom Apex in CPQ (e.g., Suspend/Resume, Swap, programmatic self-service amendments) with pure configuration.

4.6

Customization (Common Additions)

Customization Pattern	CPQ — Approach & Example	Revenue Cloud — Approach & Example
Custom Renewal / Amendment Logic	Apex + Invocable Common patterns: Override CPQ's `SBQQ.ProductSearch` plugin to filter products available for amendment Custom Apex implementing `SBQQ.AmendmentSaver` interface to post-process amendment quote lines Custom renewal pricing: Apex trigger on `SBQQ__Subscription__c` to apply tiered uplift rates before renewal quote population Multi-contract co-term: Apex to align subscription end dates across multiple active contracts // Example: Custom amendment logic via CPQ Plugin global class MyAmendmentPlugin implements SBQQ.ContractAmendmentPlugin { global void onAmendmentSaved( SBQQ__Quote__c quote, List<SBQQ__QuoteLine__c> lines) { // Custom business logic here } }	Flow + Apex Common patterns: Custom Asset Action eligibility rules: Flow-based or Apex-based validation before allowing an action Custom Amendment Order pricing: override the Pricing Procedure with custom Apex price rules Conditional renewal: Flow checks contract terms, customer tier, or renewal propensity before auto-creating renewal order Multi-asset amendment: custom Invocable Action to batch-amend multiple assets in a single operation // Example: Custom Asset Action eligibility check (Apex) public class AssetAmendEligibility implements AssetActionEligibility { public Boolean isEligible(Asset a, String actionType) { // Check custom business rules return a.Status == 'Active' && a.CustomEligible__c; } }
Custom Subscription Management UIs	LWC + Apex CPQ's amendment UI is the standard Quote line editor. Custom UIs are common for: Subscription dashboard: LWC displaying all active subscriptions with amendment actions inline Bulk amendment: custom LWC allowing sales rep to select multiple subscriptions and change quantities Customer portal view: custom LWC in Experience Cloud showing subscription status (CPQ+ license required for portal access to CPQ data) Key challenge: CPQ's Quote line editor is a VF page (legacy) or LWC (newer); deep customization is limited by the managed package.	LWC + Connect API RC offers richer UI extension points: Asset Console: standard RC UI, customizable via Lightning App Builder (add custom LWC components) Experience Cloud self-service: RC + B2B Commerce integration with native asset action UI components Custom asset action wizard: multi-step LWC using `/commerce/asset-actions` Connect API Asset health dashboard: LWC with RC asset state + billing data for Customer Success teams The Connect API enables fully headless amendment flows, enabling mobile apps or third-party portals.
Mid-Term Change Calculators	Apex + Formula CPQ's pricing engine handles standard proration, but custom calculators are common for: Tiered proration: different rates for different periods within the contract term Volume-based adjustments: recalculate tier breaks on amendment Custom credit calculation: when a downgrade should trigger a credit note, custom Apex calculates the credit amount and writes to Salesforce Billing True-up calculations: aggregate overages across subscription period	Proration Policy Override + Apex RC's Proration Engine is more extensible: Custom Proration Policy Type: implement `ProrationType` interface for fully custom proration math Usage-based adjustments: integrate RC with Salesforce Revenue Intelligence for consumption-based proration Complex credit scenarios: Flow + Apex to generate Credit Memo records in RC Billing on cancel/downgrade True-up automation: RC's Asset State Period history enables automated true-up calculation at period end
CPQ-to-RC Migration Bridging	Migration Pattern Common migration bridging patterns from CPQ side: Read `SBQQ__Subscription__c` records and transform to `Asset` + `AssetLineItem` via data migration script Map CPQ custom fields to RC custom fields (requires field mapping document) Dual-write period: write to both SBQQ__Subscription__c and Asset during transition Validate subscription counts match: total CPQ subscriptions = total RC AssetLineItems	Migration Pattern Common migration bridging patterns from RC side: Use RC's Migration Workbench (ISV tooling) to bulk-import Subscriptions as Assets Preserve historical amendment history: load `AssetStatePeriod` records for each historical amendment Re-map CPQ renewal chains to RC `LifecycleStartDate` continuity Validate billing continuity: ensure no billing gaps during cutover via RC billing reconciliation report
Complex Proration Overrides	High Effort Apex Plugin CPQ's proration is hardcoded in the managed package for the standard formula. Complex overrides require: Implementing `SBQQ.QuoteCalculatorPlugin` to intercept pricing calculations Custom formula fields on Quote Line to override `SBQQ__ProrateMultiplier__c` Post-amendment Apex trigger to recalculate if CPQ's proration is incorrect for the scenario	Medium Effort Policy + Flow RC's Proration Policy framework is designed for extension: Custom Proration Policy type via Apex interface (`ProrationPolicyCalculator`) Flow-based proration override: invoke custom proration logic via Invocable Action within the Order Lifecycle Flow Product-specific proration: assign different policies to different products / categories — no blanket override needed
Approval Integration on Amendments	Medium Effort Amendment approvals in CPQ flow through the standard Salesforce Approval Process or Advanced Approvals (separate add-on). The Amendment Quote triggers the approval; approval criteria can reference Quote and Quote Line fields (discount %, term change, etc.). Common pattern: `SBQQ__Quote__c.SBQQ__Type__c = 'Amendment'` as entry criteria.	Medium Effort RC integrates approvals at the Amendment Order level. Options: Standard Approval Process on `Order` object with Record Type = Amendment Flow-based approval within Order Lifecycle Flow (recommended for RC) Criteria: order total, delta amount, customer tier, amendment type Integration with Salesforce Approvals (Slack-based) for remote approvals

Architect Advisory — Common Pitfalls

CPQ: The CPQ managed package's Apex triggers run synchronously on Order activation. Heavy customization in SBQQ.AmendmentSaver or post-contract-creation triggers can hit CPU/SOQL limits on large contracts (100+ subscription lines). Use async Apex (Queueable/Batch) for post-processing.
CPQ: Amending a contract with CPQ+ while the original order was created without CPQ can break subscription linkages. Always ensure the original order's SBQQ__Contracted__c flag was set correctly.
RC: Asset Actions are validated against a state machine. If a product is not configured with the correct Asset Action eligibility, the action will silently fail or throw a platform error. Always test each Asset Action type against each product type in a scratch org before production deployment.
RC: The Order Lifecycle Flow is a single Autolaunched Flow per Order Record Type. Errors inside the Flow will roll back the entire Order activation. Implement robust fault paths and consider splitting complex logic into sub-flows.
Migration: CPQ subscriptions with SBQQ__TerminatedDate__c in the past represent cancelled subscriptions — do not migrate these as Active Assets in RC. Load them as Status = 'Cancelled' Assets with the correct AssetStatePeriod end record.

Subsection Summary — Customization

CPQ customization leans heavily on Apex plugin interfaces (SBQQ.QuoteCalculatorPlugin, SBQQ.ContractAmendmentPlugin) and VF/LWC overrides to extend managed-package behavior. Revenue Cloud customization uses Flow-first patterns with Apex escape hatches — the platform encourages declarative configuration via Asset Actions, Proration Policies, and Order Lifecycle Flows before resorting to Apex. RC's Connect API enables use cases (headless amendments, third-party portals) that CPQ cannot support without heavy custom development. Organizations on the CPQ-to-RC migration path should plan for a 6–12 month parallel-run period to validate amendment and billing continuity before full cutover.