Revenue Cloud = CPQ + Billing + Revenue Lifecycle Management | End-to-end: Quote → Order → Contract → Invoice → Revenue Recognition | Part of Salesforce Customer 360 — natively integrated with Sales Cloud, Service Cloud | Key differentiator: eliminates revenue leakage by connecting every step | Products: Salesforce CPQ (managed package), Salesforce Billing (managed package), Revenue Cloud Advanced (RLM — newer native platform)

CPQ scope: Product configuration, pricing, discount management, quote generation, approval workflows | Revenue Cloud adds: Order management, Contract management, Invoicing, Payment processing, Revenue recognition (ASC 606/IFRS 15) | CPQ is a managed package (sbqq__ namespace); Billing is a managed package (blng__ namespace) | Revenue Lifecycle Management (RLM): newer native Salesforce product replacing CPQ/Billing | Timeline: CPQ = quote; Revenue Cloud = quote + everything after

Key objects: SBQQ__Quote__c (Quote), SBQQ__QuoteLine__c (Quote Line), SBQQ__Subscription__c (Subscription), blng__Invoice__c (Invoice), blng__InvoiceLine__c (Invoice Line), blng__RevenueSchedule__c (Revenue Schedule) | Namespace: sbqq__ for CPQ objects, blng__ for Billing objects | Flow: Opportunity → Quote → Order → Contract → Invoice → Revenue | Quote Line Groups: organize quote lines into sections

Product2 fields added by CPQ: SBQQ__SubscriptionType__c (One-time/Renewable/Evergreen), SBQQ__BillingType__c (Advance/Arrears), SBQQ__BillingFrequency__c (Monthly/Quarterly/Annual), SBQQ__SubscriptionPricing__c (Fixed/Percent of Total), SBQQ__PricingMethod__c (List/Cost/Block/Percent of Total) | Product Family: groups products | Active flag: must be true for product to appear in CPQ | Price Book Entry: required for CPQ to pick up the price

Bundle structure: Bundle Product (parent) → Product Options (children) | SBQQ__ProductOption__c: links child product to bundle | Option Type: Component (included in bundle), Add-on (separately priced optional) | Required: option always included; Optional: rep can add/remove | Feature (SBQQ__Feature__c): groups options into categories within bundle | Min/Max: control how many options can be selected | Bundle pricing: parent price can roll up from option prices or be independent

Standard Price Book: default list prices | Custom Price Books: segment-specific pricing (Enterprise, SMB, Partner, Government) | Price Book Entry (PricebookEntry): links Product2 to Price Book with price | CPQ: Price Book selected on Quote drives which prices are used | Multi-currency: each Price Book Entry can have prices in different currencies | Override: CPQ Pricing Rules can override Price Book prices | Best practice: Standard Price Book = full list price, discount via rules not multiple price books

SBQQ__Quote__c key fields: SBQQ__Opportunity2__c (Opportunity), SBQQ__Account__c (Account), SBQQ__Status__c (Draft/Needs Review/Approved/Rejected/Presented/Accepted), SBQQ__Primary__c (is this the primary quote), SBQQ__StartDate__c, SBQQ__EndDate__c, SBQQ__NetAmount__c, SBQQ__SubscriptionTerm__c | Multiple quotes per Opportunity: only one Primary quote | Primary = true: syncs Quote Lines to Opportunity Products | Quote PDF: generated via SBQQ__QuoteDocument__c

SBQQ__QuoteLineGroup__c: container for quote lines | Fields: SBQQ__Quote__c (parent), Name (section label shown on PDF), SBQQ__StartDate__c, SBQQ__EndDate__c, SBQQ__NetTotal__c | Use cases: multi-year deals (Year 1 group, Year 2 group), separate sections (Hardware, Software, Services), different billing cycles per section | Group pricing: subtotal per group shown on PDF | Default: all lines in one default group if no groups configured

QLE features: product search and add, bundle configurator, column editing (quantity, discount, price), price waterfall visibility, group management, approval indicators, document generation | Customization: custom QLE columns via SBQQ__LineColumn__c records | Actions: Save Quote, Generate Document, Start Approval | Guided Selling: product selection prompts configured in QLE | Mobile: QLE has limited mobile support — use Lightning App Builder for mobile-first

Price Waterfall steps: List Price → Special Price (Price Rules) → Contracted Price → Customer Price (Partner Discount) → Net Price (Additional Discount) → Partner Price | Each step: additive or replacement | Configurable: Admin can rename/add/remove steps | Visibility: show/hide waterfall steps from rep | Key: Discount affects Net Price; Partner Discount affects Customer Price | SBQQ__PricingProcedure__c: custom pricing step records

SBQQ__PricingRule__c: Name, Active, Conditions (when rule fires), Actions (what price change occurs) | Evaluation Event: Before Calculate, Calculate, After Calculate | Action Type: Percentage Discount, Amount Discount, Price Override, % Markup, Calculate Field | Price Action Target: Price Field to change (Customer Price, Net Price, etc.) | Conditions: field comparisons (Product Family=Software, Quantity>=10) | Order: rules evaluated in sequence order

SBQQ__DiscountSchedule__c: Name, Type (Volume/Term), Unit (Amount/Percentage), Discount Tiers (SBQQ__DiscountTier__c) | Volume Discount Schedule: 1-10 units=0%, 11-50=10%, 51-100=15%, 100+=20% | Term Discount Schedule: 12 months=0%, 24 months=5%, 36 months=10% | Assignment: Discount Schedule assigned to Product2 | Automatic: CPQ applies correct tier discount based on Quote Line Quantity | Override: rep can manually override the scheduled discount

Product Rule types: Validation (block save if condition violated), Alert (warning message, rep can override), Selection (auto-add/remove products based on conditions), Filter (hide products that don't match) | Components: Product Conditions (when rule fires based on product config), Product Actions (what rule does to products) | Error Condition (SBQQ__ErrorCondition__c): specific conditions that trigger the rule | Scope: works during product selection in QLE

Price Condition: Object (Quote/Quote Line), Field (any field), Operator (=, >, <, contains), Value | Multiple conditions: AND/OR logic between conditions | Price Action: Object (Quote Line), Field (SBQQ__CustomerPrice__c, SBQQ__Discount__c), Type (Percent, Amount, Formula) | Formula actions: SBQQ__ValueFormula__c — complex calculations | Paired: one Pricing Rule has multiple conditions (all/any must be true) + multiple actions

Guided Selling: SBQQ__QuickFilter__c records | Process: rep opens product catalog → prompted with questions → answers filter product list → rep selects from filtered results | Fields: Prompt (question text), Filter Field (Product2 field to filter on), Filter Value (what to filter to) | Multiple prompts: sequential questions narrow results | Optional: rep can skip guided selling and browse full catalog | Commonly used for: industry, use case, deployment type questions

Twin Fields: SBQQ__FieldMetadata__c records mapping Quote fields to Order fields | Why needed: CPQ creates Orders from Quotes but custom fields on Quote Lines don't automatically copy to OrderItems | Configuration: Admin creates Field Metadata record specifying source (Quote Line field) and target (Order Item field) | Standard fields: mapped automatically | Custom fields: require explicit Twin Field configuration | Also for Contract: Quote Line → Subscription mapping

SBQQ__Subscription__c created: when Order Product with SubscriptionType=Renewable/Evergreen is activated | Fields: Product2, Contract, Quantity, StartDate, EndDate, SubscriptionTerm, UnitPrice | Renewal: SBQQ__RenewalForecast__c = true on Contract → renewal Quote auto-created X days before expiry | Renewal Quote: pre-populated with existing subscriptions, reps can add/remove/modify | Co-terming: adding new subscription mid-term prorates to match existing contract end date

Amendment process: Contract → Amend Contract button → Amendment Quote created (SBQQ__Quote__c with SBQQ__Type__c=Amendment) | Amendment Quote: shows existing subscriptions + ability to add/remove/change | Proration: CPQ automatically calculates partial-term pricing based on remaining months | Asset: existing products shown as Assets with ability to increase/decrease/remove | New Order: Amendment Quote → Order → new/changed Order Products | Best practice: always amend via CPQ (not manual) to maintain subscription records

Key Billing objects: blng__Invoice__c (Invoice), blng__InvoiceLine__c (Invoice Line), blng__Payment__c (Payment), blng__PaymentAllocation__c (Payment applied to Invoice), blng__RevenueDistribution__c (Revenue Schedule), blng__CreditNote__c (Credit) | Billing triggers: Billing Rule on Order Product determines when invoice generates | Invoice schedule: Advance (bill at start) or Arrears (bill at end of period) | Integration: Billing exports to GL (NetSuite, SAP, QuickBooks) | ASC 606: Revenue Distribution records manage recognition timing

Revenue Distribution (blng__RevenueDistribution__c): one record per recognition period | Recognition method: Straight-line (equal monthly), Event-based (on milestones), Percent complete | Deferred Revenue: revenue billed but not yet recognized — tracked in Billing | Revenue Schedule: total contract value distributed across periods | Integration: Revenue Distribution records exported to GL for journal entries | Performance Obligation: groups products into recognition units per ASC 606

List Pricing: price from Price Book Entry | Cost Pricing: Product cost × (1 + markup%) | Block Pricing (SBQQ__Block__c): quantity tiers with flat price per tier | Percent of Total: X% of Quote's net/customer/list total — for maintenance/support pricing | Contracted: price from customer-specific Contracted Price record | Override: rep can override any pricing method with manual price | Block pricing example: 1-10 users=$500 flat, 11-50=$1500 flat, 51-100=$2500 flat

SBQQ__ContractedPrice__c fields: Account, Product, Price, Discount, CurrencyIsoCode, StartDate, EndDate | Auto-apply: when Quote is created for Account with Contracted Price, CPQ automatically uses the contracted price | Priority: Contracted Price > Price Rule > Price Book | Effective dates: prices active only within StartDate/EndDate | Multiple products: one Contracted Price record per product per account | Created from: Account record, Contract amendment, or manual Admin entry

Multi-currency setup: Salesforce Advanced Currency Management enabled | Quote currency: inherited from Opportunity currency | Price Book Entries: create entries in each currency for accurate local pricing | Dated Exchange Rates: CPQ uses rates as of Quote creation date for conversions | Reporting: all amounts reportable in corporate currency | Cross-currency quotes: items in different currencies auto-converted | Best practice: create Price Book Entries in local currencies rather than relying on auto-conversion for accuracy

SBQQ__QuoteTemplate__c: template definition with sections | SBQQ__TemplateSection__c: sections within template (header, line items, T&Cs, custom) | SBQQ__TemplateContent__c: content within sections (rich text, field references, images) | Line Item Columns: configure which product fields show in the PDF table | Dynamic content: conditional sections show only when conditions met | Merge fields: {!SBQQ__Quote__c.SBQQ__Account__c} syntax | Document generation: Quote → Generate Document → SBQQ__QuoteDocument__c created | E-signature: DocuSign integration sends for e-signature

CPQ Approval setup: standard Salesforce Approval Process on SBQQ__Quote__c OR SBQQ__ApprovalStep__c (native CPQ approvals) | Native CPQ Approvals: SBQQ__ApprovalStep__c records define conditions and approvers | Approval conditions: Discount >20% → Manager, Discount >35% → VP Sales, Deal >$500K → Finance | Parallel vs Sequential: multiple approvers simultaneously or in chain | Approval status: Draft → Pending → Approved/Rejected | Auto-approve: low-risk quotes auto-approved without human intervention | Chatter notifications: approvers notified via Chatter

Quote: Salesforce record (SBQQ__Quote__c) — internal data, not shown to customer | Proposal/Quote Document: PDF generated from Quote Template (SBQQ__QuoteDocument__c) — customer-facing | Multiple documents: same Quote can generate formal proposal + order form + T&C document | SBQQ__QuoteDocument__c: stores generated PDF as ContentDocument | Primary Quote: syncs to Opportunity Products | Quote status: Accepted = customer confirmed; Quote document sent separately | DocuSign: generates document then sends for e-signature

SBQQ__LineColumn__c: defines a column in QLE | Fields: Field Name (API name of Quote Line field), Field Label (display name), Read Only (view only vs editable), Hidden (not shown), Position (column order) | Standard columns: Product Name, Quantity, List Price, Customer Price, Discount, Net Price, Start/End Date | Custom columns: any SBQQ__QuoteLine__c field can be added | Group columns: some columns appear only at group level | Best practice: hide internal cost fields from standard rep role, show to managers

Standard Price Book: Salesforce native, contains Pricebook2 + PricebookEntry (product + price) | CPQ uses Price Book: as starting point for List Price calculation | CPQ additions: Discount Schedules override list price for volume; Pricing Rules further modify; Contracted Prices override for specific accounts | Price Book selection: SBQQ__PriceBook__c on Quote determines which list prices to use | Multi-currency: Price Book Entries in different currencies for global deals | CPQ-exclusive: Block Pricing, Percent of Total, Cost pricing — beyond standard Price Book capabilities

SBQQ__ConfigurationAttribute__c: field displayed at bundle level during configuration | Feature: linked to a Feature in the bundle | Field: references a Product Option field that gets populated | Target Object: SBQQ__ProductOption__c or SBQQ__Quote__c | Use cases: deployment region (US/EU/APAC) → filters compatible options, user count → drives quantity of all included licenses, installation type (Cloud/On-premise) → shows/hides compatible add-ons | Auto-populate: value set in config attribute flows to all relevant option fields

Ramp pricing: SBQQ__SegmentIndex__c on Quote Line tracks which year/segment | Quote Line Groups: Year 1 group, Year 2 group, Year 3 group with different dates | Different quantities per year: Year 1=100 users, Year 2=150 users, Year 3=200 users | Different prices per year: Year 1=$50/user, Year 2=$55/user, Year 3=$60/user | Total contract value: sum across all ramp segments | Renewal: CPQ creates renewal based on final ramp segment pricing

Configurator features: feature-based option grouping, required/optional options, min/max selection rules, real-time pricing updates, configuration attribute input, guided selling prompts, product rule validation | Access: rep clicks configure on bundle product in QLE | Configuration Questions: can prompt rep for inputs that influence product selection | Dynamic filtering: options show/hide based on previous selections | Finish: configured bundle added to QLE as parent + option lines

Asset object: standard Salesforce Asset, linked to Account, Product2, Contract | Created: when Order Product is activated (asset creation triggered by Billing Rule or CPQ setting) | Asset quantity: reflects current active quantity | Amendment: rep can increase, decrease, or remove assets in Amendment Quote | Co-term: adding new products mid-term → automatically prorated to match existing Asset end date | Upsell: Asset list on Account shows upsell opportunities (assets near renewal, low adoption products)

Co-terming: new product end date = existing contract end date | Proration: new product price = (months remaining / contract term) × annual price | Example: 6 months into 12-month contract, new product $1,200/year → $600 charged (6 months remaining) | SBQQ__CoTerminationEvent__c: when co-terming occurs | Amendment Quote: adding product to existing contract → CPQ auto-sets end date to match | Customer benefit: single renewal date for all products

blng__BillingRule__c fields: blng__InitialBillingTriggerType__c (Activation/Date), blng__BillingTriggerDay__c (day of month), blng__Type__c (Evergreen/Once), blng__BillingFrequency__c (Monthly/Quarterly/Annual) | Billing Type on Product: Advance (invoice at start of period) or Arrears (invoice at end) | Assignment: Billing Rule assigned to Product via SBQQ__BillingRule__c on Product2 | On Order activation: Billing Rules trigger invoice generation based on their configuration

Revenue Schedule types: Equal (straight-line monthly), Custom (milestone-based), Percent Complete (project completion) | blng__RevenueSchedule__c: parent record for revenue distribution | blng__RevenueDistribution__c: individual period recognition records | Created: automatically when Order Product activates (based on Revenue Recognition Rule) | Deferred Revenue: difference between invoice amount and recognized revenue | Monthly recognition: one Distribution record per month of subscription

RLM vs CPQ: RLM is native Salesforce (no managed package); CPQ is sbqq__ managed package | RLM components: Product Catalog Management (PCM), Dynamic Revenue Orchestration (DRO), Pricing Engine with Decision Tables | Key difference: RLM uses Decision Tables for pricing (more flexible than CPQ Pricing Rules) | Migration: Salesforce provides migration tools from CPQ to RLM | Availability: RLM generally available for new implementations; existing CPQ customers migrate gradually | Timeline: RLM = strategic direction; CPQ supported long-term

Decision Table: rows = conditions, columns = inputs and outputs | Input columns: customer type, product family, quantity, region | Output columns: price, discount %, tier | Evaluation: find the row where ALL input conditions match → return output values | Replaces: CPQ Pricing Rules (more flexible, easier to maintain) | Admin-maintained: business users can update pricing tables without code or formula changes | Version control: Decision Tables versioned for audit trail

Integration points: Order Product fields from CPQ (BillingRule, RevenueRecognitionRule, TaxCode) drive Billing behavior | Order activation: triggers Billing to create Invoices based on Billing Rules | Subscription creation: CPQ creates SBQQ__Subscription__c; Billing creates blng__Invoice__c | Payment: blng__Payment__c linked to Invoice | Credit: blng__CreditNote__c for refunds | Tax: TaxRule on Product2 drives tax calculation on Invoice | ERP integration: Billing exports Invoice/Revenue data to financial systems

Order object: standard Salesforce Order | OrderItem: standard Order Product | Created from CPQ: SBQQ__Quote__c.SBQQ__Ordered__c = true → Order auto-created | Order fields from CPQ: Account, Contract, Start Date, End Date, Price Book | OrderItem fields from Quote Line (via Twin Fields): Product, Quantity, Unit Price, Discount, Subscription Type | Order Activation: Status=Activated triggers Billing Rules and Subscription creation | Order Types: New Business, Renewal, Amendment, Add-on

Order Management: Order Status (Draft/Activated/Cancelled), OrderItem status | Order splits: one Order split into multiple fulfillment orders for different warehouses/regions | CPQ Order vs Fulfillment Order: CPQ Order = commitment record; Fulfillment Order = physical shipping instruction | Integration: ERP sync (SAP/Oracle) for physical goods; provisioning API for SaaS | Order change: Amendment creates new Order updating existing subscriptions | Order cancel: cancels subscriptions, triggers credit note in Billing

Bundle = parent Product2 (SBQQ__Configurable__c=true) | SBQQ__Feature__c: grouping sections within bundle | SBQQ__ProductOption__c: links child to parent with Required flag, Min/Max, Type (Component/Add-on) | Product Rules: validation and selection logic | Test: all configuration scenarios in sandbox | Common mistake: forgetting SBQQ__Configurable__c=true on bundle

Component: SBQQ__ProductOption__c.SBQQ__Type__c=Component, price rolled into bundle | Add-on: Type=Add-On, separate Quote Line with own price | Bundle Total: Components included; Add-ons add to total | Visual in QLE: Components indented under bundle; Add-ons as separate lines

Selection rule: auto-adds/removes options based on conditions | Filter rule: shows/hides options based on context | Fired: during bundle configuration in Configurator | Example Selection: Security Module selected → auto-add Audit Log | Example Filter: Deployment=Cloud → show Cloud options only

SBQQ__OptionConstraint__c: links two Product Options | Dependency: select A → B automatically required | Exclusion: select A → B cannot be selected | Simpler than Product Rules for binary logic | Example: Standard Support and Premium Support = Exclusion (mutually exclusive)

SBQQ__Feature__c: linked to Bundle Product | Fields: Name (display label), MinOptionCount, MaxOptionCount, Number (display order) | Feature Price: optional price added to bundle total | Options under feature: ProductOption.SBQQ__Feature__c lookup | Example: Support Tier feature with MaxOptionCount=1 forces exactly one selection

Renewable: fixed term, Subscription record created, renewal quote generated at expiry | Evergreen: no end date, billed continuously until cancelled | One-time: ordered once, billed on activation, no Subscription record | Quote Line fields (Start/End Date, Term): only relevant for Subscription products

SBQQ__LookupQuery__c: SOQL query definition | SBQQ__LookupField__c: maps query result to Quote Line field | Example: query custom Rate Card object → return price for customer+product combination | Maintenance: update pricing by changing lookup records, not CPQ config

Block Pricing: flat total for quantity range (not per-unit × quantity) | SBQQ__Block__c records: quantity ranges with flat prices | Example: 1-10=$500 flat, 11-50=$1,500 flat, 51-100=$2,500 flat | Use case: software with flat ranges regardless of exact user count

SBQQ.PricingPlugin: implement onAfterCalculate(QuoteModel) | Called after standard CPQ pricing | Return modified QuoteModel | Enable: SBQQ__PriceCallbackEnabled__c=true on Account | QCP (JavaScript): client-side alternative for pure calculations | Apex Plugin: when external API calls or complex logic needed

SBQQ__CustomAction__c: Name, Type (Flow/URL), Placement (QLE toolbar/Quote page) | Conditions: show/hide based on field values | Flow: launch Screen Flow or Auto-launched Flow | Pass parameters: Quote/QuoteLine fields to Flow | Use cases: Validate Pricing, Create Project, Request Special Pricing, Apply Discount Template

SBQQ__QuoteLineGroup__c: container for Quote Lines | Fields: Name (section label), StartDate, EndDate, NetTotal | Use cases: multi-year deals (Year 1/Year 2/Year 3 groups), category sections (Hardware/Software/Services), different billing per section | Without groups: all lines in one default group | Group subtotal: shown on PDF per section

SBQQ__PriceSchedule__c: list of absolute prices | SBQQ__PriceScheduleTier__c: From Qty, To Qty, Price | Difference from Discount Schedule: absolute price vs percentage discount | Example: 1-10=$100/unit, 11-50=$85/unit, 51-100=$70/unit | Use case: consumption-based products where unit price changes at thresholds

Nested Bundle: Bundle Product → Option Product (which is itself a bundle) | Configure: parent first → nested bundle options in second configurator screen | Max depth: 2 levels recommended (3 levels causes QLE slowness) | Pricing: each bundle level can have own pricing

QCP: JavaScript deployed as Static Resource | Events: onBeforeCalculate, onCalculate, onAfterCalculate, onInit | Advantage: instant client-side feedback | Limitation: no server callouts | Use case: margin % display, dynamic labels, instant validation | Apex Plugin: use when external API or server data needed

SBQQ__Discount__c: rep's manual additional discount | Stage: Customer Price → Net Price | SBQQ__CustomerDiscount__c: contracted or partner discount | Stage: List Price → Customer Price | SBQQ__PartnerDiscount__c: channel partner margin | Approval triggers: typically based on SBQQ__Discount__c threshold

MDQ: SBQQ__Dimension__c defines segments | One Quote Line, multiple columns (segments) | Each segment: own Quantity, Discount, calculated price | Total: sum across all segments | Contrast to Quote Line Groups: MDQ = one line with segments; Groups = separate lines in sections | PDF: shows segment breakdown per product

Load order matters: parent before child | Data Loader: Product2 and PricebookEntry | CPQ API: bundles (complex structures easier via API) | External IDs: legacy product codes on Product2 for upsert | Testing: all product configurations in sandbox | Simplify: often 300 legacy products → 150 rationalized CPQ products

SBQQ__ConfigurationAttribute__c: displayed at bundle level in Configurator | Field: references ProductOption field | Use cases: deployment region filters compatible options, user count drives all license quantities, industry selection shows compliant products | Auto-populate: value flows to all relevant option fields

PricingMethod = Percent of Total | SBQQ__PercentOfTotalBase__c: what to calculate % of (List/Net/Customer total) | Example: Annual Support = 20% of subscription total | Auto-calculates: as subscription lines increase, support price auto-increases | Use case: maintenance agreements, support contracts, insurance products

Governance: (1) Change request for new products; (2) Finance approves pricing; (3) Product Team approves description; (4) Admin activates in sandbox first; (5) UAT in staging; (6) Production release | Version control: track Product2 field history | Retirement: inactive flag + EndDate vs deletion | Quarterly audit: deactivate unused products | Naming convention: Product Family - Product Name - Edition

Contract: standard Salesforce object | Status: Draft → Activated → Expired | SBQQ__Subscription__c: child records per recurring product | Renewal: auto-created X days before expiry | Amendment: creates new Quote on active Contract | Auto-creation: on Order activation

Renewal: SBQQ__Quote__c.SBQQ__Type__c=Renewal, at expiry, new term, new Contract | Amendment: Type=Amendment, mid-term, changes current Contract, prorated charges | Co-term: amendments prorate new products to existing contract end date | Key: Renewal = new term; Amendment = changes to current term

SBQQ__RenewalForecast__c=true: enables renewal automation | Days before expiry: configured in CPQ settings | Renewal Quote: pre-populated with Subscriptions | Price uplift: SBQQ__RenewalUplift__c auto-increases renewal price | Evergreen: no renewal needed — continues until cancelled

blng__CreditNote__c: Credit Note record | blng__CreditNoteLine__c: line items | Created from: Invoice over-billing, Order cancellation, Amendment credit | Application: against future invoices or refund | Tax reversal: reverses tax from original invoice | Status: Draft → Approved → Applied/Refunded

blng__BillingRule__c: InitialBillingTriggerType (Activation/Date), BillingTriggerDay, Type (Evergreen/Once), BillingFrequency | Advance: invoice at start of period | Arrears: invoice at end | Assigned to Product2 | On Order activation: triggers invoice generation per rule

blng__RevenueSchedule__c: parent | blng__RevenueDistribution__c: one record per recognition period | Methods: Straight-line (equal monthly), Event-based, Percent Complete | Deferred Revenue: billed but not yet recognized | Exported to GL: journal entries per period

blng__DunningRecord__c: tracks dunning status | Dunning Schedule: days past due → action (email/task/suspend) | Actions: email reminder, AR task, suspend service | Escalation: unpaid after X days → Account Manager | De-dunning: auto-stops when invoice paid

blng__InvoiceScheduler__c: cron expression for when billing runs | Advance: generates invoice at period start | Arrears: generates at period end | Multiple schedulers: different products can have different timing | Manual run: on-demand for ad-hoc needs

blng__InvoiceGroup__c: grouping logic | Options: one per Order, one per Account, one per Contract, Custom | Use case: enterprise with multiple Orders → one consolidated monthly invoice | Bill-to Account: invoice to parent company

SBQQ__Ordered__c=true: trigger to create Order | OrderItem from QuoteLine: via Twin Fields (custom fields must be configured) | Order activation: triggers Billing Rules and Subscription creation | Automation: Flow or Apex sets SBQQ__Ordered__c on specific events

Contract: master agreement (Account, Term, Dates) | SBQQ__Subscription__c: child of Contract, per recurring product | Asset: created for each ordered product | Renewal: built from Subscriptions | Amendment: changes Subscription quantities | Asset quantity: current active amount

Daily proration: price/days × actual days | Monthly: price/months × actual months | Mid-period start: 15th of month → billed for remaining days | Amendment: adding mid-term → remaining days at daily rate | Co-term: new product prorated to existing contract end

blng__TaxRule__c: tax method and rates | Native: Salesforce calculates | External: Avalara/Vertex integration | TaxCode on Product: product classification | Tax-exempt: account-level exemption | Tax on Invoice: blng__TaxAmount__c per line

blng__Payment__c: Payment record | blng__PaymentAllocation__c: links payment to invoice | Auto Pay: stored payment method charged automatically | Failed: blng__PaymentException__c → dunning triggered | Refund: blng__Refund__c | Status: Draft → Processing → Processed/Failed

blng__LegalEntity__c: Name, Address, Tax ID, Currency, Logo, Bank Details | Assignment: Invoice Group → Legal Entity | Use case: US/EU/India subsidiaries each invoice their region | Tax: each entity has own tax registration | Invoice header: shows correct entity

SBQQ__ApprovalStep__c: conditions + approver + sequence | Conditions: Discount>20% → Manager, Deal>$500K → VP Sales | Parallel: multiple steps simultaneously | Auto-approve: standard deals below threshold | Chatter notifications: approver sees details inline | Status: Draft → Pending → Approved/Rejected

Invoice: Account, Date, Due Date, Total, Status (Draft/Posted/Paid), Invoice Number | InvoiceLine: Invoice (parent), Product, Quantity, Unit Price, Total, Tax Amount | Post: generates PDF, emails customer, creates GL entries | Paid: when Payment Allocation applied

ERP: Invoice + Revenue Distribution → GL journal entries | Payment: tokenized card → auto-charge | Tax: real-time calculation on invoice | DocuSign: Quote acceptance → Order creation trigger | Provisioning: Order activation → API call to SaaS platform/warehouse | CRMA: ARR/MRR dashboards

Evergreen: no EndDate, continuous billing | No renewal quote generated (unlike Renewable) | Cancellation: Cancellation Order sets EndDate → billing stops | Use case: month-to-month SaaS, ongoing platform fees | Amendment: quantity/price changes via Amendment Quote

Pre-built dashboards: ARR/MRR trends, Revenue Waterfall, Renewal Pipeline, Quote-to-Cash funnel, Top Deals, Product Mix | Data from: Opportunity, Quote, Order, Subscription, Invoice, Revenue Schedule | Refresh: daily scheduled | License: CRM Analytics license required

SBQQ.QuoteAPI.read(quoteId): returns QuoteModel JSON | SBQQ.QuoteAPI.save(quote): saves QuoteModel | SBQQ.OrderAPI.createOrders(quoteId): creates Order | SBQQ.ContractAPI.activate(contractId): activates Contract | Async required: CPQ API involves HTTP callouts — must use @future or Queueable

Properties: record (SBQQ__Quote__c), lineItems (List), groups (List) | Read: QuoteAPI.read(id) → deserialize JSON | Modify: update lineItem fields | Save: QuoteAPI.save(JSON.serialize(qm)) → CPQ recalculates | Common: auto-populate fields, apply programmatic discounts

Test data: Account, Opportunity, Pricebook2, Product2 with SBQQ fields, PricebookEntry, SBQQ__Quote__c, SBQQ__QuoteLine__c | Pricing engine: mock HTTP callouts (cannot call Heroku in tests) | SeeAllData=false: works with created test data | TestDataFactory: create reusable CPQ test data factory

SBQQ.PricingPlugin: onAfterCalculate(SBQQ.QuoteModel) | Enable: SBQQ__PriceCallbackEnabled__c=true | Modify: update line prices in QuoteModel → returned to CPQ | Synchronous: keep lightweight | Use cases: external pricing API, ML pricing, ERP price lookup

Data flows: Invoice Posted → MuleSoft → NetSuite Journal Entry | Revenue Distribution → nightly batch → scheduled entries | Payment → Cash Receipt (real-time) | Credit Note → Credit Memo | External IDs: NetSuite TransactionId on Invoice for deduplication | Platform Events: trigger real-time sync

SOQL: lines × queries per rule = limit exceeded → batch with IN clause | Heap: 200-line QuoteModel can hit 6MB | CPU: complex nested bundles | Fix SOQL: IN clause instead of per-line queries | Fix heap: batch processing | Fix CPU: flatten bundles, fewer rules | Monitor: test with max expected quote size

DocuSign App on AppExchange | Send for Signature button on Quote | DocuSign completion event → Platform Event → Flow → Quote accepted + ordered | Multi-signer: multiple recipients configured | Time from signature to Order: automated (3 min) vs manual (24 hrs)

Never modify CPQ managed objects | Use Custom Actions not triggers on SBQQ__ objects | Twin Fields for all custom fields | Test CPQ upgrade compatibility in sandbox | Document all configurations | Train sales reps on QLE before go-live | Test with real deal scenarios

Custom fields: safe to add to SBQQ__Quote__c, SBQQ__QuoteLine__c | Twin Fields: SBQQ__FieldMetadata__c maps QuoteLine → OrderItem custom fields | Triggers: AVOID on SBQQ__ objects — use CPQ APIs or Custom Actions | Validation Rules: safe on CPQ objects | CPQ upgrades: custom fields survive (not part of managed package)

CPQ: managed package, SBQQ__ namespace, bundles, Pricing Rules, large installed base | RLM: native objects, no namespace, attribute-based products, Decision Tables, newer | CPQ: supported long-term but primary investment going to RLM | RLM: for new implementations | Migration: CPQ→RLM tools available from Salesforce

Anti-pattern: 68% of quotes requiring approval (benchmark 30-40%) | Root cause: approval at >10% discount — nearly every deal triggers | Fix: align approvals to margin risk not just discount % | Auto-approve: standard margin deals | Parallel: independent approvals simultaneously not sequentially

Price Waterfall: toggle visibility on Quote Line → see each step | CPQ Debug: SBQQ__EnableDebug__c=true on User → see rules fired | SBQQ__SystemLog__c: CPQ error records | Common errors: wrong Price Book, deprecated field in condition, Contracted Price expired

ARR: Subscription annual value | MRR: ARR/12 | Churn: lost ARR / beginning ARR | NRR: (Begin ARR + Expansion - Churn) / Begin ARR | Renewal Rate: Renewed / Expired | ACV: Quote net amount average | Quote-to-Close: Won / Total Opportunities

Partner Price Book: list minus partner margin | Experience Cloud: partners log in and create quotes | Deal Registration: Opportunity submitted by partner → review → approved → deal protection | Partner Quote Template: white-labeled with partner branding | SBQQ__PartnerDiscount__c: partner margin on Quote Line

QLE performance: <200 Quote Lines optimal, <50 Pricing Rules, <2 bundle levels | Lookup Queries: batch retrieval vs per-line SOQL | QCP: client-side calculations for instant feedback | Monitor: measure QLE save time regularly, alert if >3 seconds | Quarterly governance: deactivate unused rules/products

SaaS decisions: Evergreen (monthly) vs Renewable (annual), usage-based Dimensions, churn tracking (cancellations), expansion (amendments), NRR calculation | Integrations: Stripe, Avalara, AWS provisioning, CRMA

SBQQ__FieldMetadata__c: maps source (QuoteLine field) to target (OrderItem field) | Standard fields: mapped automatically | Custom fields: require explicit Twin Field records | Also for Contract: QuoteLine → Subscription mapping | Missing Twin Field: data silently lost on Order creation

Monitor: Invoice Exceptions dashboard (daily), Billing Error queue, QLE save time trend, Payment failure rate | Maintenance: quarterly rule audit, managed package upgrade testing, Twin Field audit for new custom fields | Training: new rep onboarding on QLE | Upgrade strategy: sandbox → staging → production with regression testing

Einstein: suggests optimal price based on similar won deals | Agentforce quoting: rep types quote request in natural language → agent builds full CPQ quote | Renewal AI: predicts churn 90 days before expiry | Exception handling: detects and resolves Invoice Exceptions automatically | 2026: Agentforce Revenue Actions in pilot

ASC 606 five steps: (1) Identify contract → Salesforce Contract, (2) Performance obligations → blng__PerformanceObligation__c, (3) Transaction price → CPQ Quote, (4) Allocate → Revenue Schedule, (5) Recognize → Revenue Distribution records | Contract modification: Amendment creates new Revenue Schedule

Key decisions: product type (Evergreen/Renewable), pricing model (per-seat/usage/tiered), integrations (Stripe, Avalara, provisioning API), reporting (ARR/MRR/NRR/Churn) | Phase 1: product catalog design. Phase 2: pricing rules. Phase 3: integrations. Phase 4: testing.

Custom Action: rep submits request with desired price + justification | Approval: VP reviews in Salesforce | On approval: Flow creates SBQQ__ContractedPrice__c for account+product | Audit trail: all requests logged with approver, reason, expiry, deal outcome

Equipment: bundle (motor+casing+controls as components), one-time | Maintenance Agreement: Renewable subscription, annual billing | Spare Parts: catalog one-time | ERP: SAP/Oracle integration on Order activation for production order

Challenge 1: product migration (legacy bundles don't map directly to CPQ) | Challenge 2: ERP GL codes differ from Salesforce product hierarchy | Challenge 3: rep adoption (resist change from Excel) | Challenge 4: scale (200+ line quotes hit SOQL limits) | Challenge 5: upgrades (2-3x/year, each needs regression)

POC scope: 10 products (all pricing methods), 2 bundles, 3 Pricing Rules, Approval matrix, Quote Template, Order creation, Invoice generation | UAT: reps test with real pending deals | Success criteria: quote<10 min, approval<4 hrs, accurate invoice

CPQ Specialist: Salesforce official exam | Revenue Cloud Accredited Professional: newer, covers RLM | Prerequisites: Admin certification recommended | Trailhead: CPQ Specialist Superbadge | Salary premium: 20-30% over standard Salesforce | Hands-on lab: configure bundle + pricing rule + generate quote

Role products: one Product2 per role with hourly rate | T&M: Duration Dimension (hours × rate) | Fixed Price: one-time flat product | SOW Template: detailed sections per deliverable | Milestone billing: completion % triggers invoice | Margin: QLE column showing cost vs price

Process: (1) Install new version in full sandbox; (2) Run all automated Apex tests; (3) Run manual UAT (key deal scenarios); (4) Test all integrations (DocuSign, Stripe, ERP); (5) Staging environment test; (6) Production weekend upgrade | Schedule: CPQ releases 2-3x/year | Common issues: deprecated API usage, managed class changes

Tier 1 (Starter): flat price, no volume discount | Tier 2 (Professional): volume Discount Schedule (10-100 users scale) | Tier 3 (Enterprise): negotiated Contracted Prices | Add-on: Support = 20% of subscription (Percent of Total) | Annual discount: 15% Pricing Rule for annual billing | Bundle: each tier = bundle with included features

CPQ Specialist: Product configuration, Pricing Rules, Quote Templates, QLE customization, basic Billing | Revenue Cloud Architect: architecture decisions (CPQ vs RLM), ERP integration design, ASC 606 strategy, multi-entity billing design, performance at scale, team leadership | Experience: Specialist 1-3 years, Architect 5+ years | Salary: Specialist $100-140K, Architect $160-220K

Advanced Currency Management: dated exchange rates | Local Price Book Entries: accurate local pricing (not just converted) | Quote currency: from Opportunity | Reporting: all amounts roll up to corporate currency | Best practice: create local PricebookEntry vs relying on auto-conversion

Governance: change request → sandbox → UAT → production | Product Catalog Committee: monthly meeting — new products, price changes, bundle updates | Rule audit: quarterly (deactivate unused, fix deprecated fields) | Documentation: all configurations documented in Confluence | Admin certification: Revenue Cloud admins must be CPQ Specialist certified

GSA pricing: Contracted Prices for all GSA-eligible products | Compliance rules: Product Rules auto-select required compliance modules | Option periods: Base Year + Option Year 1-4 as Quote Line Groups | Tax-exempt: TaxStatus=Exempt on government accounts | Contract vehicle: GWAC/BPA/IDIQ fields on Quote

blng__Usage__c: usage record (Product, Quantity, Date) | Created: via API (ERP, app event, meter) or manual | Billing: reads usage records in billing period → calculates invoice | Rates: from Price Schedule or Pricing Rules | Metered: API calls, storage GB, compute hours | Reconciliation: compare metered usage vs billed

Competitive Pricing Rule: Opportunity.CompetitorName__c = Oracle/SAP → apply 20% discount | SBQQ__Quote__c.Competitive__c checkbox → triggers rule | Approval: competitive discount >30% requires VP approval | Win rate tracking: report on competitive deals with/without discount | Protection: contracted competitor pricing expires in 12 months

Finance responsibilities: ASC 606 recognition method selection | GL mapping: Salesforce revenue categories → chart of accounts | Approval matrix: financial deal thresholds | Credit Note approval: controls for revenue adjustments | Revenue close: monthly Revenue Distribution review | Audit: documentation of recognition policies | Finance sign-off: required before go-live

COE roles: CPQ Admin (day-to-day config), Billing Admin (invoice exceptions, payment failures), Integration Dev (ERP + gateway maintenance), Architect (upgrades, roadmap, governance), SA (Finance liaison), Business Analyst (Sales liaison) | Processes: change management, quarterly audit, upgrade strategy, KPI reporting | Tools: CRMA for system health, Jira for change requests

Common Excel patterns to CPQ: product lists → Product2, discount tables → Discount Schedules, approval emails → CPQ Approvals, Word templates → Quote Templates, manual order entry → CPQ Order creation | Change management: critical — reps have used Excel for years | Pilot group: 3-5 champion reps first | Quick win: show time savings in Week 1 of pilot

Recurring services: Managed Services (Evergreen, monthly), Annual SLA (Renewable, pre-paid), T&M Project Work (Time Dimension), Retainer (Evergreen, flat monthly) | Billing: managed services auto-invoice monthly, SLA annual invoice, T&M on completion | Staffing: resource allocation tracked against subscription capacity

CRMA datasets: Opportunity, SBQQ__Quote__c, Order, SBQQ__Subscription__c, blng__Invoice__c, blng__RevenueDistribution__c | Calculated metrics: ARR (Subscription × 12), MRR (ARR/12), NRR ((Begin+Expansion-Churn)/Begin), Churn (lost ARR), ACV (Quote average) | Refresh: daily at 6AM | Single source of truth: eliminate Excel reports

Multiple Quotes per Opportunity: compare alternatives, only one Primary | Status: Draft (building) → Needs Review → Approved → Presented → Accepted | Custom version field: V1.0, V1.1, V2.0 | Field history: track all Quote changes (who, when, what) | Chatter: feed on Quote record for comments | Archive: old Quotes preserved, Primary=false

Migration order: (1) Product2 + PricebookEntry, (2) SBQQ__Feature__c + SBQQ__ProductOption__c, (3) Account Contracted Prices, (4) Active Contracts, (5) SBQQ__Subscription__c, (6) blng__Invoice__c (historical) | External IDs: legacy system ID on every record | Validation: count records, compare amounts, spot-check 10% | In-flight quotes: build fresh in CPQ (don't migrate open quotes) | Cutover: weekend, freeze legacy on Friday

Health check items: Pricing Rules active (should be <50), Product catalog active (should match actual offerings), QLE save time (<2 sec), Invoice Exceptions/month (<1%), Payment failures/month (<3%), Renewal coverage (Renewal Quotes created for 100% of expiring contracts), Apex test coverage (>80%), CPQ package version (should be current)

Real-time: Platform Events → MuleSoft/Apex → ERP/Provisioning | Batch: nightly Apex/MuleSoft for Revenue Distribution → GL | API-first: external system calls Salesforce REST API → creates Order or Invoice | Event-driven: Order Activation event → triggers provisioning, billing, notifications simultaneously | Error handling: retry mechanism, dead letter queue, exception monitoring

(1) Data model: Opportunity→Quote→Order→Contract→Subscription→Invoice | (2) Price Waterfall: List→Special→Customer→Net | (3) Bundle: Features+Options+Rules | (4) Pricing: Rules (conditional) vs Schedules (volume tiers) vs Contracted (account-specific) | (5) Quote-to-Order: SBQQ__Ordered__c trigger | (6) Renewal vs Amendment | (7) ASC 606: blng__RevenueDistribution__c | (8) SBQQ.QuoteAPI + Queueable | (9) CPQ=managed package, RLM=native | (10) Platform Events + MuleSoft