CPQ vs RC
Section 03

Quote & Order Management

An architect-level deep-dive comparing how Salesforce CPQ (SteelBrick origin) and Salesforce Revenue Cloud each handle the full quote-to-order lifecycle — from the data model and persona journeys through automation engines, configuration effort, and common customization patterns.

Salesforce CPQ (SteelBrick)
Salesforce Revenue Cloud (RC)
✓ Supported natively
~ Partial / workaround needed
✗ Not supported out of the box
3.1

Use Case, User Journey & Personas

When to use this section · who drives it · step-by-step journeys on both platforms

When to use — Quote & Order Management

Core Use Cases

  • Generating, versioning, and presenting commercial quotes to prospects and customers
  • Applying discounts, bundles, and special pricing terms before deal acceptance
  • Managing e-signature and formal quote acceptance workflows
  • Converting accepted quotes into activated orders that trigger fulfillment
  • Producing order line items that downstream Billing, RevRec, or ERP systems can consume
  • Creating Assets (entitlements) that represent what the customer owns post-order

Internal Personas

👨‍💼
Sales Representative

Owns quote creation, product selection, and initial discount requests. Primary user of the quote configurator.

📊
Sales Manager

Reviews and approves discount levels above rep authority. Monitors quote pipeline via reports.

📦
Order Management Team

Activates orders, coordinates with fulfillment, and resolves order exceptions post-acceptance.

📋
Deal Desk

Structures complex, non-standard deals. Manages multi-year ramps, custom terms, and exception pricing.

💵
Finance / RevRec

Reviews order integrity, validates pricing against policies, and ensures orders are billing-ready.

External Personas

✍️
Customer (E-Sign)

Reviews the rendered quote document and signs electronically via DocuSign, Conga, or built-in RC e-sign.

🤝
Channel Partner (PRM)

Submits deal registrations or quotes through the Partner Community. Subject to partner pricing rules and approval gates.

CPQ — Quote-to-Order Journey

1
Opportunity
Sales Rep qualifies an Opportunity in Salesforce Sales Cloud
Opportunity
↓
2
New CPQ Quote
Rep clicks "New Quote" — CPQ creates a custom SBQQ__Quote__c record linked to the Opportunity
SBQQ__Quote__c
↓
3
Product Configurator
Line editor opens; Rep adds products, selects options, configures bundles, enters quantities
SBQQ__QuoteLine__c
↓
4
Apply Discounts
Manual and rule-based discounts applied; approval workflow triggered if thresholds exceeded
SBQQ__DiscountSchedule__c
↓
5
Generate PDF / Document
HTML/CSS-based quote template rendered to PDF; stored as SBQQ__QuoteDocument__c
SBQQ__QuoteDocument__c
↓
6
E-Signature (DocuSign / Conga)
Quote document sent via third-party e-sign integration; status updated on return
3rd-Party Integration
↓
7
Mark Primary
SBQQ__Primary__c set to true; triggers sync of Amount and Close Date back to Opportunity
SBQQ__Quote__c.SBQQ__Primary__c
↓
8
Order Created
One-click "Order" button creates standard Order and OrderItem records from quote lines
Order + OrderItem
↓
9
Order Activated
Order status changed to "Activated"; downstream Billing or ERP integration consumes the order
Order.Status = Activated

Revenue Cloud — Quote-to-Order-to-Asset Journey

1
Opportunity
Sales Rep qualifies an Opportunity; RC quote creation available directly from the record
Opportunity
↓
2
New RC Quote
RC creates an enhanced standard Quote record in Draft lifecycle state
Quote (standard, RC-enhanced)
↓
3
Product Catalog Selection
RC Product Catalog browsed; products added with attribute configuration (color, size, term, etc.)
QuoteLineItem + Attributes
↓
4
Pricing Applied
RC pricing engine evaluates price books, adjustments, and promotion rules; net price calculated
PricebookEntry + Adjustments
↓
5
Quote Document Generated
Quote document created from template; lifecycle state transitions to Presented
Quote.Status = Presented
↓
6
E-Signature
Sent via Salesforce eSign or integrated DocuSign/Conga; Quote transitions to Accepted on completion
Quote.Status = Accepted
↓
7
Order Created
RC creates an enhanced standard Order with full lifecycle management; OrderItems generated from QuoteLineItems
Order + OrderItem
↓
8
Order Activated → Fulfillment
Order activation triggers orchestration flow; FulfillmentOrder and OrderDeliveryGroup created (SOM)
FulfillmentOrder + OrderDeliveryGroup
↓
9
Assets Created
On order activation, Asset and AssetLineItem records created — customer's entitlements are live
Asset + AssetLineItem
💡
Key Architectural Difference
CPQ Quote is a CPQ-specific custom object (SBQQ__Quote__c) — it does not extend or replace the standard Quote object, which creates a data model fork. Revenue Cloud Quote is the enhanced standard Quote object — platform-native, supported by standard reports, flows, and all ecosystem tools without object translation. This difference cascades into every integration pattern, migration path, and governor limit profile downstream.

Key Takeaway — 3.1

  • Both platforms follow the same conceptual arc: Opportunity → Quote → Document → Sign → Order → Activation
  • CPQ's journey is battle-tested for complex B2B sales but ends at Order activation; Billing/RevRec require the CPQ Billing add-on or a separate platform
  • RC extends the journey natively to Assets and (with SOM) Fulfillment Orders — making it a true order-to-cash platform without add-ons
  • Partner quoting via PRM is supported on both; headless quoting via API is an RC-native pattern not available in stock CPQ
3.2

Licensing Requirements

Which licenses unlock which quoting and order capabilities

CPQ — License Stack

  • ✓
    Salesforce CPQ (Base) — core quoting: SBQQ__Quote__c, line editor, product configurator, PDF generation, approval engine
  • ✓
    Salesforce CPQ+ (Advanced) — adds multi-dimensional quoting, contracted pricing, advanced approvals, and co-term management
  • ~
    CPQ Billing Add-on — required for order-to-invoice automation, subscription management, and revenue recognition within the CPQ stack
  • ✗
    E-Signature (DocuSign / Conga) — no native e-sign; third-party ISV license required at additional cost per envelope or user
  • ✗
    Salesforce Order Management (SOM) — separate product license for fulfillment orchestration; CPQ does not include SOM

Revenue Cloud — License Stack

  • ✓
    RC Base — quoting (enhanced standard Quote), product catalog, pricing engine, quote-to-order conversion, and Asset creation are all native
  • ✓
    RC Advanced — adds advanced approvals, complex bundling, headless quoting API, and extended lifecycle management
  • ~
    E-Signature — Salesforce-native eSign available; DocuSign connector bundled in some SKUs. Full Conga integration still requires separate license
  • ~
    Salesforce Order Management (SOM) — required for FulfillmentOrder and advanced order routing; available as add-on to RC or as standalone. Billing & RevRec functionality native to RC
  • ✓
    Headless Order API — included with RC Advanced; no separate ISV license needed for API-first quoting patterns

Feature Availability by License Tier

Capability CPQ Std CPQ+ RC Base RC Advanced SOM Add-on
Quote Creation & Line Editor ✓ ✓ ✓ ✓ —
Quote PDF / Document Generation ✓ ✓ ✓ ✓ —
Native E-Signature ✗ ✗ ~ ✓ —
Quote Approval Workflow ✓ ✓ ✓ ✓ —
Advanced / Multi-Step Approvals ~ ✓ ~ ✓ —
Quote-to-Order Conversion ✓ ✓ ✓ ✓ —
Order Activation & Lifecycle ✓ ✓ ✓ ✓ —
Contracted Pricing on Renewal ✗ ✓ ✓ ✓ —
Asset Creation on Activation ✗ ✗ ✓ ✓ —
Fulfillment Order / SOM Routing ✗ ✗ ✗ ~ ✓
Headless Quote / Order API ✗ ✗ ~ ✓ —
Proration on Mid-Cycle Orders ✗ (Billing add-on) ✗ (Billing add-on) ✓ ✓ —

Key Takeaway — 3.2

  • CPQ Base + CPQ+ covers quoting comprehensively but requires add-ons (Billing, SOM, e-sign ISV) for a full order-to-cash stack — total cost is significantly higher than the base license suggests
  • RC Base bundles more of the order-to-cash journey natively; e-sign and SOM are optional add-ons rather than hard requirements for basic order management
  • For net-new implementations evaluated purely on capability-per-dollar, RC is structurally more efficient unless the org has deeply customized CPQ already in production
3.3

Data Model

Key objects, field-level detail, and the order-to-asset object relationship map

Data Model Diagram — Quote & Order Management
Quote & Order Data Model

Quote-to-Order-to-Asset object relationships across CPQ and Revenue Cloud

CPQ Core Objects

Object API Name Type Purpose Key Fields
SBQQ__Quote__c CPQ-Specific Primary quote object — all CPQ quoting lives here, not on the standard Quote SBQQ__Opportunity2__c, SBQQ__Primary__c, SBQQ__Status__c, SBQQ__ExpirationDate__c, SBQQ__Ordered__c
SBQQ__QuoteLine__c CPQ-Specific Individual line items on a CPQ quote, including bundle children SBQQ__Product__c, SBQQ__Quantity__c, SBQQ__ListPrice__c, SBQQ__CustomerPrice__c, SBQQ__Discount__c, SBQQ__SubscriptionPricing__c
SBQQ__QuoteDocument__c CPQ-Specific Tracks generated PDF documents and e-sign status per quote version SBQQ__Quote__c, SBQQ__Template__c, SBQQ__DocumentFormat__c, SBQQ__SignatureStatus__c
SBQQ__QuoteLineGroup__c CPQ-Specific Groups quote lines for section headers, group-level discounts, or segment pricing on a quote SBQQ__Quote__c, SBQQ__Number__c, SBQQ__ListTotal__c, SBQQ__CustomerTotal__c
Order Platform-Standard Standard Salesforce Order object — CPQ populates this from the primary quote AccountId, OpportunityId, SBQQ__Quote__c, Status, EffectiveDate, EndDate
OrderItem CPQ-Modified Standard Order Product — CPQ writes custom fields from quote lines; used by downstream Billing SBQQ__QuoteLine__c, SBQQ__Contracted__c, SBQQ__BillingFrequency__c, Quantity, UnitPrice

Revenue Cloud Core Objects

Object API Name Type Purpose Key Fields
Quote RC-Enhanced Standard RC uses and extends the standard Quote object with lifecycle state management OpportunityId, Status (lifecycle), ExpirationDate, TotalAmount, QuoteToOrderStatus
QuoteLineItem RC-Enhanced Standard Standard Quote Line Item enhanced with RC attribute and pricing fields QuoteId, Product2Id, Quantity, UnitPrice, TotalPrice, product attribute fields
Order RC-Enhanced Standard Standard Order enhanced with RC lifecycle state machine and order action types Status (lifecycle), OrderAction (New/Amend/Cancel/Renew), StartDate, EndDate, BillingStatus
OrderItem RC-Enhanced Standard RC Order Product with lifecycle and asset linkage fields OrderId, Product2Id, Quantity, UnitPrice, EndDate, AssetId
Asset RC-Enhanced Standard Customer-owned entitlement created on order activation; drives renewals and amendments AccountId, Product2Id, Quantity, Status, LifecycleStartDate, LifecycleEndDate
AssetLineItem RC-Standard Granular asset line — links Asset to specific OrderItem and tracks quantity, term, and pricing history AssetId, OrderItemId, StartDate, EndDate, TotalAmount, RevenueInstallmentPolicy
FulfillmentOrder SOM / RC-Standard Groups OrderItems for physical or digital fulfillment routing; requires SOM license for full usage OrderId, FulfilledToName, Status, InvoiceId, DeliveryMethodId
OrderDeliveryGroup SOM / RC-Standard Groups order items by delivery destination or method within a FulfillmentOrder OrderId, OrderDeliveryMethodId, DeliverToAddress, SellerOrderId

Order-to-Asset Object Relationship Diagram

CPQ — Quote/Order Object Chain
Opportunity
Sales Cloud
→
SBQQ__Quote__c
CPQ Custom Object
→
SBQQ__QuoteLine__c
Line Items
→
SBQQ__QuoteDocument__c
PDF / e-Sign
→
Order
Platform Standard
→
OrderItem
CPQ-Modified
→
CPQ Billing
Add-on Required
Revenue Cloud — Quote/Order/Asset Object Chain
Opportunity
Sales Cloud
→
Quote
RC-Enhanced Standard
→
QuoteLineItem
RC-Enhanced Standard
→
Order
RC Lifecycle-Enabled
→
OrderItem
RC-Enhanced Standard
→
Asset + AssetLineItem
Native on Activation
→
FulfillmentOrder
SOM Add-on
CPQ-Specific Object
RC-Enhanced Object
Platform Standard
SOM Add-on

RC Core Objects — Deep Dive

Quote (RC-Enhanced Standard)
RC uses and extends the standard Quote object with a declarative lifecycle state machine. Lifecycle stages (Draft → Approved → Presented → Accepted) are managed via Order Management flows, not a CPQ managed package. Native reporting, Einstein, and Flow work on this object without namespace workarounds.
Key fields: Status (lifecycle), ExpirationDate, TotalAmount, QuoteToOrderStatus
Created by: Sales rep via the Revenue Cloud Quote UI or Agentforce Quote Agent.
QuoteLineItem (RC-Enhanced Standard)
Standard Quote Line enhanced with product attribute values, Pricing Procedure outputs, and ramp interval fields. Because it extends the standard object, Salesforce-native tooling (Reports, Einstein, Data Cloud) works without translation layers or namespace handling.
Key fields: QuoteId, Product2Id, Quantity, UnitPrice, TotalPrice, product attribute fields
Created by: Auto-created when rep adds a product via Product Configurator. Attributes and pricing populated by the Pricing Procedure engine.
Order (RC Lifecycle-Enabled Standard)
Standard Order enhanced with RC's lifecycle state machine and Order Action types (New, Amend, Cancel, Renew). Each action type triggers different downstream behavior — amendments create delta orders, renewals clone existing assets. No separate custom order object is needed.
Key fields: Status (lifecycle), OrderAction, StartDate, EndDate, BillingStatus
Created by: Auto-generated when a rep converts an Accepted Quote. Activated by lifecycle Flow — no manual field-mapping required.
Asset + AssetLineItem (RC-Enhanced Standard / RC-Standard)
The most impactful RC architectural differentiator. On order activation, RC automatically creates Asset and AssetLineItem records — the customer's entitlement and granular line history. These drive all downstream amendments, renewals, and billing without a custom integration. CPQ has no equivalent native behavior.
Key fields: AssetId, OrderItemId, StartDate, EndDate, TotalAmount, RevenueInstallmentPolicy
Created by: Automatically by the RC order activation engine — no admin action needed, this is native platform behavior.
CartItem (Commerce / Headless RC)
Used in B2B Commerce and headless RC scenarios where a buyer self-configures via storefront. The cart is the pre-quote state. On checkout, the Cart converts to a Quote or Order depending on the checkout flow. Requires B2B Commerce or Experience Cloud license.
Key fields: CartId, Product2Id, Quantity, TotalLineAmount, attribute configuration fields
Created by: Buyer via storefront Product Configurator or programmatically via Connect API / Headless Commerce API.
FulfillmentOrder (SOM Add-on)
Groups OrderItem records for physical or digital fulfillment routing. Required only when the business needs to split an order across fulfillment locations or delivery methods. The core quote-to-order-to-asset path has no dependency on FulfillmentOrder.
Key fields: OrderId, FulfilledToName, Status, InvoiceId, DeliveryMethodId
Created by: Auto-generated by Order Management fulfillment flow on activation. Requires SOM license for production use.

How RC Quote & Order Objects Get Created

Object Creation Method Who Creates It Frequency Notes
Quote UI (Revenue Cloud Quote screen) or Agentforce Quote Agent Sales Rep Per opportunity Standard object — Reports and Flow work natively without namespace workarounds
QuoteLineItem Auto-created via Product Configurator when rep adds product System (rep trigger) Per product added Attributes and pricing populated automatically by Pricing Procedure
Order Auto-created from Quote on Accept / Convert action System (rep or Flow trigger) Per accepted quote OrderAction type (New/Amend/Cancel/Renew) controls downstream behavior
OrderItem Auto-created from QuoteLineItem during quote-to-order conversion System Per order line Inherits pricing and attribute data from QuoteLineItem
Asset Auto-created on Order activation by RC engine System (activation engine) Per activated order Drives all future amendments, renewals, and billing — no custom integration needed
AssetLineItem Auto-created alongside Asset on activation System (activation engine) Per OrderItem activated Links Asset to specific OrderItem; tracks quantity, term, and pricing history
CartItem Buyer action in storefront or Connect API call Buyer (self-service) or Integration Per cart interaction Only in B2B Commerce / headless scenarios; converts to Quote or Order at checkout
🖥️
Revenue Cloud Quote UX — Product Configurator Sales reps interact with quotes through the Revenue Cloud Quote UI, which presents the Product Configurator as the primary interface for adding products, selecting attributes, and viewing the pricing waterfall. Unlike CPQ's embedded Visualforce quote line editor, the RC Product Configurator is built on LWC and is fully customizable via Experience Builder without a managed-package upgrade cycle. Reps see the live pricing breakdown (List → Discount → Net) in real time as they configure. The Agentforce Quote Agent (AI-assisted quoting) reads from and writes to the same Quote and QuoteLineItem records — no separate integration model required.
⚠️
End-User Interaction vs. Admin Setup Quote and Order records are created by sales reps through the UI. OrderItem, Asset, and AssetLineItem records are created automatically by the platform — reps never create these directly. Admins/architects configure the underlying Pricing Procedures, Order Management flows, and lifecycle state machines as one-time setup activities, not per-transaction tasks.
🧑‍💻 User Experience — Admin Setup vs. End-User Self-Service (Quote & Order)
Salesforce CPQ
Admin Must Do
  • Configure all product rules, option constraints, and configuration attributes
  • Build and maintain QCP JavaScript for any pricing customization
  • Set up quote templates (HTML/CSS) for document generation
  • Manage e-sign provider integration (DocuSign, Adobe Sign)
  • Manage package upgrades — requires org sandbox testing cycle
What Sales Reps Can Do
  • Add products and bundles via CPQ configurator (Visualforce-based)
  • Apply manual discounts within approval thresholds
  • Generate and send quote PDFs
  • View final price — but not the calculation breakdown
CPQ Verdict
Heavy admin dependency. Every new product configuration rule, pricing change, or document tweak requires admin or developer involvement. Reps work within tightly controlled guardrails with minimal self-service latitude.
Revenue Cloud
Admin Must Do (One-Time Setup)
  • Build and activate Pricing Procedures (Flows) and Context Mappings
  • Configure Order Management lifecycle flows and Order Action routing
  • Set up Product Configurator layout and attribute display rules in Experience Builder
Product Manager / Ops Self-Service
  • Add/modify products, attributes, and categories via Products & Catalog app — no deployment
  • Update pricing rules and discount schedules via Revenue Management app — date-effective, no code
Sales Rep Self-Service
  • Configure products with full attribute visibility; see live pricing waterfall
  • Self-create ramp deals directly in the Quote UI — no admin help needed
  • Use Agentforce Quote Agent for AI-assisted quoting from natural language
  • View full discount breakdown (List → Tier → Partner → Net) without requesting a report
RC Verdict
Three-tier model: architects set up the engine, product managers own catalog and pricing day-to-day, reps operate with meaningful self-service. Admin is the backstop, not the bottleneck.

Self-Service Configurability Rating — Quote & Order

Quote creation by rep without admin help
CPQ75%
Revenue Cloud95%
Ramp deal self-configuration by seller
CPQ30%
Revenue Cloud90%
Product / pricing change without code deploy
CPQ20%
Revenue Cloud80%
Pricing transparency visible to seller
CPQ25%
Revenue Cloud85%

Key Takeaway — 3.3

  • CPQ's custom object data model (SBQQ__Quote__c) means all quoting lives outside the standard data architecture — every report, flow, and integration must account for this fork
  • RC's standard-object approach means native Salesforce tooling (Flow, Reports, Data Cloud, Einstein) works on quotes and orders without translation layers
  • The Asset + AssetLineItem native creation on order activation is the single most impactful RC architectural difference — it eliminates an entire integration workstream that CPQ implementations typically require
  • FulfillmentOrder / SOM objects are additive in RC; the core quote-to-order-to-asset path requires no SOM license
3.4

Automations

Platform-delivered automation behaviors that drive the quote and order lifecycle

CPQ — Built-In Automations
🔁
Primary Quote Sync to Opportunity
When SBQQ__Primary__c = true, CPQ automatically syncs Amount, CloseDate, and line-count fields back to the parent Opportunity. Configurable via Org Preferences.
📋
One-Click Order Generation
The "Order" action button creates standard Order and OrderItem records from all active quote lines in a single transaction, including subscription field mapping.
💰
Contracted Pricing Auto-Apply (CPQ+)
On renewal or amendment quotes, contracted prices from prior orders are automatically pulled and applied, bypassing list price. Requires CPQ+ license and SBQQ__ContractedPrice__c records.
🔗
Order Product–Subscription Linking
CPQ automatically creates SBQQ__Subscription__c records from OrderItems marked as subscription products, linking them to parent contracts for renewal tracking.
📄
Quote Line Group Automation
Group-level totals (SBQQ__QuoteLineGroup__c) aggregate child line amounts automatically; group discounts propagate down to child lines via the pricing calculator.
🕒
Quote Expiration Notifications
Standard workflow rules or Process Builder (legacy) can be used; no native quote expiration enforcement engine — typically implemented via Flow or trigger.
Revenue Cloud — Built-In Automations
⚙️
Quote Lifecycle State Machine
RC enforces a formal state machine: Draft → In Review → Presented → Accepted → Cancelled. State transitions are governed by declarative rules and can trigger downstream automations via Flow.
🚀
Order Orchestration Flows
On order activation, RC triggers a configurable orchestration flow that routes to fulfillment, creates Assets, fires Platform Events for downstream integration, and handles split-order scenarios.
💸
Native Asset Creation on Activation
Asset and AssetLineItem records are automatically created from OrderItems when an Order is activated — no custom trigger or Billing add-on required.
📦
Fulfillment Order Routing (SOM)
With SOM, RC auto-creates FulfillmentOrder and OrderDeliveryGroup records based on routing rules (warehouse, territory, priority). Routing logic is Flow-configurable.
⚖️
Proration Auto-Calculation
For mid-cycle orders (amendments), RC automatically calculates prorated amounts based on remaining days in the billing period — native to the pricing engine, no custom apex needed.
🔌
Platform Events for Order Status
RC publishes Platform Events on key order lifecycle transitions (e.g., OrderStatusChanged), enabling event-driven ERP integration, notification systems, and async processing patterns.

Key Takeaway — 3.4

  • CPQ automations are centered on the quote-to-order conversion and pricing synchronization — the engine is powerful but terminates at order creation
  • RC automations extend into post-order territory natively: asset creation, fulfillment routing, proration, and Platform Events are all delivered without custom code
  • The RC state machine provides a formalized, auditable quote lifecycle that CPQ lacks — CPQ Status is a picklist with no enforced transition logic by default
  • Both platforms rely heavily on Flow for custom automation logic; RC's deeper Flow integration (order orchestration flows) reduces the need for Apex in standard scenarios
3.5

Configuration (Architect Setup Level)

Declarative effort required per task — assessed for a senior Salesforce architect

Configuration Task CPQ Effort RC Effort Notes
Quote object setup & page layout Low Low CPQ uses custom object; RC uses standard Quote — both require layout config and permission sets
Quote template / document generation Medium Medium CPQ uses HTML/CSS-based templates with SBQQ template tags; RC uses OmniScript/document builder or external tools
E-signature integration Medium–High Medium CPQ requires third-party ISV setup and mapping; RC has tighter native integration with lower configuration overhead
Order settings & activation behavior Medium Medium CPQ order settings in Org Preferences; RC uses Order Settings page and lifecycle configuration
Contracted pricing setup High Medium CPQ requires CPQ+ license + ContractedPrice records + co-term logic; RC handles this through standard price book and asset lifecycle
Asset creation configuration N/A — Billing add-on Medium CPQ itself does not create Assets; requires CPQ Billing. RC creates Assets natively — configure Asset fields, mappings, and lifecycle policies
Fulfillment / SOM integration N/A — Not available High RC + SOM requires fulfillment routing rules, warehouse location setup, and order delivery method config — significant but well-documented
Quote approval workflow Medium Medium Both use native Approval Processes or Flow-based approvals; CPQ adds approval conditions via SBQQ__ApprovalCondition__c records
Headless quote / order API N/A — Not available High RC headless pattern requires API enablement, Connected App setup, OAuth scopes, and consumer-side integration work
Order-to-opportunity sync Low Low CPQ: Org Preference checkbox; RC: standard Opportunity-Order relationship with Flow sync for custom fields

Configuration Complexity Watch-outs

  • CPQ Org Preferences — a single setup page with 40+ boolean toggles that interact with each other in non-obvious ways. Document every toggle state before go-live
  • CPQ Template Editor — HTML/CSS-based with a proprietary tag syntax; not all CSS is supported. Budget 2–4 weeks for a polished multi-section template
  • RC Order Lifecycle — misconfigured lifecycle states can block order activation silently; always validate with an end-to-end quote-to-order smoke test in a sandbox
  • SOM Routing Rules — OrderDeliveryGroup routing logic must be tested across all product type combinations; edge cases multiply quickly with mixed physical/digital SKUs

Key Takeaway — 3.5

  • Overall configuration effort is comparable between CPQ and RC for the core quoting and order conversion path (both Medium effort)
  • RC has lower effort for contracted pricing and e-sign; CPQ has higher effort for these same tasks and cannot natively handle Asset creation or headless APIs at all
  • RC's SOM integration (when needed) is genuinely High effort, but it is an optional add-on — the baseline without SOM is lighter than CPQ's equivalent full-stack
3.6

Customization (Common Additions)

Frequently implemented custom extensions and integration patterns on both platforms

Salesforce CPQSteelBrick origin
Revenue CloudRC Advanced

CPQ Custom Extensions

  • ✓
    Custom Quote Document Templates — HTML/CSS templates with SBQQ merge tags; architects typically build multi-section templates with conditional sections, custom fonts, and co-branded headers. Stored as HTML static resources or visualforce.
  • ✓
    Visualforce / LWC Quote Line Editor Overrides — the standard CPQ line editor can be partially replaced with custom LWC components for complex UX requirements (e.g., real-time inventory checks, custom pricing calculators) using the CPQ JavaScript API.
  • ✓
    Apex Triggers for Custom Order Transformation — SBQQ__Order__c and OrderItem triggers to apply business logic not covered by CPQ configuration: e.g., custom field mapping from quote lines to order products, segment-level calculations, ERP field population.
  • ✓
    Custom Order Activation Sequences — override of standard order activation via Apex OrderActivation plugins or post-activation flows: e.g., generating external IDs, calling provisioning APIs, creating custom entitlement records.
  • ✓
    ERP Integration Middleware — outbound order data typically sent via MuleSoft, Boomi, or custom REST callouts triggered from order activation. CPQ provides no native outbound Order API; all ERP sync is custom-built.

Revenue Cloud Custom Extensions

  • ✓
    Headless Quoting via LWC / External UI — RC's headless quoting pattern allows custom storefronts, portals, or mobile apps to create and manage quotes via REST API, with RC as the pricing and configuration engine behind a custom UX.
  • ✓
    Complex Order Routing via Flow — order orchestration flows can be extended to implement complex routing logic: multi-warehouse allocation, backorder handling, priority queuing, and carrier selection — all declarative via Flow Orchestration.
  • ✓
    Custom Fulfillment Orchestration — beyond SOM's built-in routing, custom fulfillment steps can be inserted into the orchestration flow: e.g., calling a 3PL API, waiting for warehouse confirmation via Platform Event, or triggering IoT provisioning.
  • ✓
    ERP Integration via MuleSoft / Custom API — RC publishes Platform Events on order state transitions, enabling event-driven ERP integration. The standard Order object's API accessibility reduces the mapping complexity vs. CPQ's custom object translation.
  • ✓
    Custom Asset Lifecycle Actions — post-activation asset actions (upgrade, downgrade, add-on, cancellation) can be extended with custom Apex or Flow logic, modifying AssetLineItem records and triggering prorated order amendments automatically.

Anti-Patterns — What to Avoid

CPQ Anti-Patterns

  • Overriding the pricing calculator with Apex — calling the SBQQ pricing calculator from Apex triggers a nested async invocation that frequently hits governor limits. Use Price Rules and Price Actions instead
  • Triggers on SBQQ__QuoteLine__c at high volume — CPQ recalculates all lines on any change; triggers on QuoteLine can fire 10-50x per user action, causing CPU timeout errors
  • Multiple Primary Quotes on one Opportunity — while the platform allows it briefly during transitions, persistent multi-primary states cause Amount sync conflicts; enforce a single-primary invariant with validation rules
  • Bypassing the Order button with direct DML — creating Order / OrderItem records directly (not via CPQ's order action) skips subscription linking, contracted pricing stamping, and quote-line–order-product mapping; produces orphaned subscriptions

Revenue Cloud Anti-Patterns

  • Skipping lifecycle state validation in integrations — API callers that update Order Status directly without honoring the RC lifecycle state machine break the orchestration flow and leave Assets in inconsistent states
  • Creating AssetLineItems manually outside order activation — AssetLineItem records should only be created by the RC order activation engine; manual creation bypasses proration logic and billing triggers
  • Using legacy CPQ-style Visualforce in RC — RC's quoting UX is LWC-first and headless-API-compatible; Visualforce overrides are incompatible with the headless pattern and create maintenance debt
  • Ignoring SOM routing complexity during initial design — deferring fulfillment routing design until after go-live is a common RC mistake; routing rule gaps cause FulfillmentOrder creation failures that are hard to debug in production

Key Takeaway — 3.6

  • CPQ customization is mature and well-documented — the ISV ecosystem is large, patterns are proven, and most edge cases have solved reference architectures. The trade-off is technical debt accumulation from Apex-heavy implementations
  • RC customization is leaning into LWC, Flow, and API-first patterns — more aligned with Salesforce's long-term platform direction and significantly less Apex-dependent for standard scenarios
  • The headless quoting pattern in RC is a genuine architectural advantage for organizations building custom front-end experiences (B2B portals, mobile commerce, self-service quoting) — CPQ has no equivalent native capability
  • Both platforms punish anti-patterns severely in production; enforce architectural governance checkpoints before any customization reaches a sandbox deployment
3.7

RC Quote Generation — Deep Dive

Who creates quotes, quote-first vs opportunity-first, customer self-service, and Sales Cloud continuity

The Question Every Rep Asks In CPQ, the answer is simple and rigid: you always start with an Opportunity, then create a Quote from it. Revenue Cloud gives you more flexibility — but that flexibility raises real questions about where the process begins, who can initiate it, and how Sales Cloud staples like forecasting, territory management, and sharing still work when quote creation is decoupled from the Opportunity record.

Path 1 — Opportunity-First (Standard / Recommended)

🏆 Same as CPQ — Rep creates Opportunity first, then creates a Quote from it
Opportunity
→
New Quote
→
Configure Products
→
Accept → Order
  • The Quote.OpportunityId lookup field links the quote to the Opportunity — exactly as in CPQ
  • Sales Cloud forecasting reads from the Opportunity (Amount, CloseDate, ForecastCategory) — RC can be configured to sync the primary quote's TotalAmount back to Opportunity.Amount via a Flow trigger, same pattern as CPQ's SBQQ__Primary__c sync
  • Territory management and sharing rules apply at the Opportunity level — the Quote inherits sharing from its parent Opportunity by default; no additional sharing configuration needed
  • Pipeline reports, forecast dashboards, and Einstein Deal Insights all continue to read from Opportunity — the Quote is a child record and does not disrupt these
  • Recommended for all field sales and enterprise B2B scenarios — preserves full Sales Cloud continuity

Path 2 — Quote-First (RC-Only Capability)

⚡ Rep (or system) creates a Quote directly — no Opportunity required upfront
New Quote (standalone)
→
Configure + Price
→
(optionally) Link to Opportunity
→
Accept → Order
  • RC allows a Quote to be created with OpportunityId as null — the standard object field is not required by the platform
  • This enables transactional / high-velocity sales patterns: inside sales teams, renewal processing, e-commerce order capture, and integration-driven quoting where the deal is already qualified externally
  • A quote created without an Opportunity can be linked to an Opportunity later by setting OpportunityId — the Opportunity-sync Flow then picks it up for forecast contribution
  • Sharing caveat: A standalone Quote (no parent Opportunity) does not inherit Opportunity-level sharing. You must define explicit Quote-level sharing rules, OWD settings, or a sharing Flow to ensure the right reps and managers can see it
  • Forecasting caveat: A standalone Quote contributes nothing to forecast until it is linked to an Opportunity. If your org relies on Opportunity-based forecasting, enforce the link via a required field validation rule or a Flow-based guardrail
CPQ comparison: This path does not exist in CPQ. SBQQ__Quote__c has a required lookup to Opportunity — you cannot create a CPQ quote without an Opportunity. This is one of the hard architectural constraints of the managed-package model.

Path 3 — Customer Self-Service Quoting (Experience Cloud / Headless)

🛍️ Customer (CC / Experience Cloud license) generates their own quote via a portal or storefront
Option A — Experience Cloud Portal (B2B Self-Service)
  • A customer with a Customer Community (CC) or Partner Community license can access a Salesforce Experience Cloud site where RC surfaces the Product Configurator as an LWC component
  • The customer browses the product catalog, configures attributes, and submits — this creates a Quote (or CartItem → Quote) directly in the org
  • Quote.OwnerId is set to the associated account owner or a queue; the rep is notified via Flow/notification and can review before the quote proceeds to acceptance
  • Requires: Experience Cloud license + RC license for the portal site. The CC license does not include a full Sales Cloud seat — the customer sees only what is explicitly exposed on the portal page
  • Forecasting: the system can auto-create an Opportunity from the self-service quote via Flow, ensuring it feeds the rep's forecast; or the rep can manually link it after review
Option B — B2B Commerce Storefront (Cart → Quote → Order)
  • Customer interacts with a B2B Commerce storefront; products are added to a Cart using CartItem records
  • At checkout, the Cart converts to an Order (for immediate purchase) or a Quote (for negotiation / approval before commitment)
  • The full RC Pricing Procedure runs at checkout — the customer sees the same attribute-based pricing the internal rep would see
  • Requires: B2B Commerce license + RC license. No separate Sales Cloud seat needed for the buyer
Option C — Headless API (Custom Storefront / Partner System)
  • An external system (customer portal built on React/Angular, ERP, or partner system) calls RC's Connect API / Commerce API to create Quote and QuoteLineItem records programmatically
  • The Pricing Procedure still runs server-side — the external UI just sends product selections and attribute values; RC returns priced line items
  • No Salesforce UI license required for the end buyer — only the integration user needs a Salesforce API license
CPQ comparison: CPQ has no native customer self-service quoting capability. A customer cannot access or create a CPQ quote directly. Workarounds exist (Visualforce portals surfacing CPQ data) but are heavy custom builds with significant managed-package constraints. This is a genuine CPQ gap that RC closes natively.

Sales Cloud Continuity — Forecasting, Territory & Sharing

📊
Forecast Management
Salesforce Forecast Management reads from Opportunity.Amount, ForecastCategory, and CloseDate — it has no native awareness of Quote records. RC handles this via a Flow-based sync (identical in concept to CPQ's Primary Quote sync):
  • When a Quote is marked as primary (or accepted), a Flow copies Quote.TotalAmount → Opportunity.Amount and optionally updates ForecastCategory
  • For standalone quotes (no Opportunity), a Flow can auto-create an Opportunity on quote acceptance and link both records — ensuring nothing falls through the forecast gap
  • Collaborative Forecasting and Pipeline Inspection continue to work unchanged — they never read from the Quote object directly
  • If your org uses Revenue Intelligence / Einstein Forecasting, the Opportunity record is still the source of truth — RC does not change this contract
🗺️
Territory Management (Enterprise Territory Management)
Territory assignment rules in Salesforce ETM run against Account and Opportunity records — not Quote records. RC does not disrupt this:
  • When a Quote is linked to an Opportunity, it inherits the Opportunity's territory assignment automatically — Quote has no separate territory field
  • For standalone quotes, territory context comes from the Quote.AccountId lookup — the account's territory assignment can be read by Flow to set Quote.OwnerId to the correct territory rep
  • Territory-based forecast rollups are entirely Opportunity-driven — standalone quotes that haven't been linked yet simply do not appear in territory forecasts until linked
  • Recommendation: For orgs using ETM heavily, enforce the Opportunity link via a required field or a Flow that auto-creates the Opportunity on Quote creation to prevent territory blind spots
🔐
Record Sharing
The standard Quote object follows Salesforce's standard sharing model:
  • Opportunity-linked quotes: Sharing is controlled by the parent Opportunity's sharing settings. If a manager can see the Opportunity, they can see its child Quotes — this is identical to standard Salesforce parent-child sharing behavior
  • Standalone quotes: OWD (Org-Wide Default) for the Quote object applies. If Quote OWD is "Private," only the owner and above see it. Configure Quote OWD to "Read/Write" or use sharing rules to ensure manager visibility
  • Manual sharing, sharing rules, and Apex managed sharing all work on the standard Quote object — no namespace restrictions (unlike CPQ's SBQQ__Quote__c which can be harder to share-extend from outside the package)
  • Customer / Partner portal sharing: If a CC or Partner Community user creates a quote, the quote is owned by the portal user. A sharing rule or a Flow that shares the record with the account owner ensures the internal rep maintains visibility

Which Quote Path Should You Use?

Scenario Recommended Path Opportunity Required? Forecast Impact Sharing Consideration
Standard B2B field sales Path 1 — Opportunity-First Yes Native — syncs via primary quote Flow Inherits Opportunity sharing
High-velocity / inside sales (fast transactions) Path 2 — Quote-First, link Opp later No (link recommended) Requires Opp link or auto-create Flow Set Quote OWD or sharing rule
Renewal processing (system-initiated) Path 2 — Quote-First via Flow/Apex No (auto-create Opp if needed) Auto-create Opp on quote acceptance Set owner via territory or account team
Customer portal self-service Path 3 — Experience Cloud / CC license No (auto-create on acceptance) Flow creates Opp when quote accepted Share quote with account owner via Flow
B2B Commerce storefront purchase Path 3 — B2B Commerce Cart → Order No Booked revenue; Opp optional for reporting Commerce order shared with account owner
Headless / API-driven quoting Path 3 — Connect API No Downstream system triggers Opp creation Integration user owns; transfer via Flow
CPQ (any scenario) Path 1 only — Opportunity is required Yes — always CPQ Primary Quote sync to Opportunity Inherits Opportunity sharing

Key Takeaway — 3.7

  • For standard field sales, nothing changes: Opportunity → Quote → Order is the same motion as CPQ. Forecasting, territory, and sharing all work identically
  • RC unlocks Quote-First and customer self-service paths that CPQ simply cannot do — standalone quotes, portal-generated quotes, and headless API quoting are native RC capabilities with no equivalent in the managed-package model
  • The Opportunity is still the heart of Sales Cloud forecasting and territory management — RC does not replace it; it removes the hard requirement that a rep must create one before a quote can exist
  • The governing principle for architects: if an Opportunity-free path is enabled, always implement a guardrail (Flow, validation rule, or auto-create) that ensures the Opportunity is eventually created before the deal closes — otherwise the gap will silently corrupt forecast and territory data
  • Customer self-service quoting requires an Experience Cloud or B2B Commerce license on top of RC — a CC license alone is not sufficient; the Product Configurator LWC and Pricing Procedure must be explicitly exposed on the portal page

RC 3.8 — E-Signature Deep Dive

E-signature is the bridge between a finalized Quote and a customer-committed Order. Revenue Cloud does not ship a native e-signature engine — instead it exposes document generation hooks and status fields that integrate with either Salesforce's own eSign offering or third-party providers such as DocuSign or Adobe Acrobat Sign. Understanding exactly where RC ends and e-signature begins is critical for architects.

What Triggers E-Signature in RC

E-signature is not automatic — it is triggered by a deliberate action on a finalized Quote. The typical sequence before an envelope is ever sent:

1
Quote Finalized

Quote status set to Presented or equivalent final status. All line items, pricing, and terms locked.

2
Document Generated

OmniStudio DocGen or Salesforce Document Builder renders the Quote into a PDF using a template. The output is stored as a ContentDocument linked to the Quote.

3
Envelope Sent

A Flow action or Quote document action sends the PDF to the e-sign provider. The provider creates a signing envelope and emails the customer.

4
Customer Signs

Customer opens the email link and signs in the provider's hosted signing UI. No Salesforce login required.

5
Status Writeback

Provider calls back to Salesforce via webhook or polling. Quote status field updated (e.g. Signed). Signed PDF stored as a new ContentDocument.

6
Order Created

"Convert to Order" action unlocked (manually or via Flow automation). Quote becomes the source of truth for the Order.

E-Signature Provider Options

SALESFORCE CONTRACTS (eSIGN)
  • Native — no third-party vendor
  • Bundled with certain RC/CLM SKUs
  • Basic signing workflow
  • Limited template customization
  • Covered in detail below
DOCUSIGN (MOST COMMON)
  • AppExchange managed package
  • Deep Salesforce field mapping
  • Rich template + tag engine
  • Separate DocuSign license required
  • Webhook-based status writeback
ADOBE ACROBAT SIGN
  • AppExchange managed package
  • Strong PDF template control
  • Adobe license required
  • Less common in pure Salesforce shops
  • Webhook or polling writeback

Salesforce Contracts (eSign) — Deep Dive & Limitations

Salesforce's native e-signature offering is bundled with certain Revenue Cloud and Salesforce Contracts (CLM) SKUs. It removes the need for a third-party vendor but comes with meaningful constraints that teams frequently underestimate.

✓ WHAT IT DOES WELL
  • Zero additional vendor cost if bundled with your RC SKU
  • Native Salesforce objects — no data leaves the org for envelope management
  • Basic sequential and parallel signing workflows
  • Standard signer authentication (email + access code)
  • Signed document stored directly in Salesforce Files
  • No AppExchange managed package to maintain
✗ LIMITATIONS
  • No SMS / phone-based signer authentication
  • No in-person signing kiosk mode
  • Limited signer UX customization (branding, colors, fonts)
  • No bulk send / PowerForms equivalent
  • No advanced routing (conditional recipients, role-based routing)
  • No built-in ID verification (driver's license, passport scan)
  • Audit trail less detailed than DocuSign Certificate of Completion
  • Not available as a standalone product — requires CLM or RC license
  • Limited AppExchange ecosystem (fewer pre-built connectors)
AUTHENTICATION GAP

Only supports email + access code. No SMS OTP, no ID document scan, no knowledge-based authentication (KBA). For regulated industries (financial services, healthcare) this may not meet compliance requirements — DocuSign or Adobe Sign offer those tiers.

ROUTING LIMITATIONS

Sequential routing is fixed at envelope creation — you cannot branch based on signer responses or conditionally add approvers mid-flow. Complex multi-party deals (customer + legal + finance) may require custom Flow orchestration to compensate.

BRANDING & UX

The signing experience is Salesforce-branded with minimal customization. Enterprises that want fully white-labeled signing pages (logo, colors, domain) will need DocuSign or Adobe Sign. This is often a deal-breaker for enterprise deals where brand consistency matters.

BULK & HIGH-VOLUME

No PowerForms equivalent and no bulk-send capability. Each envelope must be created individually. For high-volume transactional deals (renewals, amendments at scale) this creates operational overhead unless custom automation is built.

AUDIT & LEGAL EVIDENCE

The audit trail captures signing events but lacks DocuSign's tamper-evident Certificate of Completion with full IP/timestamp/device chain. For high-value contracts or jurisdictions requiring strong evidence of signing intent, this may require additional legal review.

LICENSE DEPENDENCY

Not available as a standalone add-on. If the RC or CLM contract changes, eSign access can disappear. Teams that invest heavily in native eSign workflows carry a license-dependency risk that third-party providers (with their own independent contracts) do not.

Status Writeback & Order Automation

The signed status must flow back to the Quote to unlock the "Convert to Order" step. How this works depends on the provider.

Provider Writeback Mechanism Field Updated Automation Trigger
Salesforce eSign Native platform event Quote.Status → Signed Record-Triggered Flow on Quote Status change
DocuSign Webhook → Connect → Flow dsfs__DocuSign_Envelope_Status__c → Completed Flow triggered on envelope status field update
Adobe Sign Webhook → Flow echosign_dev1__Agreement_Status__c → Signed Flow triggered on agreement status field update

Recommended automation pattern: Use a Record-Triggered Flow on the Quote's status/envelope field. When it transitions to the signed state, automatically set Quote.Status = 'Accepted' and call the "Activate Quote" action. This removes the manual "Convert to Order" button click and prevents reps from forgetting to complete the cycle.

Self-service path (Experience Cloud): When the customer signs via a portal, the same writeback occurs — the difference is the signer is already authenticated as a Community user. The envelope is still created server-side via Flow and the signing link is surfaced on the portal page rather than emailed.

CPQ vs. RC — E-Signature Integration Model

Dimension CPQ Approach RC Approach
Native eSign None — always required a third-party managed package Salesforce Contracts (eSign) available natively with CLM/RC SKUs
DocuSign integration DocuSign for Salesforce managed package, direct CPQ Quote action Same managed package — wired via Quote document action or Flow
Document generation CPQ Quote Templates (HTML-based, limited) OmniStudio DocGen or Salesforce Document Builder (richer templates)
Automation post-sign CPQ Primary Quote sync + DocuSign webhook → Process Builder/Flow Record-Triggered Flow on Quote status — cleaner, all declarative
Self-service signing No native self-service — required custom portal work Experience Cloud portal + Flow surfaces signing link natively
Multi-party signing DocuSign routing only — no native multi-signer support Same — DocuSign or Adobe Sign for complex routing; eSign for basic

Key Takeaway — 3.8

  • RC does not ship a native e-signature engine — it provides document generation hooks and status fields. The actual signing happens in Salesforce eSign, DocuSign, or Adobe Sign
  • Salesforce Contracts (eSign) is viable for straightforward B2B deals — single or sequential signers, standard authentication, no white-labeling requirement. It removes third-party vendor cost and complexity
  • Salesforce eSign has hard limits that matter in enterprise deals: no SMS/ID verification, no conditional routing, no bulk send, limited branding, and a thinner audit trail than DocuSign — evaluate these against your compliance and UX requirements before committing
  • DocuSign remains the default for complex deals — regulated industries, multi-party routing, high-volume renewals, or any deal where white-labeled signing UX is a requirement
  • Automate the post-sign transition — use a Record-Triggered Flow to detect the signed status and activate the Quote automatically. Never rely on a rep to click "Convert to Order" after signing
  • Self-service signing via Experience Cloud follows the same writeback model — the only difference is the signing link is surfaced in the portal rather than emailed, and the signer is already authenticated as a Community user

RC 3.9 — Order Generation Deep Dive

An Order in Revenue Cloud is not a manual record — it is a structured conversion of a finalized, accepted Quote. Understanding exactly when the Order is created, what is copied from the Quote, which platform mechanisms fire, and what settings govern the process is essential for any RC implementation.

When Is the Order Generated?

The Order is generated after the Quote reaches an accepted state. In most implementations the e-signature event is the trigger, but it is not the only path. The table below maps the three common triggers to their mechanism:

Trigger How It Works Manual or Automated Notes
E-Signature (signed) Provider writeback sets Quote Status → Accepted; Flow calls "Activate Quote" → Order created Automated (recommended) Most common production pattern. Zero rep action required after signing
Manual rep action Rep clicks "Activate Quote" button on the Quote record after verbal or offline approval Manual Valid for internal orders, renewals not requiring signature, or pilots
Flow / API Headless: a Flow or API call sets Quote Status + invokes the activateQuote Apex action or Connect API endpoint Automated Used in self-service (B2B Commerce checkout) and integration scenarios

Key distinction: The e-signature does not directly create the Order. The signing event updates the Quote's status, and it is the Activate Quote action (triggered by that status change) that actually converts the Quote into an Order. E-signature and Order creation are two separate platform steps — decoupling them is what allows manual or API-driven Order creation without requiring a signature.

What Is Copied from Quote to Order?

The Activate Quote action performs a structured field-by-field copy. It is not a free-form process — the platform controls what moves, in what shape, and what is recalculated vs. inherited.

Quote Field / Object Order Field / Object Behavior
Quote.Pricebook2Id Order.Pricebook2Id Copied directly — must match or conversion fails
Quote.AccountId Order.AccountId Copied directly
Quote.BillingAddress Order.BillingAddress Copied from Quote; can be overridden post-conversion
Quote.ShippingAddress Order.ShippingAddress Copied from Quote
Quote.OpportunityId Order.OpportunityId Copied if present; null for standalone Quote-First paths
Quote.ContractId Order.ContractId Copied if the Quote is an amendment/renewal tied to a Contract
QuoteLineItem (each line) OrderItem (each line) One OrderItem created per QuoteLineItem — see line detail below
QuoteLineItem.Product2Id OrderItem.Product2Id Copied directly
QuoteLineItem.PricebookEntryId OrderItem.PricebookEntryId Copied directly — must exist in the Order's Price Book
QuoteLineItem.Quantity OrderItem.Quantity Copied directly
QuoteLineItem.UnitPrice OrderItem.UnitPrice Copied — reflects the negotiated/net price from Pricing Procedure output
QuoteLineItem.Discount OrderItem.Discount Copied if field is populated
QuoteLineItem.StartDate / EndDate OrderItem.ServiceDate / EndDate Copied — drives billing schedule start/end in Revenue Scheduling
QuoteLineItem.SBQQ__* (CPQ fields) Not copied CPQ managed-package fields are not part of RC Order conversion
Quote Documents (ContentDocument) Not auto-linked Files stay on the Quote; must be re-linked via Flow if needed on Order

RC-Specific Objects Created Alongside the Order

Beyond the standard Order and OrderItem, Revenue Cloud creates additional objects during activation that feed downstream billing and asset management.

ASSET / ASSET LINE ITEM

Created (or updated) from each OrderItem that represents a product configured for asset tracking. AssetLineItem carries the subscription term, quantity, and pricing that billing reads to generate invoices.

BILLING SCHEDULE (BSG)

If Revenue Scheduling is enabled, a BillingScheduleGroup and child BillingSchedule records are created per OrderItem based on the billing frequency and term defined on the Quote Line.

FULFILLMENT ORDER

If Order Management is enabled, a FulfillmentOrder is created to track physical provisioning or service delivery steps. Not always used in pure SaaS/subscription RC implementations.

Special Settings That Govern Order Generation

Several org and object settings must be correctly configured before Activate Quote can succeed. Misconfiguring these is the most common source of Order activation failures.

ORG / FEATURE SETTINGS
  • Orders Enabled — must be toggled on in Setup → Order Settings. Off by default in some orgs
  • Order Save Behavior — set to Always save (not Save only when valid) to allow draft Orders
  • Revenue Cloud Settings — "Enable Quote-to-Order" must be active in Revenue Cloud Setup
  • Asset Tracking Enabled — required if AssetLineItems should be created on activation
  • Revenue Scheduling Enabled — required for Billing Schedule auto-creation
PRODUCT / PRICE BOOK SETTINGS
  • PricebookEntry must exist on every product in the Order's Price Book — missing entries block activation
  • Product Type / Revenue Recognition — set on the Product2 record to determine if the line creates an Asset, a one-time charge, or a usage record
  • Billing Frequency — set on QuoteLineItem; copied to OrderItem; drives Billing Schedule cadence
  • Order record type — must match the Order management flow configured in Revenue Cloud Setup (e.g. New vs. Amendment)
SHARING & ACCESS SETTINGS
  • Order OWD — must allow the running user (or automated process user) to create Orders on the Account
  • Quote Status field picklist — Accepted value must exist and be active; custom statuses used as activation triggers must be mapped in RC Settings
  • Process Automation Settings — ensure "Let Flow run in system context" is enabled if the activation Flow runs as a guest or community user
CONTRACT LINKAGE SETTINGS
  • Auto-create Contract — optional setting in RC that automatically generates a Contract record from the Order on activation
  • Contract Start Date logic — driven by Order.EffectiveDate; must be set before activation or defaults to today
  • Amendment / Renewal flags — Order.Type must be set correctly (New, Amendment, Renewal) as it controls downstream Asset and Contract delta logic

Flows & Platform Logic Executed During Order Activation

"Activate Quote" is not a single action — it fires a chain of platform events and Flows in a defined sequence. Understanding the order matters when debugging activation failures.

1
Quote Validation

Platform checks Quote Status, PricebookEntry existence, required fields on all QuoteLineItems, and product eligibility rules. Any failure here throws an error before anything is written.

2
Order & OrderItem Creation

Platform creates the Order header record (Status = Draft) and all OrderItem records from the QuoteLineItems in a single transaction.

3
Record-Triggered Flows on Order / OrderItem (Before Save)

Any before-save Record-Triggered Flows on Order or OrderItem fire here. Use these for field defaulting and custom validation — they run in the same transaction and can set field values before the record is committed.

4
Order Activation (Status → Activated)

Order Status is set to Activated. At this point the Order is immutable — standard Salesforce behavior prevents editing Activated Order fields. RC extends this with Revenue-specific lock logic.

5
Asset & AssetLineItem Creation

RC platform logic reads each OrderItem and creates or updates Asset and AssetLineItem records. For amendments and renewals, existing Assets are delta-updated rather than replaced.

6
Billing Schedule Creation

If Revenue Scheduling is enabled, BillingScheduleGroup and BillingSchedule records are generated. The billing engine reads these to create invoices on the correct cadence.

7
After-Save Flows & Platform Events

After-save Record-Triggered Flows on Order fire last. This is the right place for notifications, external system callouts, Opportunity Close/Won updates, and Contract auto-creation if not handled natively.

Common Activation Failures & Root Causes

Error Root Cause Fix
Missing PricebookEntry Product exists in Quote's Price Book but not in the Order's Price Book (can differ if manually changed) Ensure Order inherits Quote's Pricebook2Id; add missing PricebookEntry
Invalid Quote Status Accepted picklist value missing or Quote not in an activatable status Add Accepted to Quote Status picklist; verify RC status mapping in Setup
Required field missing on OrderItem Custom required fields on OrderItem not populated during the Quote → Order copy Use a before-save Flow on OrderItem to default the required field from the QuoteLineItem
Sharing / access error Automated process user lacks Create on Order or access to the Account Set Flow to run in System Context; verify OWD and sharing rules for Order
Governor limits hit Large Quotes (100+ lines) trigger SOQL / DML limits in the activation transaction Use async after-save Flows for heavy post-activation logic; avoid synchronous callouts in before-save

CPQ vs. RC — Order Generation Model

Dimension CPQ Approach RC Approach
Activation action "Submit Order" or "Order" button on CPQ Quote — managed package action "Activate Quote" — standard platform action, callable from Flow or API
Field copy control Controlled by CPQ Order settings + SBQQ__OrderingPreferences__c Controlled by RC platform + before-save Flows on OrderItem for custom fields
CPQ managed fields SBQQ__* fields copied from Quote Line to Order Product No SBQQ__* fields — RC uses standard + RC-native fields only
Asset creation Optional — requires CPQ Asset settings; Asset records managed by CPQ Native — Assets and AssetLineItems auto-created by RC platform on activation
Billing schedule Not native — required CPQ Billing add-on or external system Native — BillingScheduleGroup auto-created if Revenue Scheduling enabled
Amendment / renewal CPQ amendment process clones the Quote and delta-calculates changes RC Order Type (Amendment/Renewal) drives delta Asset update natively

Key Takeaway — 3.9

  • The Order is created by the Activate Quote action, not directly by the e-signature event — signing updates the Quote status, and that status change triggers activation. Decoupling them means you can activate without a signature when the business case allows
  • The Quote → Order copy is a structured platform operation — header fields, address, Price Book, and all line items move across in a single transaction. CPQ managed-package fields (SBQQ__*) do not move; RC uses standard and RC-native fields
  • RC creates Assets, AssetLineItems, and Billing Schedules automatically on activation — these are not optional post-processing steps. They are the foundation of everything billing and contract management does downstream
  • Before-save Flows on OrderItem are the right extension point for populating custom required fields during conversion — they run in the same transaction and can read from the source QuoteLineItem via the relationship
  • The five most common activation failures are: missing PricebookEntry, invalid Quote Status picklist, missing required OrderItem field, sharing/access error on the process user, and governor limits on large Quotes — all are preventable with correct setup
  • Order Type matters — set New, Amendment, or Renewal correctly. RC uses this to determine whether to create a new Asset or delta-update an existing one, which directly impacts billing and contract accuracy
⚠ Training Material Only. This document was created solely for personal training and study purposes. It is not official Salesforce documentation. Content was generated with the assistance of generative AI and may contain inaccuracies, omissions, or outdated information. Always consult the latest official Salesforce documentation at help.salesforce.com and the Salesforce Developer Docs before making implementation decisions.
CPQ vs Revenue Cloud Deep Dive Series  ·  Personal Training Reference  ·  Generated with Generative AI