Admin Guide
For the Salesforce admin implementing Pinion CPQ — how licensing, pricing models, bundle math, MDQ, approvals, and configuration actually work under the hood.
Getting Oriented
Welcome
What Pinion CPQ is, who this Admin Guide is for, and what it covers — answering ”why is the total what it is?” without opening Apex.
The Big Picture
Pinion has one canonical pricing kernel — PricingMath — that owns every formula. The practical consequence is that what reps see matches the persisted line items, byte-for-byte.
Licensing & Tiers
Pinion ships in two tiers — Pinion (base) and Pinion+ — and which one an org is on decides which features are available to configure. Gating is ”shown, not hidden”: Plus features appear with an upgrade prompt; base limits are enforced only when you try to exceed them.
Pricing Concepts
Bundle Math — Effective Quantity
When a product has bundle options, Pinion decides how the parent's quantity relates to each option's. Components and Fixed Price Components scale (parent × option); Accessories don't. Multiplication happens once, at save time.
Pricing Models
Each bundle picks one of three pricing models — Standard, Roll-Up, or Itemized — via the parent product's PricingModel__c. The model decides how the parent total relates to the child line totals.
Fixed Price Components
An FPC scales its quantity like a Component (parent × option) but contributes a flat total to the bundle regardless of parent quantity — its stored unit price is rawSalesPrice / effectiveOptionQty. Use it for implementation, onboarding, and setup fees.
Proration
How Pinion prorates a subscription line whose coverage doesn't align to whole billing periods — the Proration Type field, its four granularity floors, and the blank fallback.
MDQ — Multi-Dimensional Quoting
A subscription product can be priced across dimensions (usually time — year 1, 2, 3) as segments. Partial segments prorate their billable quantity by a configurable-per-product term factor (Proration Type); each segment can apply a compound percentage uplift over the previous.
Block Pricing
Block pricing replaces a product's single list price with fixed unit prices by quantity band. When a line spans more than one band, the Block Aggregation Mode (Slab vs Range) decides how they combine.
Usage & Metered Billing
A metered product prices as a committed base subscription plus a projected overage estimated from a usage rate card above an included entitlement. The overage is a non-contractual quoting estimate in v1. Usage authoring is a Pinion+ capability.
Config-Attribute Pricing
Configuration attributes a rep fills in can adjust a line's unit price — picklist/multi-select overrides or deltas, number bands, checkbox both-sides. Contributions blend into the unit price and show as their own step in the Price Waterfall. Base allows 2 attributes per product; Pinion+ raises the cap and adds dimensional attributes.
Renewals & Amendments
Renewals and amendments both re-price carried-forward lines on the effective date — active contracted price, then discount schedule, then subscription verbatim price. Re-pricing is always on; there is no org-wide toggle. Multi-instance bundles carry forward independently.
The Universal Invariant
One equation holds across every pricing model — parent.Quantity × BundlePrice__c equals the bundle's total dollar contribution. If a quote ever violates it, that's a real bug.
Approvals
Overview & Data Model
Pinion ships its own approval engine that knows about products, bundle options, line aggregates, and configuration draft state. This page explains when to reach for it and the seven custom objects it's built from.
Authoring a Rule
The four-step approval wizard — Basics (name, target, mode, match policy), Steps (the split-pane editor), Policy (per-chain knobs like SLA, reroute, consolidation, smart approval), and Review (author-time validation).
Conditions
Firing criteria — the left/operator/right comparisons that decide whether a rule fires — plus line aggregates (COUNT/SUM/AVG/MIN/MAX), reusable variables, and scoping a rule or condition to a product.
Approvers
An Approver__c record wraps a User, Queue, Public Group, or Role and is reusable across rules. This page covers how a rule picks its approver (Approver / Manager / AccountOwnerManager / Formula), sequential vs parallel chains, cohorts, reroute, and consolidation.
Runtime & Troubleshooting
What reps and approvers see when a rule fires — the ”Why this approval?” tooltip and evaluation log — how to disable the engine with the kill switch, and a full worked example of a discount-escalation chain.
Administration
Overview
Where Pinion's admin configuration lives — the Pinion Admin app, the singleton Configurator Settings record that drives org-wide behavior, and the permission set that grants admin access. Orientation for the rest of this section.
Configurator Settings
The org-wide Configurator Settings singleton — the target line object (Opportunity vs Quote mode), the parent grouping field, the performance/tuning knobs, and the default theme. Kill switches and lifecycle defaults live on the same record but have their own pages.
Kill Switches
The Disable… toggles on Configurator Settings turn off rule engines, server-side pricing/recompute, and rule scoping. Polarity is null=active (absent record means everything runs). Reach for them to isolate an incident, not as routine configuration.
Lifecycle Defaults
The Configurator Settings fields that drive the contract lifecycle — the stages, record types, and opportunity types stamped on renewals, amendments, and new business, plus the default uplift, proration type, contract-end convention, and amendment credit behavior.
Field Propagation
How field values flow through the deal lifecycle. Two hops, two mechanisms — a Quote's line items copy to the Opportunity's automatically as twin fields on sync, and the Opportunity's line items copy onto the Contract, Subscription, and Asset records at close-won through an explicit, fixed mapping. What carries for free, what a custom field needs, and why the close-won write runs in system mode.
Personas & Permission Sets
Pinion ships nine permission sets, each a persona. PinionAdministrator is the full-admin set; PinionUser is the paid configurator seat; the rest are narrower free personas (approver, account manager, deal desk, quote manager, RevOps) plus a minimal home floor and an MCP OAuth grouping.
Licensing & Feature Gates
How a Pinion license is activated (a signed JWT stored on PinionLicense__c, validated against LicenseConfig) and how the tier gate enforces — FeatureGateGuard checks capability gates (Pinion+ only) and limit gates (a base cap, unlimited on Pinion+) and surfaces an upgrade prompt.
Setup Wizard
The post-install health check in Pinion Admin. It runs three live, server-computed steps — permission-set assignment, license activation, and Connect Hosted MCP (Pinion+) — each reporting a status you can re-check any time. It detects and links, it doesn't change your org for you.
Scheduled Jobs
Pinion's batch and scheduled jobs — auto-renewal, contract-expiration, approval-escalation, and SyncKey backfill. The approval-escalation and backfill jobs self-seed; the auto-renewal and contract-expiration jobs define their cron but you must schedule them yourself.
Trigger Bypass
BypassSettings__c is a hierarchy custom setting that switches off Pinion's triggers (and platform events) per user or profile. Use it for bulk data loads and admin operations where you don't want the engine reacting to every row, then turn it back off.
Audit & Error Logs
Two separate concerns — AuditTrailSettings__c.LoggingMode controls whether engine writes (not just manual edits) are audit-logged, and ErrorLog__c is the package's error sink. Raw error-log fields stay FLS-invisible; the parity-break tamper trail is surfaced through a gated, sanitized viewer behind the Pinion View Error Log permission.
Integrations
Overview
How Pinion connects to the rest of your stack. Pinion is the system of record for configuration, pricing, quotes, and contracts; integrations let AI assistants drive it, and let external systems (billing, ERP, e-signature, analytics) read the committed terms and react to changes. The pattern is ”bring your own system” — Pinion exposes clean surfaces (MCP, platform events, queryable records) and your assistant or integration middleware does the rest, with data staying in Salesforce.
AI Assistant Access
Pinion ships a native Salesforce Hosted MCP server so an AI assistant can answer questions about deals and take a few tightly scoped actions — every tool runs as the signed-in user. Setup is three tasks: activate the server, configure the packaged External Client App, and gate who can connect. A Pinion+ feature.
Composing MCP Servers
Native Hosted MCP is admin-composed — you decide which packaged tools each MCP server exposes. Compose servers by least privilege, aligned to Pinion's persona/license model. The recommended pattern is three concentric rings — Insights (read-only), Operate (free-persona actions), and Author (the paid, tier-zero ConfigurePrice tool) — so a broad grant can never reach a narrow-grant tool. A Pinion+ feature.
Creating MCP Servers & Client Apps
The click-by-click how-to for building your own MCP servers and External Client Apps beyond Pinion's all-tools quick start. Create an McpServerDefinition and attach the tools you want, create an External Client App in Setup, and gate its OAuth policy to a permission set so only the right people connect. Covers the ECA-to-server topology, the re-activation gotcha, and when — and why — you'd scope down from the all-tools default. A Pinion+ feature.
Platform Events & Webhooks
Pinion publishes Salesforce Platform Events for key lifecycle transitions — a subscription created or changed, an approval submitted or decided, a quote document generated. External systems, Flows, or middleware subscribe to react without polling. This is the outbound integration surface: each event is a thin notification carrying keys and a change type, so a subscriber re-queries the record for full detail. Reference for every event, when it fires, and its payload.
Billing Integration for Usage-Based Products
Pinion commits the usage rate card on a closed deal but does not meter consumption or invoice. This page is the integration contract for connecting your own billing system — where the committed terms live (line, subscription, and the rate-card ladder), how to resolve the full graduated/volume schedule, the SubscriptionChanged__e change signal to sync on, and the recommended pattern for feeding terms into Revenue Cloud, Stripe, Metronome, Orb, Zuora, or a homegrown biller.