| Posture |
| Primary use case | AI front door for complex catalogs: buyer arrives with a task, receives a validated configuration and commercial quote without waiting on a rep. Full CPQ workflow in one deterministic engine. | Rep-console quoting inside Salesforce: rep handles discovery outside the CPQ, then Salesforce CPQ (SteelBrick) generates quote objects on CRM records. | Coexistence |
|---|
| Primary user persona | Buyer self-serve (full / guided / sales-assisted); internal-tool mode — rep pastes customer requirements, BOM lands in CRM. Escalation target: < 10% of sessions. | Rep and deal desk — quoting after external discovery. Buyer self-serve requires a separate portal engagement. | Lean Talkulate AI CPQ |
|---|
| Deployment model | Standalone without Salesforce: chat widget, iframe (10-min deploy on any CMS), JS snippet, embedded page, headless API. Connects to any CRM or ERP stack. | CRM-native managed package: requires a Salesforce tenant and a Salesforce license. — Revenue Cloud (separate product) additionally requires a CRM prerequisite license. | Lean Talkulate AI CPQ |
|---|
| Entry UX | Plain-language task entry with optional persona routing (B2B technical / B2C consumer / installer / homeowner / fleet). Contextual goals, not decision trees. | Forms, picklists, and guided flows in the rep UI. — Buyer-facing NL entry requires separate portal or community project work. | Lean Talkulate AI CPQ |
|---|
| Product status | Active product development; AI-native architecture roadmap. | "End-of-sale" as of 2025 per official Salesforce materials. — Existing customers can renew contracts, add licenses, and receive full support — no forced migration. Salesforce directs new CPQ investment to Revenue Cloud (a separate, API-first product line). | Program-dependent |
|---|
| Self-serve modes | Three built-in modes: full self-serve, guided self-serve (rep invited mid-flow), and sales-assisted (rep paste-in). Maturity benchmark: < 10% escalation rate. | Salesforce communities and portals support buyer self-serve but are typically separate SI-project builds on top of the CPQ package. | Lean Talkulate AI CPQ |
|---|
| Discovery & pricing |
| Discovery model | Interviewer Agent: contextual goals — you define the data points, the agent determines order and phrasing per context. Reference case: 6–10 questions, 4–8 minutes to a validated BOM. | Rep-mediated discovery via forms, picklists, and guided flows. — Native buyer conversational discovery is not part of the legacy CPQ package. | Lean Talkulate AI CPQ |
|---|
| CPQ workflow coverage | Six stages in a single engine: Entry (plain language) → Discovery (Interviewer Agent) → Selection (Engineer Agent + DB validation) → Pricing (rules + tiers + bundles) → Output (BOM + proposal + reasoning) → Handoff (CRM / ERP / exception routing). | Same six stages covered; discovery typically external; quoting and approval in Salesforce UI; output as CRM quote objects. | Coexistence |
|---|
| Pricing engine depth | Volume tiers, bundle logic (buy X + Y → discount), regional price lists, SLA adders (% of hardware cost), customer-specific tiers and contract rebates (MRO), time-limited promotions, multi-currency (EUR / USD / GBP). Pricing runs inside the same Engineer Agent that validates compatibility. | Rules-based Price Conditions with documented Object / Operator / Filter Type (Value / Variable / Formula) model — strong pricing rules surface on a well-implemented instance. | Lean Salesforce CPQ |
|---|
| Real-time option swaps | Buyer swaps a compatible alternative → Engineer Agent revalidates the full BOM and reprices instantly. Out-of-rule swaps are blocked at the engine level — the buyer cannot build an invalid configuration. | Real-time repricing on option change is possible when UI and integration latency allow; timing behavior depends on product rule and attribute configuration. | Lean Talkulate AI CPQ |
|---|
| Output formats | Validated BOM (line items + specs + compatibility confirmations) + interactive commercial proposal + per-line reasoning (inline or summary mode) + compatible alternatives swap + branded PDF. Sales BOM by default; EBOM / MBOM as scoped output. | Quote and proposal outputs are standard; per-line AI reasoning in buyer UX is not a native feature of the legacy managed package. | Lean Talkulate AI CPQ |
|---|
| BOM types | Sales BOM default (selling-level). — Engineering BOM (EBOM) and Manufacturing BOM (MBOM) are out-of-scope for the standard product — available as a separate engagement scope. | Multiple BOM structures supported per manufacturing setup; depth depends on implementation and product rule modeling. | Program-dependent |
|---|
| Approval & discount governance | Discount threshold approvals available as add-on scope per tenant (e.g. — discount > 15% → manager sign-off in CRM). Not included out of the box. | Built-in approval frameworks for discounts and entitlements are a standard feature of Salesforce CPQ (SteelBrick) programs and a documented competitive strength. | Lean Salesforce CPQ |
|---|
| Validation |
| Validation method | Deterministic: Engineer Agent runs multi-step function calls against a live PostgreSQL tenant database via a secure MCP bridge. No document retrieval, no similarity matching — every component selection is mathematically checked against rules. | Rules engine + data model: rules-based pricing and configuration via Price Conditions and product rules. Not LLM-guesswork — a well-configured instance produces reliable quotes. Correctness depends on rule and data quality. | Coexistence |
|---|
| Invalid configuration handling | Engineer Agent runs allowlisted queries on the live catalog — no document retrieval for compatibility. Invalid combinations are blocked with per-line reasoning before a governed BOM is pushed into Salesforce. In one published internal reference (~3,400 SKUs), reps stopped routing every standard quote through presales engineering review. | Salesforce CPQ (SteelBrick) enforces configuration through product and price rules on Salesforce objects. When rules and data are sound, invalid combos are blocked in the managed package; when rules are incomplete, quotes can look valid until someone audits them — remediation is rule engineering, not swapping the CPQ UI. | Program-dependent |
|---|
| Constraint types covered | Electrical / power (PSU vs system load), physical (chassis / slots / dimensions), interface (ports / transceivers / cable types), performance budgets (memory bandwidth / throughput / latency), regulatory (CE marking, FDA, UL, NSF, RoHS), commercial (regional / contract / partner pricing), operational (lead time, regional availability, install complexity). | Commercial and product rules are mature (Price Conditions). Deep technical constraint coverage — electrical, physical, regulatory — depends on implementation scope and SI modeling effort. | Program-dependent |
|---|
| Dual-agent architecture | Interviewer Agent (contextual discovery, tool-calling, persona routing) and Engineer Agent (deterministic validation, pricing, BOM assembly) are fully separated. The Engineer Agent only executes allowlisted database queries — it cannot be prompted to return arbitrary data. | Salesforce CPQ (SteelBrick) uses a single rules engine and data model. — There is no LLM layer by default, so prompt-injection is not a relevant attack surface for the legacy managed package. | Lean Talkulate AI CPQ |
|---|
| Internal data model | Optimized PostgreSQL tenant database built and owned by the configurator — separate from source systems. The MCP bridge enables real-time queries; per-tenant isolation at both DB and runtime level. | Salesforce objects and managed-package data model. — Revenue Cloud (separate product) is native on Salesforce Platform with API-first architecture, explicitly contrasted with the managed-package "app-first" constraint of legacy Salesforce CPQ (SteelBrick). | Coexistence |
|---|
| Catalog source connectors | Relational DBs: PostgreSQL, MySQL, MSSQL. — ERP stacks: SAP, Oracle NetSuite, Microsoft Dynamics, Salesforce CPQ. Loose data: Excel files, PDF specifications, XML feeds, REST APIs, scheduled file drops. Engineer tribal knowledge captured during data-structuring engagement. | CRM + ERP + integration fabric via Salesforce platform connectors and partner-built integrations. — Admin-heavy programs for non-Salesforce source systems. | Program-dependent |
|---|
| Per-line audit trail | Every BOM line records which constraint triggered the selection and why this component rather than an alternative — surfaced to both buyer and rep in inline or summary mode. Full historical query available for compliance review. | Field-level and rule-level audit is standard. — An LLM-style reasoning log explaining each configuration decision in buyer UX is not a native feature. | Lean Talkulate AI CPQ |
|---|
| Observability & tracing | Langfuse tracing per agent session (Interviewer and Engineer traces separately). — Rate limiting: 20 req / IP / hour on chat, 10 req / IP / hour on overview. Session persistence in sessionStorage; resumable across days with SSO / SAML authentication. | Salesforce platform monitoring and logging. — No LLM observability layer is relevant for the legacy managed package. | Lean Talkulate AI CPQ |
|---|
| Channels & time to value |
| Embed channels | Chat widget (brand-customizable), iframe (10-minute deploy, no backend changes to host site), JS snippet, embedded page, headless API, internal-tool (account-manager-facing). CMS coverage: Shopify, BigCommerce, WordPress, and ~99% of custom CMS that allow JS or iframe embed. | Salesforce CRM UI and partner-built portals. — Revenue Cloud emphasizes API-first architecture for headless patterns; legacy Salesforce CPQ (SteelBrick) UI is app-first / managed-package constrained. | Lean Talkulate AI CPQ |
|---|
| Async messenger channels | The same Interviewer + Engineer flow runs inside: WhatsApp, Telegram, Microsoft Teams, Slack DM / Connect, Facebook Messenger, LinkedIn — one validation engine, multiple channel adapters. Outcome: PDF delivered in-thread + secure link to interactive proposal page. Each channel is implementation-scoped. | Web-console and rep-console centric. — Messenger-native CPQ intake is not a documented feature of the legacy Salesforce CPQ (SteelBrick) managed package. | Lean Talkulate AI CPQ |
|---|
| Time to production buyer surface | Envelope: 5 days – 6 weeks. — Typical: 3–5 weeks. Canonical reference case: 5 weeks from kick-off to production. Driven by catalog complexity and integration scope. | Timeline is sensitive to migration complexity, data volume, custom object structures, integrations, and SI / SME availability. No public numeric SLA on Salesforce pricing pages. Official Trailhead content frames timeline around drivers, not a fixed duration. Enterprise programs are often multi-month. | Lean Talkulate AI CPQ |
|---|
| Customer effort | 10–15 hours over 2–3 weeks (vendor claim for standard deployment). — Reps consume outputs; they do not operate the tool. Single 60-minute demo is sufficient for rep readiness. | Heavier stakeholder alignment, SI discovery, data and rule modeling, UAT, and hypercare phases. — Exact effort depends on catalog complexity and partner scope. | Lean Talkulate AI CPQ |
|---|
| "No structured catalog" path | Data structuring service ($3,450–$17,250 one-time): consolidates Excel files, PDF specifications, and tribal knowledge into a queryable schema ready for the validation engine. 500 components = low end of band; 5 000+ SKUs with broken documentation = high end. | Data migration and admin modeling work is partner-scoped. — No equivalent fixed-fee public offering for catalog structuring; scope is determined by SI discovery. | Program-dependent |
|---|
| Verticals | Eight first-class vertical packs — each a capability skin over the same engine: servers & IT infrastructure, hosting & cloud, automotive (VIN/YMM fitment + fleet), telecom (multi-vendor network BOM), energy (solar / HVAC + regional grid rules), retail (B2C compatible build), fintech / fleet insurance, MRO (spec-based equivalence, 50–200 line RFQs). | Generic CPQ with partner-led verticalization. — No equivalent first-class vertical packs in the managed package. | Lean Talkulate AI CPQ |
|---|
| Security & governance |
| Error mode | Refuse: the engine does not publish incompatible combinations. — Each selection is checked against tenant rules before output; out-of-rule options are blocked rather than approximated from documents. | Rules engine blocks disallowed combinations when rules are correctly defined. — With missing or incorrect rules, the engine may produce a plausible-looking but incorrect quote without flagging it — correctness is a function of implementation quality, not an architectural guarantee. | Lean Talkulate AI CPQ |
|---|
| Regulatory constraint encoding | CE marking, FDA, UL, NSF, RoHS, and medical-device certification constraints are encodable as product rules in the validation engine. Regulated-industry TCO factor: ×1.2 applied in reference pricing. | Implementation-dependent. — Regulatory rules can be encoded in product and price rule objects, but depth and coverage depend on the SI and customer team that built the rules. | Program-dependent |
|---|
| Anti-prompt-injection | Dual-agent separation is the architectural defense: the Engineer Agent only executes allowlisted PostgreSQL queries — it cannot be prompted via user input to return arbitrary data or exfiltrate cost / margin information. Vendor does not need access to internal cost data; only customer-facing prices are required. | Salesforce CPQ (SteelBrick) is not LLM-fronted for the core quoting engine. — Prompt-injection is not the relevant attack surface; workflow-level misuse (misconfigured rules, insufficient RBAC) is the applicable risk class for the legacy managed package. | Lean Talkulate AI CPQ |
|---|
| GDPR / PII posture | DPA in place. — PII is separated from configuration data. No training on client catalog or conversation data. Data minimization principle: vendor does not need internal margins or costs — only the customer-facing price list enters the configurator database. | Enterprise compliance programs on the Salesforce platform. — DPA and data residency options available through standard Salesforce enterprise agreements. | Program-dependent |
|---|
| Multi-tenant isolation & hosting | Standard Cloud: AWS or Azure, EU regions (Frankfurt, Ireland) for European customers; per-tenant PostgreSQL DB and runtime isolation. On-premise option: Docker / Kubernetes containers, $69,000 one-time enterprise license. | Mature SaaS isolation on Salesforce Platform. — Global datacenter regions. On-premises deployment is rare for the core managed package. | Program-dependent |
|---|
| Margin & cost protection | Vendor does not access internal margin or cost data — data minimization reduces the attack surface. Discount threshold approvals (e.g. > 15% → manager sign-off) are available as an add-on scope item. Optional Admin Portal add-on allows manager review before CRM push. | Field-level security and RBAC on Salesforce objects. — Mature, built-in approval frameworks for discount governance are a documented strength of Salesforce CPQ (SteelBrick) programs. | Lean Salesforce CPQ |
|---|
| Built-in analytics | Conversation funnel analytics (stage transition rates: Intro → Needs → Selection → Budget → Contact), demand-sensing signals, and data export. Tracks what buyers ask, which configurations they build, and where they drop off. | Quote operations reporting on CRM objects. — Conversation funnel analytics are not a feature of the legacy CPQ package. | Lean Talkulate AI CPQ |
|---|
| Outcomes & commercial |
| Quote cycle | Reference deployment (US server reseller, ~3,400 SKUs): standard quotes that previously took about 1–2 days were routinely produced in about 15 minutes after go-live — SteelBrick scope and Communities projects will change your timeline. | Quote cycle varies widely by implementation and catalog complexity. — No matched published study available for direct comparison. | Lean Talkulate AI CPQ |
|---|
| First-pass accuracy | See the reference deployment band below. | Unknown without a matched study on equivalent catalog complexity. | Lean Talkulate AI CPQ |
|---|
| Quote capacity | See the reference deployment band below. | Capacity uplift not published for a matched use case. | Lean Talkulate AI CPQ |
|---|
| Conversion uplift | A different buyer-facing pilot (not the server-reseller program) reported higher web conversion and fewer prospects leaving while waiting for quotes, compared with that pilot’s starting metrics — validate on your site, not as a SteelBrick benchmark. | Conversion uplift from deploying a buyer-facing CPQ surface is not published. — Rep-console CPQ does not directly address top-of-funnel web conversion. | Lean Talkulate AI CPQ |
|---|
| RFQ unit economics | Example RFQ cost bands (illustrative): ~$230–$460 for a manual complex RFQ vs up to about $12 when high-volume self-serve is running — not a Salesforce license quote; see Talkulate AI CPQ pricing / ROI. | Salesforce CPQ (SteelBrick) is priced on seats and SI scope, not per RFQ. — Per-quote cost scales with headcount, not with quote volume — additional capacity means additional hires or SI scope. | Lean Talkulate AI CPQ |
|---|
| Pricing model | One-time cloud implementation ($18,400) + monthly infrastructure fee ($1,725 / month, includes 600 dialogs) + per-dialog overage (see Talkulate AI CPQ pricing page) + integration hours ($115 / hour, scoped per tenant). Enterprise on-premises: $69,000 one-time license. | Legacy Salesforce CPQ (SteelBrick) list pricing is not published on standard Salesforce pricing grids — contact Salesforce for a quote. Revenue Cloud (separate product) lists $150 / $200 per user / month billed annually plus a CRM license prerequisite. Premier Success Plan: 30% of net license fees (published on Revenue Cloud pricing page). Implementation and migration scope is partner-led with no public fixed rate card. | Program-dependent |
|---|