Revenue Cloud Architecture
"Revenue Cloud" is Salesforce's umbrella for quote-to-cash. The
modern stack is Revenue Lifecycle Management (RLM) — a native,
five-domain architecture that replaces the prior generation built on
the CPQ classic managed package (SBQQ__ namespace) and the
Salesforce Billing managed package (blng__ namespace). Many orgs
run a hybrid because RLM's adoption has been gradual.
This skill is an architecture reference. It maps the RLM domains to
their canonical objects, names the integration patterns Salesforce
Architects publishes for RLM <-> ERP, and disambiguates RLM from the
legacy products it replaces (a frequent LLM confusion).
The five RLM domains
RLM organizes the quote-to-cash lifecycle into five composable
domains. Each owns a set of objects and a slice of behavior.
| Domain |
Owns |
Key Objects |
| Product Catalog & Pricing |
Catalog, configurations, pricing rules |
Product2, Pricebook2, PricebookEntry, attribute / category metadata |
| Transaction Management |
Quote, configure-price-quote, order capture |
Quote, QuoteLineItem, Order, OrderItem |
| Contract Lifecycle Management |
Contracts, amendments, renewals |
Contract, ContractLineItem |
| Order-to-Cash |
Order fulfillment, asset lifecycle |
Order, OrderItem, Asset, AssetStatePeriod |
| Billing |
Invoicing, revenue, payments, accounting |
BillingSchedule, Invoice, InvoiceLine, LegalEntity, AccountingPeriod |
The objects are not unique to one domain — Order participates in
Transaction Management (capture) and Order-to-Cash (fulfillment).
The five-domain map is conceptual. It guides which team owns what
and where to put extension logic.
Multi-entity: the LegalEntity object
LegalEntity is the linchpin for multi-subsidiary setups. Invoices,
accounting periods, payment terms, and tax-treatment metadata can be
scoped per LegalEntity. One Salesforce org can run several legal
entities concurrently.
The risk: entity proliferation. Without governance, every regional
finance team wants a separate LegalEntity, and tax / accounting
configuration multiplies. Architect default: start with the smallest
LegalEntity count that satisfies legal / accounting separation,
expand only with finance approval.
RLM <-> ERP integration patterns
The reference pattern published by Salesforce Architects is
event-driven, not point-to-point. The recipe:
- Outbound from Salesforce to ERP. Use Change Data Capture
on Order / OrderItem / Invoice consumed via CometD, MuleSoft, or
a Pub/Sub API client. Or publish a Platform Event from a
trigger and have the ERP subscribe.
- Outbound via Apex callout. Trigger-time callouts are blocked
(synchronous callouts from triggers aren't allowed). Use
@future(callout=true) or Queueable with Database.AllowsCallouts
for fire-and-forget; for transactional integration, the
event-driven path is preferred.
- Inbound from ERP. REST or Bulk API loads, gated through
LegalEntity scoping and validation.
The anti-pattern: writing a synchronous Apex trigger that calls the
ERP REST API on every Order insert. It cannot work synchronously
(blocked) and even when async it tightly couples Salesforce
deployments to ERP availability.
Disambiguating RLM, CPQ classic, and Salesforce Billing
| Term |
Meaning |
| Revenue Cloud |
Marketing umbrella; refers to RLM in modern docs |
| RLM (Revenue Lifecycle Management) |
Native quote-to-cash, no managed package |
| CPQ classic |
SBQQ__ managed package; the predecessor to RLM Transaction Management |
| Salesforce Billing |
blng__ managed package; the predecessor to RLM Billing |
| Subscription Management |
Older subscription billing product, distinct from both above |
LLMs frequently conflate RLM Billing with the blng__ package. They
are different products with different objects, different APIs, and
different upgrade paths. Confirm namespace before designing.
Recommended Workflow
- Confirm which products are licensed and active. RLM, CPQ classic, Salesforce Billing, and Subscription Management can coexist. Discover the actual managed-package state via Setup -> Installed Packages.
- Map the business process to the five RLM domains. Identify which domain owns which step. This determines which objects to extend and which team is responsible.
- Plan multi-entity scoping early. Decide LegalEntity count and granularity before any data model extension. Adding entities mid-flight is disruptive.
- Choose ERP integration shape per direction. Outbound preferred via CDC / Platform Events. Inbound via REST / Bulk API gated through LegalEntity validation. Document the contract per direction.
- Avoid synchronous trigger callouts. They are blocked by the platform; the alternative is
@future(callout=true) or Queueable, but the architect-recommended pattern is event-driven.
- Stand up sandbox tests for each integration path. Failure modes (ERP down, slow, malformed response) need explicit handling. Replay-from-CDC checkpointing is the durable pattern.
- Document the namespace decision. Make explicit in the architecture record whether the integration targets native RLM objects,
SBQQ__ CPQ classic, blng__ Salesforce Billing, or a hybrid. This prevents downstream confusion for the next team.
What This Skill Does Not Cover
| Topic |
See instead |
| Declarative CPQ classic configuration |
omnistudio/cpq-classic-config |
| CPQ-classic specific quoting patterns |
architect/cpq-architecture-patterns |
| Subscription Management (legacy) billing patterns |
architect/cpq-architecture-patterns |
| ERP-side connector implementation |
integration/named-credential-patterns |
1---2name: revenue-cloud-architecture3description: "Architecting on Salesforce Revenue Cloud (Revenue Lifecycle Management — RLM, the successor to CPQ-Plus + Billing). Covers the five RLM domains (Product Catalog & Pricing, Transaction Management, Contract Lifecycle Management, Order-to-Cash, Billing), the canonical data model (Product2 / PricebookEntry / Quote / Order / OrderItem / Contract / Asset / BillingSchedule / Invoice / LegalEntity), multi-entity scoping via LegalEntity, the RLM ↔ ERP integration patterns (CDC + MuleSoft preferred over point-to-point trigger callouts), and the disambiguation between native RLM and the legacy `blng__` Salesforce Billing managed package and `SBQQ__` CPQ classic. NOT for implementing DRO fulfilment plans or Connect API billing schedules - use integration/revenue-lifecycle-management. NOT for CPQ classic bundle, pricing and quoting architecture - use architect/cpq-architecture-patterns."4category: architect5salesforce-version: "Spring '25+"6well-architected-pillars:7 - Reliability8 - Operational Excellence9 - Security10triggers:11 - "revenue cloud rlm revenue lifecycle management architecture"12 - "product catalog price book quote order contract asset rlm"13 - "rlm billing schedule invoice legal entity"14 - "rlm vs cpq classic vs salesforce billing managed package"15 - "rlm to erp integration cdc platform events"16 - "multi entity legal entity invoice scoping"17 - "transaction management order data model"18tags:19 - revenue-cloud20 - rlm21 - billing22 - quote-to-cash23 - legal-entity24inputs:25 - "Whether the org is on RLM, CPQ classic (`SBQQ__`), Salesforce Billing (`blng__`), or a hybrid"26 - "ERP system on the receiving end of order / invoice data and its preferred integration shape"27 - "Multi-entity scope: how many LegalEntity rows, accounting periods, tax jurisdictions"28outputs:29 - "RLM domain map with canonical objects per domain"30 - "RLM <-> ERP integration pattern (CDC, Platform Event, queueable callout)"31 - "Multi-entity setup checklist with LegalEntity scoping"32dependencies: []33version: 1.0.034author: Pranav Nagrecha35updated: 2026-05-0536metadata:37 source: https://skillmd.com/skills/pranavnagrecha/revenue-cloud-architecture38---3940# Revenue Cloud Architecture4142"Revenue Cloud" is Salesforce's umbrella for quote-to-cash. The43modern stack is **Revenue Lifecycle Management (RLM)** — a native,44five-domain architecture that replaces the prior generation built on45the CPQ classic managed package (`SBQQ__` namespace) and the46Salesforce Billing managed package (`blng__` namespace). Many orgs47run a hybrid because RLM's adoption has been gradual.4849This skill is an architecture reference. It maps the RLM domains to50their canonical objects, names the integration patterns Salesforce51Architects publishes for RLM <-> ERP, and disambiguates RLM from the52legacy products it replaces (a frequent LLM confusion).5354## The five RLM domains5556RLM organizes the quote-to-cash lifecycle into five composable57domains. Each owns a set of objects and a slice of behavior.5859| Domain | Owns | Key Objects |60|---|---|---|61| Product Catalog & Pricing | Catalog, configurations, pricing rules | `Product2`, `Pricebook2`, `PricebookEntry`, attribute / category metadata |62| Transaction Management | Quote, configure-price-quote, order capture | `Quote`, `QuoteLineItem`, `Order`, `OrderItem` |63| Contract Lifecycle Management | Contracts, amendments, renewals | `Contract`, `ContractLineItem` |64| Order-to-Cash | Order fulfillment, asset lifecycle | `Order`, `OrderItem`, `Asset`, `AssetStatePeriod` |65| Billing | Invoicing, revenue, payments, accounting | `BillingSchedule`, `Invoice`, `InvoiceLine`, `LegalEntity`, `AccountingPeriod` |6667The objects are not unique to one domain — `Order` participates in68Transaction Management (capture) and Order-to-Cash (fulfillment).69The five-domain map is conceptual. It guides which team owns what70and where to put extension logic.7172## Multi-entity: the LegalEntity object7374`LegalEntity` is the linchpin for multi-subsidiary setups. Invoices,75accounting periods, payment terms, and tax-treatment metadata can be76scoped per `LegalEntity`. One Salesforce org can run several legal77entities concurrently.7879The risk: entity proliferation. Without governance, every regional80finance team wants a separate `LegalEntity`, and tax / accounting81configuration multiplies. Architect default: start with the smallest82`LegalEntity` count that satisfies legal / accounting separation,83expand only with finance approval.8485## RLM <-> ERP integration patterns8687The reference pattern published by Salesforce Architects is88event-driven, not point-to-point. The recipe:8990- **Outbound from Salesforce to ERP.** Use **Change Data Capture**91 on Order / OrderItem / Invoice consumed via CometD, MuleSoft, or92 a Pub/Sub API client. Or publish a **Platform Event** from a93 trigger and have the ERP subscribe.94- **Outbound via Apex callout.** Trigger-time callouts are blocked95 (synchronous callouts from triggers aren't allowed). Use96 `@future(callout=true)` or Queueable with `Database.AllowsCallouts`97 for fire-and-forget; for transactional integration, the98 event-driven path is preferred.99- **Inbound from ERP.** REST or Bulk API loads, gated through100 `LegalEntity` scoping and validation.101102The anti-pattern: writing a synchronous Apex trigger that calls the103ERP REST API on every Order insert. It cannot work synchronously104(blocked) and even when async it tightly couples Salesforce105deployments to ERP availability.106107## Disambiguating RLM, CPQ classic, and Salesforce Billing108109| Term | Meaning |110|---|---|111| **Revenue Cloud** | Marketing umbrella; refers to RLM in modern docs |112| **RLM** (Revenue Lifecycle Management) | Native quote-to-cash, no managed package |113| **CPQ classic** | `SBQQ__` managed package; the predecessor to RLM Transaction Management |114| **Salesforce Billing** | `blng__` managed package; the predecessor to RLM Billing |115| **Subscription Management** | Older subscription billing product, distinct from both above |116117LLMs frequently conflate RLM Billing with the `blng__` package. They118are different products with different objects, different APIs, and119different upgrade paths. Confirm namespace before designing.120121## Recommended Workflow1221231. **Confirm which products are licensed and active.** RLM, CPQ classic, Salesforce Billing, and Subscription Management can coexist. Discover the actual managed-package state via Setup -> Installed Packages.1242. **Map the business process to the five RLM domains.** Identify which domain owns which step. This determines which objects to extend and which team is responsible.1253. **Plan multi-entity scoping early.** Decide LegalEntity count and granularity before any data model extension. Adding entities mid-flight is disruptive.1264. **Choose ERP integration shape per direction.** Outbound preferred via CDC / Platform Events. Inbound via REST / Bulk API gated through LegalEntity validation. Document the contract per direction.1275. **Avoid synchronous trigger callouts.** They are blocked by the platform; the alternative is `@future(callout=true)` or Queueable, but the architect-recommended pattern is event-driven.1286. **Stand up sandbox tests for each integration path.** Failure modes (ERP down, slow, malformed response) need explicit handling. Replay-from-CDC checkpointing is the durable pattern.1297. **Document the namespace decision.** Make explicit in the architecture record whether the integration targets native RLM objects, `SBQQ__` CPQ classic, `blng__` Salesforce Billing, or a hybrid. This prevents downstream confusion for the next team.130131## What This Skill Does Not Cover132133| Topic | See instead |134|---|---|135| Declarative CPQ classic configuration | `omnistudio/cpq-classic-config` |136| CPQ-classic specific quoting patterns | `architect/cpq-architecture-patterns` |137| Subscription Management (legacy) billing patterns | `architect/cpq-architecture-patterns` |138| ERP-side connector implementation | `integration/named-credential-patterns` |