
Revenue Cloud integrations: remap or rethink?
Every connection from Salesforce to your ERP, billing system and provisioning platform has to move when you move to Salesforce Revenue Cloud. Here is how to decide which to carry across as they are, which to redesign and how to cut them over without stranding a single order.
- Integration
- Data Transformation
- Data Migration
A software company’s order rarely stops at Salesforce. Within minutes of activation, the ERP needs the order to set up revenue, the billing system needs it to start an invoice schedule and a provisioning platform needs it to switch on the customer’s license. When the order is amended three months later, all three need to hear about it again, in the right sequence and in the terms each one understands.
On most Salesforce CPQ orgs, each of those hand-offs is its own connection, written when the system it serves was added and maintained ever since. Moving to Salesforce Revenue Cloud breaks every one of them, because the objects they read no longer exist. This article explains what changes, where the integration logic can live on Revenue Cloud, when an integration is worth redesigning rather than remapping and how to carry each one across. It is written for the RevOps and Business Systems teams who own quote to cash in Salesforce, and it draws on what our consultants see when integrations are rebuilt during Revenue Cloud implementations.
Executive summary
What this article offers, what it means for the business and what to decide
Every integration has to move
Salesforce CPQ keeps quotes, quote lines and subscriptions in its own custom objects. Revenue Cloud uses standard Salesforce objects, so any integration that reads or writes the old objects stops working at cutover.
Moving them is also a chance to simplify them
Remapping each connection field by field preserves today’s design, including its fragility. Revenue Cloud’s Dynamic Revenue Orchestrator can instead hold the sequence of downstream work (ERP, billing and provisioning) in one plan that operations teams can see.
Identifiers carry the most risk
The ERP, billing and provisioning systems store Salesforce order, contract and line references. If those references aren’t carried across deliberately, the first amendment after go-live arrives in each system as an order it has never seen.
The billing system question comes first
Revenue Cloud has its own billing. Whether it replaces an external billing system decides how many integrations you rebuild at all.
Decisions to make
Which integrations to remap and which to redesign; whether downstream sequencing lives in Revenue Cloud or in middleware; whether to keep the external billing system; how legacy identifiers are carried across; and what must pass before go-live.
Jump to what you need
- Executive summary
- What changes for integrations on Revenue Cloud
- Where the integration logic can live
- When an integration is worth redesigning
- How to carry integrations across to Revenue Cloud
- What this looks like for a software company
- What it changes for GTM, Finance and Business Systems
- What trips teams up when integrations move
- Practices that keep integrations steady through cutover
- Where this approach doesn’t fit
- Questions teams ask about Revenue Cloud integration
- Where to go next
What changes for integrations on Revenue Cloud
The change is structural rather than cosmetic. Salesforce CPQ is a managed package, so its records live in custom objects with the SBQQ prefix. Revenue Cloud is built on standard Salesforce objects. Every integration that names a CPQ object, whether it is a middleware mapping, an Apex callout, a scheduled export or a report the ERP team pulls each month, names something that won’t be there after cutover.
The objects Revenue Cloud integrations read instead
| What the record holds | In Salesforce CPQ | In Revenue Cloud | What the integration has to do |
|---|---|---|---|
| The quote | SBQQ__Quote__c | Quote | Re-point to the standard object and reconcile header fields |
| Quote lines | SBQQ__QuoteLine__c | QuoteLineItem | Rebuild the field mapping; custom fields are recreated, not carried |
| What the customer owns | SBQQ__Subscription__c | Asset, with its lifecycle history | Read subscriptions as assets, including the chain of changes behind each |
| Negotiated prices | Contracted prices | ContractItemPrice | Remap to the account each price belongs to |
| Orders | Order and OrderItem, extended with CPQ fields | Order and OrderItem, as standard objects | Keep the object, replace every CPQ-specific field reference |
The same shift reaches beyond integrations. Reports and dashboards built on CPQ objects, and any Flow, Apex or legacy automation that reads them, have to be rebuilt as well. Treat them as part of the same dependency map, because an integration often relies on a field that a Flow populates.
What this means for you: the field mapping is the easy part. The harder work is finding every place outside Salesforce that depends on a CPQ object, including the ones nobody has looked at since they were built.
Where the integration logic can live
On a typical Salesforce CPQ org, every downstream system has its own connection to the order. One integration tells the ERP, another starts billing and a third provisions the license. Each decides for itself when to act, each handles amendments in its own way and each is monitored separately, if it is monitored at all. When one fails, the order looks complete in Salesforce while one system quietly falls behind.
Revenue Cloud offers a different place for that logic. Dynamic Revenue Orchestrator (DRO) breaks the order a customer bought into the technical tasks needed to fulfill it, then runs those tasks as one orchestration plan. Each step in the plan has a type: an automated task run by a Flow, a callout to an external system, a manual task assigned to a person, a milestone or a pause. Every step carries a status, and steps at risk of missing their target are flagged, so operations teams can see the whole downstream picture on one canvas.
DRO doesn’t remove the connection to each system. A callout step still calls the ERP, the billing platform or the provisioning service, directly or through middleware. What moves is the decision about what happens next, in what order and what to do when an order changes. That logic stops living in three integrations and starts living in one plan.
What this means for you: if your middleware holds business rules about what happens after an order is placed, the migration is the cheapest moment you will get to move those rules somewhere your team can see and change them.
When an integration is worth redesigning
Not every connection needs rethinking. A nightly export of closed opportunities to a data warehouse only needs its object and field names changed. Remap integrations like that and move on. Redesign is worth the effort when one or more of these is true:
- It acts on orders and amendments. Any integration that has to react when an order is changed, cancelled or renewed carries its own amendment logic today. That logic is where most post-go-live incidents start.
- Several systems depend on the same order. When the ERP, billing and provisioning all key on one order, the sequence between them matters. Holding that sequence in one plan is easier to reason about than holding it in three places.
- It translates what was sold into what must be done. If middleware turns one commercial product into several provisioning actions, that translation is exactly what DRO’s decomposition rules are designed to hold.
- It feeds an external billing system Revenue Cloud could replace. Rebuilding a billing integration you are about to retire is work you do twice.
- Nobody can say what it does. An integration whose logic lives only in code written by someone who has left is a risk at cutover whichever way you go. Redesigning it documents it.
The reverse also holds. If an integration is stable, read-only and indifferent to amendments, a redesign adds risk without adding value.
How to carry integrations across to Revenue Cloud
The work runs in the order below. Treat it as its own workstream, with an owner, rather than as a task inside data migration, and build and test each step in a sandbox before production.
Inventory every connection and what it depends on
List every system that reads from or writes to Salesforce quote, order, contract, subscription, asset or invoice records. For each, record the objects and fields it uses, the integration user it runs as, what triggers it, what it does when a record changes and who owns it today. Include the quiet ones: scheduled exports, spreadsheets refreshed by a connector and reports another team pulls by API. This inventory becomes the dependency map every later step works from.
Decide remap or redesign, integration by integration
Use the tests in the previous section to mark each integration. Remap the stable, read-only ones. Redesign the ones that act on amendments, coordinate several systems or feed a billing platform you may retire. Write the decision down against each line of the inventory, with the reason, so the scope is agreed before anyone builds.
Remap fields from CPQ objects to standard objects
For every integration you keep, map each CPQ field to its Revenue Cloud equivalent and decide how values change on the way. This is data transformation in the plain sense: a quote line field may become a field on the standard quote line, a subscription becomes an asset and contracted prices attach to accounts. Custom fields don’t come across automatically; they are recreated on the standard objects and mapped again. Record each mapping with the integration owner’s sign-off, because the same mapping drives the data migration and the integration rebuild.
Carry identifiers across deliberately
This is the step most often underestimated. Your ERP, billing system and provisioning platform store Salesforce identifiers: order numbers, contract numbers and line references. After migration, the same commercial records exist in Revenue Cloud under new Salesforce IDs. Decide, for each downstream system, how it will recognize a migrated record as one it already knows:
- store each system’s own key on the Revenue Cloud record as an external ID, so integrations match on a value that doesn’t change
- keep the legacy Salesforce ID on the migrated record, so any reference to it can be traced
- update the downstream system’s stored references once, at cutover, from a cross-reference table both sides have validated
Whichever you choose, test it with an amendment, not just a new order. A new order proves the integration works; an amendment to a migrated contract proves the identifiers held.
Decide where downstream sequencing lives
For integrations you redesign, decide whether DRO holds the sequence or your middleware continues to. If you adopt DRO, design the orchestration plan with the operations team that will watch it: which tasks run in parallel, which wait for another to finish, which are callouts and what the target time is for each. Orders reach DRO when a record-triggered Flow submits them, usually on activation, so that trigger becomes part of the integration design. If middleware keeps the sequence, document its rules as carefully as you would the plan, because they are now the only record of what happens after an order is placed.
Settle the billing system and the route to the ERP
If you bill from an external platform today, assess whether Revenue Cloud billing can replace it before you rebuild anything. Consolidating removes an integration entirely. If you keep the external platform, billing can be started by a DRO task so its timing sits in the same plan as provisioning and the ERP. If Revenue Cloud does the billing, its Invoice Management records become what the ERP receives, which replaces a custom order-to-ERP feed with a feed of posted invoices. Either way, revalidate invoice and payment reconciliation as part of go-live acceptance.
Test the integrations, then cut over
Before go-live, agree the checks that must pass and the conditions under which you would roll back. On the integrations we rebuild, that means:
- smoke tests on every integration, run against a set of curated test orders that covers a new sale, an amendment, a renewal and a cancellation
- record counts and totals compared between Salesforce and each downstream system
- a decision on in-flight orders: finished before cutover, paused under an order freeze or migrated and replayed
- rollback criteria that name who can call a rollback and what happens to orders placed in the meantime
- a period of heightened support after go-live, with the integration owners on call
Keep the curated test orders in production on a dedicated test account. Every later release can then re-run the same scenarios and prove the integrations still behave.
What this means for you: most post-go-live integration incidents come from an amendment to a migrated record. Testing new orders is necessary. Testing changes to old ones is what proves the cutover.
What this looks like for a software company
Consider a B2B security software company moving from Salesforce CPQ to Revenue Cloud. It sells an annual platform subscription with an implementation package. Today, an activated order triggers three integrations: one creates a sales order in the ERP, one sets up an invoice schedule in an external billing platform and one calls the provisioning service to create the customer’s tenant and seat licenses.
- The defect. The billing integration matches amendments to the original subscription by its CPQ quote line ID. About 240 amendments a month flow through it. In the last quarter before migration, roughly one in ten failed to match and was keyed by hand, so Finance carried about 24 manual corrections into each close.
- The decision. The ERP export of closed orders is stable and read-only, so it is remapped to the standard Order and OrderItem objects. The billing integration is retired, because Revenue Cloud billing replaces the external platform, and the ERP now receives posted invoices instead. Provisioning is redesigned as a DRO callout step, because one platform product decomposes into a tenant, a seat block and an onboarding task.
- The identifiers. Each migrated contract keeps the ERP’s customer and sales order numbers as external IDs, and the provisioning service’s tenant ID is stored on the asset. A cross-reference table of legacy and new Salesforce IDs is validated by both teams before cutover.
- The test. The curated order set includes a mid-term seat increase on a migrated contract. In the final sandbox cycle it reaches billing, the ERP and provisioning with the right references; the first attempt failed on a missing tenant ID, which is exactly what the test was for.
- The result to measure. After go-live, amendments match their originals by external ID rather than by a quote line that no longer exists. The team measures unmatched amendments and manual corrections per close against the baseline from the last CPQ quarter.
The company, volumes and failure rate are illustrative. Measure your own baseline before claiming an improvement.
What it changes for GTM, Finance and Business Systems
GTM. Reps quote and activate orders as before. Customers are provisioned and invoiced from the same order without anyone chasing a downstream system, and amendments reach billing and provisioning on the same path as new sales.
Finance. Orders, amendments and invoices arrive in the ERP with references that match, so unmatched transactions are found by a count rather than at close. Retiring an external billing platform removes one reconciliation entirely; where one stays, invoice and payment reconciliation is part of go-live acceptance, with sign-off. The return shows up in fewer manual corrections and fewer days spent reconciling, both measured against your own baseline before and after cutover.
Business Systems. The work leaves behind a dependency map of every integration, the objects and fields it uses and the integration user it runs as, with each user’s permission sets reviewed for the new objects. Downstream sequencing is documented in one orchestration plan or in middleware rules, never split between the two. Every integration is regression-tested against the curated order set in a sandbox, and the same set runs before each release after handoff.
What trips teams up when integrations move
- Integrations nobody listed. A spreadsheet connector or a scheduled report that reads CPQ objects stops at cutover, and someone notices weeks later.
- Remapping amendment logic as it is. Carrying old amendment handling into new field names preserves the behavior that caused today’s incidents.
- Identifiers left to chance. Downstream systems that still hold legacy Salesforce IDs treat the first amendment to a migrated contract as an unknown order.
- Sequencing in two places. Half the rules in DRO and half in middleware means nobody can say what happens next.
- Rebuilding a billing integration you will retire. Decide the billing question before the build plan, not after it.
- Integration users with the old permissions. A user granted access to CPQ objects can’t read the standard objects that replace them until its permission sets are updated.
- Assuming every change path behaves as designed. Check Salesforce’s known issues for Dynamic Revenue Orchestrator on your release before you design around it. At the time of writing, W-23286018 (an order can show as complete before all its fulfillment assets exist) and W-24551685 (an attribute downgrade on renewal can cancel the current term) are still open.
- Testing only new orders. New orders pass. Amendments, renewals and cancellations on migrated records are where cutover problems appear.
Practices that keep integrations steady through cutover
- Give integrations their own workstream and owner. Integration work hidden inside data migration is scoped last and tested least.
- Keep one mapping document. The data migration and the integration rebuild use the same object and field mapping, signed off once.
- Match on keys that don’t change. Store each downstream system’s key on the Revenue Cloud record as an external ID.
- Hold sequencing in one place. Choose DRO or middleware for each flow and document the choice.
- Test with a curated order set. Cover a new sale, an amendment, a renewal and a cancellation on migrated records, and keep the set for every later release.
- Agree rollback before go-live. Name who can call it and what happens to orders placed in the meantime.
Where this approach doesn’t fit
- It doesn’t replace middleware as transport. DRO decides what happens and when. Each callout still needs a named credential, an integration definition and, where the payload must be reshaped, an integration procedure or middleware. Retries, authentication and the external system’s own API remain integration work.
- It doesn’t fix the downstream system. If the ERP’s customer master or item master is duplicated or inconsistent, clean integrations will feed it clean data that still won’t reconcile.
- When we would advise remapping only. If fulfillment is a single, instant step, such as a license key issued on activation with no dependencies, an orchestration plan adds structure the business doesn’t need.
- When we would advise waiting. If the ERP or the billing platform is being replaced in the same period, settle that decision first. Integrations designed for a system about to change get built twice.
Questions teams ask about Revenue Cloud integration
Do we have to rebuild every integration when we move off Salesforce CPQ?
Every integration that uses a CPQ object has to change, because Revenue Cloud uses standard objects. Many only need remapping. Redesign the ones that act on amendments, coordinate several systems or feed a billing platform you may retire.
Can Dynamic Revenue Orchestrator replace our middleware?
It can replace the business logic many companies keep in middleware: what happens after an order is placed, in what order and what to do when it changes. It doesn’t replace the transport. Callout steps still connect to each system, directly or through an integration platform.
How do we keep our ERP’s order and contract references intact through the migration?
Store the ERP’s own keys on the migrated Revenue Cloud records as external IDs, keep the legacy Salesforce IDs for traceability and validate a cross-reference table with the ERP team before cutover. Then test with an amendment to a migrated contract.
Should we keep our external billing system?
Assess it before you rebuild anything. If Revenue Cloud billing meets your needs, retiring the external system removes an integration and a reconciliation. If you keep it, start billing from an orchestration task so its timing is visible alongside provisioning and the ERP.
How do we test integrations before go-live?
Run smoke tests on every integration against a curated set of orders covering a new sale, an amendment, a renewal and a cancellation, compare counts and totals in each downstream system and agree rollback criteria in advance.
Integrations simpler than the ones they replace
Tell us which systems your orders reach today. Our experts can start with a read-only inventory of every integration that touches quote, order, contract and subscription records, mapped in a sandbox copy, and show which to remap and which to redesign before anything changes. We shape the Salesforce Revenue Cloud experience to fit your revenue model, from strategy and implementation to support.