A sales rep opens your CRM, pulls up a deal, and starts building a quote. Thirty minutes later, they're toggling between tabs, copying pricing from a spreadsheet, and chasing an approval through Slack. Their quoting tool is technically available. It just doesn't work the way anyone expected.
This is a common pattern, and it traces back to how the CPQ was implemented—not the software itself. When quoting workflows aren't mapped before configuration begins, the tool inherits the same gaps that existed before.
The problem is that most implementations skip the foundational work that makes integration actually function.
Your CRM stores customer data. Your CPQ calculates pricing. When these two systems don't share a common source of truth for pricing logic, every quote becomes a judgment call.
Reps end up referencing a spreadsheet for discount thresholds. Finance maintains a separate document for margin floors.
This disconnect creates what looks like a CPQ problem but is actually a data governance problem. The moment pricing rules live in multiple places, you've introduced room for error at every step of the quote.
Pricing drift happens gradually. A promotion gets extended but the price book doesn't update. A rep negotiates a one-time discount that becomes a template for future deals. A new product launches without a defined margin floor.
By the time anyone notices, the drift has accumulated across dozens of quotes. Your CPQ shows what it was told to show—but the rules it's enforcing are outdated.
Approval steps are where many CPQ implementations stall. The quote is built, the pricing looks right, but now it needs sign-off before it goes to the customer.
When approvals route through email or messaging apps, the process loses visibility. Managers approve deals without seeing the margin impact. Requests get buried in inboxes. Reps follow up manually, adding days to the cycle.
The workflow itself may be documented somewhere. But if the CPQ doesn't enforce it automatically, approvals become informal handoffs that no one can audit.
A manager receives an approval request with a deal name and a discount percentage. What they don't see is the deal history, the margin after discount, or whether the customer already received a similar concession last quarter.
Without context, approvals become binary decisions made under time pressure. The manager approves because the rep says it's urgent. The pattern repeats until margin erosion becomes visible in quarterly reports.
CRMs are designed to manage relationships, not configure products. When your sales process involves bundles, tiered pricing, or calculated line items, the native quoting tools hit their limits quickly.
Reps start working around the system. They build quotes in spreadsheets, paste them into the CRM, and hope nothing changes before the customer signs. Each workaround adds time and introduces potential for error.
Quotivity addresses this by embedding configuration logic directly into the HubSpot deal record. Reps select products, apply rules, and generate quotes without leaving the CRM—because the CPQ lives where the work happens.
Manufacturing sales often involve product configurations that require engineering validation. A quote might include components that need to ship together, accessories that are required for certain SKUs, or pricing that varies by volume tier.
Generic CPQ tools treat these as edge cases. For manufacturers, they're the core of the quoting process. When the CPQ can't handle configuration complexity, reps either slow down to get it right or speed up and get it wrong.
The failure often isn't visible until reps stop using the system. By week three, half the team is back to spreadsheets. By day 90, the CPQ is technically live but practically abandoned.
This traces back to five decisions that either weren't made or were made wrong before anyone touched the configuration:
If reps aren't quoting primarily in the system by day 90, the implementation didn't fail at day 90. The failure happened at day one.
The signs of a working integration aren't dramatic. Quotes go out faster. Approvals route to the right person automatically. Reps stop asking where to find the latest price list.
The signs of a failing integration are also subtle—until they're not. Reps toggle between systems. Finance discovers margin issues after deals close. Managers approve quotes they never fully reviewed.
A functional CPQ-CRM integration means the quoting workflow lives inside the CRM, not alongside it. Quotivity achieves this by building directly into HubSpot, so every quote, approval, and document stays connected to the deal record.
Before configuring any CPQ tool, interview the people who actually touch quotes. Find out where they get pricing data. Ask how approvals really happen—not how they're supposed to happen.
Document the current workflow with enough detail to expose the gaps. You'll likely find that the policy and the practice are different. Building a CPQ around the policy means the tool will enforce rules that reps already work around.
The right move before implementation starts is to map your actual quoting behavior, not your intended process.
CPQ software breaks down inside CRM systems for predictable reasons. Pricing rules fragment across spreadsheets. Approvals happen outside the system. Configurations exceed what the native tools can handle.
The fix isn't more software. It's structural: map the workflow, centralize the pricing logic, and build approvals directly into the quoting path. When the process is right, the software works.
Quotivity builds CPQ natively into HubSpot, so reps quote from the deal record with guardrails that protect margin and approvals that route automatically. For more on how this works in practice, get a demo.
CPQ fails inside CRMs when the quoting workflow wasn't mapped before implementation. Pricing rules end up scattered across spreadsheets, approvals route through email instead of the system, and reps revert to old habits because the tool doesn't match how they actually work.
The main cause traces back to skipping foundational work. Most failures happen because teams configure the software before documenting their current quoting process. By day 90, reps abandon the CPQ because it enforces workflows that don't match reality.
Quotivity prevents breakdowns by building CPQ directly into the HubSpot deal record. Reps quote without switching systems, pricing rules enforce automatically, and approvals route with full deal context. The quoting workflow lives where the work happens.
Signs include reps toggling between systems, approvals happening in Slack or email, pricing data living in spreadsheets outside the CRM, and finance discovering margin issues only after deals close. If the CPQ isn't the primary quoting tool, the integration isn't working.
Approval workflows break down when they route outside the system. Managers approve deals without seeing margin impact or deal history. Requests get buried in inboxes. Quotivity fixes this by embedding approval routing directly into the quote, with automatic notifications and full context.
Native CRM quoting tools handle simple transactions well but struggle with bundles, calculated pricing, and tiered configurations. Manufacturing and SaaS teams often need CPQ software that embeds configuration logic directly into the CRM to avoid workarounds.