
Ask an industrial sales team what slows them down and the answer is almost always quoting. A single quote can mean pulling a customer price list, checking material costs, configuring a product with engineering constraints, confirming a lead time and getting a manager to sign off a margin. Spread across tools, that takes days.
In CRM manufacturing projects, quote-to-order is the workflow that decides whether the system gets used. This post looks at it from the engineering side: how to structure a configure-price-quote (CPQ) layer that reads real data and hands clean orders to the ERP.
The shape of the flow
configure -> validate -> price -> margin check -> lead time
-> approval (if needed) -> document -> customer acceptance
-> ERP sales order -> order no. written back to CRM
Each stage should be a separate, testable component. The common mistake is one large "quote service" that mixes engineering rules, pricing and approvals, which nobody can change safely.
Configurator: rules as data
Highly configurable products are where generic CPQ tools break. Encode engineering rules as data, owned by engineering, versioned and testable.
product: pump-housing
version: 14
options:
material: [cast_iron, ss316, duplex]
flange: [DN50, DN80, DN100]
coating: [none, epoxy, ceramic]
rules:
- if: { material: duplex }
require: { coating: none }
reason: "Duplex ships uncoated"
- if: { flange: DN100 }
forbid: { material: cast_iron }
reason: "DN100 not cast in iron above PN16"
derive:
bom_variant: "{material}-{flange}-{coating}"
Keep a reason on every rule so the UI can explain why an option is unavailable. Store the rule version on each quote line, so a quote from last March can be reproduced even after the rules change.
Pricing pipeline
Price as an ordered pipeline of small steps over ERP-sourced data, never hand-typed numbers:
base price (ERP item / BOM cost-plus)
-> customer price list or contract price
-> volume break
-> raw material surcharge (index-linked, dated)
-> option uplifts
-> manual adjustment (logged, reasoned)
= net price, with cost and margin per line
Every step writes a trace entry. When a customer disputes a price, sales should be able to show exactly how it was built.
Margin-based approvals
Discount-percentage approvals are a weak proxy in manufacturing, because cost varies by configuration and material. Approve on margin instead.
def approval_level(quote) -> str:
m = quote.margin_pct # computed from line costs
if m >= policy.target_margin: return "none"
if m >= policy.floor_margin: return "sales_manager"
if m >= policy.hard_floor: return "commercial_director"
return "blocked"
Run the policy per line and per quote, since one deeply discounted line can hide inside a healthy total. Strategic deals sometimes justify low margin, so the approval request should carry context: account history, volume, competitor notes.

Capacity-aware lead times
Quoting a standard lead time the plant cannot meet costs more trust than losing the deal. Compute lead time from data:
-
Stock on hand and allocations from the ERP for stocked items.
-
Material availability and supplier lead times for make-to-order lines.
-
Load on the relevant work centres from the planning system or MES.
-
A buffer per product family, tuned against actual delivery performance.
Show the promise as a date with a confidence label, and refresh it when a quote is revived after weeks of silence. Quotes should carry a validity period tied to both price and lead time.
Document generation
Generate quote documents from templates with the customer's required format, terms and incoterms. Store the rendered document alongside the structured quote so what the customer saw is always recoverable.
Handoff to ERP
When the customer accepts, the CRM emits an acceptance event. An integration layer revalidates items, prices and credit status against the ERP, then creates the sales order using an idempotency key derived from the quote ID. The ERP order number goes back to the CRM quote and opportunity. Failures land in an exception queue with a readable reason, never a silent retry loop.
Where AI fits
Two places, both supervised. Upstream, models can extract line items from RFQ PDFs and emails and prefill the configurator for an estimator to review. Downstream, models can suggest which quotes are at risk of going stale based on customer behaviour. Neither should set a price or promise a date.
Build or buy the CPQ layer?
If your options are simple, a packaged CPQ is fine. If your products carry real engineering rules, a custom configurator that engineering owns will outlast any attempt to squeeze those rules into a generic tool. TechCirkle's custom software development team builds this layer for industrial clients, usually alongside an existing CRM.
For the rest of the picture, including ERP ownership, partner portals, field service and a phased roadmap, see the full TechCirkle guide to CRM for manufacturing.
Frequently Asked Questions
Why approve on margin rather than discount?
Because cost varies with configuration and materials, a fixed discount can be profitable on one quote and loss-making on another. Margin reflects the real commercial risk.
Who should own configurator rules?
Engineering, with rules stored as versioned data and every quote line recording the rule version it was built with.
How do you keep quotes reproducible?
Store rule versions, price-list versions, surcharge index dates and a trace of each pricing step on every quote line, plus the rendered document.
How should lead times be calculated in a manufacturing CPQ?
From stock, material availability, supplier lead times and work centre load, with a buffer tuned against actual delivery performance.
How do you avoid duplicate ERP orders from accepted quotes?
Revalidate in an integration layer and create the order with an idempotency key derived from the quote ID, writing the ERP order number back to the CRM.
Can AI generate manufacturing quotes?
It can prepare them, by extracting RFQ data and prefilling configurations, but prices and delivery promises should come from rules, ERP data and human approval.