“Why did this quote take nine days?” The room goes quiet. Someone mentions engineering. Someone mentions pricing. Someone mentions waiting for approvals. Nobody mentions the real bill you just paid: friction cost.

Every invalid configuration, every delayed quote, every miscommunication adds up. Not as big bangs, but as sand in the gears. It looks like normal work. It feels like diligence. It quietly kills velocity.

I see it in almost every complex sales organization I work with. The product is configurable, the price depends on choices, and the quote needs to be right the first time. When it isn’t, the deal doesn’t collapse. It just drifts. That drift is expensive.

CPQ doesn’t fail loudly. It fails quietly - through workarounds.

The Hidden Cost of Friction in Quotes

Friction cost isn’t a line item. It’s the sum of small losses that never show on a report:

  • Invalid configurations that trigger a polite “Can we schedule a quick call?”
  • Re-quoting after someone finds a dependency buried in a PDF
  • Pricing emails that loop for days because discount rules aren’t clear
  • Docs chasing - “Can you send the updated drawing with the right flange?”

Analyst research has been consistent on this for years: complex B2B buying is non-linear with more stakeholders and more loopbacks. Gartner’s work on buyer enablement and consensus building explains why a single delay creates ripple effects across committees. Forrester has written about the need to remove effort from the buyer’s journey. McKinsey links cycle time to win probability - the longer you take, the more momentum slips to competitors. You don’t need their numbers to feel the truth of it in your pipeline.

Friction isn’t just time. It’s confidence. When a buyer receives three versions of the same quote, they start to wonder if your delivery will be any clearer. When your own salesperson has to cross-check five rules manually, they start to wonder if the system helps them think, or just click.

Here’s the reframe: this is not a system speed problem. It’s a correctness and explainability problem. If you remove rework at the source, the process speeds up naturally.

CPQ is not about automation - it’s about correctness.

I call CPQ a GPS for complex sales for a reason. You tell it where you want to go (customer need), and it guides you through a valid route (product + price), avoiding dead ends (invalid combinations). No guessing, no backtracking. Less friction, more momentum.

Why This Keeps Happening in CPQ Programs

Most teams think friction comes from missing features or slow UI. In my experience, the root cause sits elsewhere:

1) Product truth lives in too many places. Engineering drawings, old Excel calculators, tribal knowledge, outdated price books. The CPQ inherits the mess and politely multiplies it. If the beams aren’t straight, the building won’t be either.

2) Rules exist, but they aren’t explainable. If a salesperson can’t see why a choice is blocked or a price moved, they won’t trust it. According to Gartner’s research on sales tech adoption, systems that can’t justify outcomes struggle in the field. That matches what I see every week.

3) Ownership is vague. Nobody owns the decision logic end-to-end, so changes get bolted on. The model grows sideways. Two years later you’re paying the interest on every shortcut.

4) AI expectations are upside down. AI is powerful, but it doesn’t replace product logic. Without constraints, AI gives fluent guesses. With explicit rules and tests, it becomes a fast apprentice. Forrester and others emphasize this: assistance beats autonomy in complex B2B.

If the system cannot explain itself, it will never be trusted.

The mechanism to reduce friction is simple, not easy: make the product truth explicit, testable, and visible where selling decisions happen. When logic is structural and pricing intent is clear, everything else accelerates. That’s why I put correctness and explainability ahead of workflow and UI. Fancy screens can’t fix unclear rules.

Where does CPQ actually remove friction?

  • Configuration constraints: Hard stops and guided choices prevent dead ends before they happen.
  • Transparent pricing logic: A visible price waterfall and discount guardrails reduce “why is it this price?” debate.
  • Document generation tied to choices: If a flange changes, the drawing and spec change with it - immediately.
  • Guardrails for approvals: Only the exceptions travel up the chain. Normal deals flow.
  • AI on top of rules: Summarize rationale, draft proposals, surface similar deals - all constrained by the beams.

AI does not replace logic - it depends on it.

Practical Rules and Moves That Cut Friction Fast

Here are rules of thumb I use with teams selling complex products. They’re simple tests you can apply this week.

  • Block mistakes early - don’t clean them up later. If a configuration can’t be built, the UI should not allow it. Example: enforce coupling between power option and motor size at selection time, not in a downstream validator.
  • One rule, one sentence. If a rule needs a paragraph to explain, split it. Example: separate compatibility rules from commercial rules. Mixing them creates “rule soup” - the anti-pattern that slows every change.
  • Make pricing explain itself. Show list, adjustments, discount policy, and pocket price transparently. If a sales manager can’t review a deal in 60 seconds, your waterfall isn’t clear enough.
  • Prefer modules over exceptions. If you keep adding “just this one” override, you’re paying future interest. Example: instead of exceptions for regional bundles, create a regional module with explicit options and prices.
  • Test logic like code. Every time a rule or price changes, a small automated suite should prove you didn’t break yesterday’s quotes. No test, no deploy.

And one named anti-pattern to watch: Sidecar Spreadsheets. If critical calculations live in an Excel file next to CPQ, you’ve outsourced correctness. Those files drift fast. Pull them in or retire them.

What can you do immediately, without a big project?

  • Instrument friction: Add three fields to your quote object for the next 30 days - “Rework count,” “Engineering touches,” and “Approval hops.” You’ll get a baseline fast. You can’t reduce what you don’t see.
  • Pick one workaround and remove it: Choose the single most common manual step and fix it end-to-end. Ship the smallest change that kills it permanently.
  • Run a trust review with sales: Sit with three reps. Ask where the system feels like guessing. Those spots are where explainability is missing. Fix the explanation before the feature.

Adoption is the only metric that matters.

Who wins when friction drops? Teams that make product truth explicit and govern change lightly. Quotes get out faster. Fewer loops. Less reliance on heroes. Buyers feel the clarity. Who drifts into irrelevance? Teams that keep adding exceptions and blame “user resistance” when people route around the system.

If you’ve worked with CPQ long enough, you’ve seen both paths. The difference isn’t technology. It’s choices about what to make explicit and what to make optional. Get the beams right and the building holds, even as products and markets change.

The beautiful part is compounding. Every rule you clarify, every dependency you surface, every approval you avoid - it all stacks. Your quoting process starts to feel like a GPS. You still fly the plane, but you stop flying it manually.

Friction cost is real, and it’s optional. The shortest path to a correct quote is the only path that compounds.