Building a CPQ Platform in 50 Days

The Problem

Building a quote at the company was a multi-hour, multi-tool process that started over every time.

A sales rep would open a pricing spreadsheet to pull current numbers, then manually type preliminary pricing into a Word document template just to show a prospect early-stage numbers. Once negotiations concluded, the real work began. Building a finalized quote required three separate documents (an MSA, a Statement of Work, and a product table), each assembled individually. The order form lived in yet another Word template where the rep manually selected discounts, added or removed line items, and included or excluded products line by line.

That document then had to be saved as a PDF, combined with the SOW, uploaded to DocuSign, and routed for signatures. Before any of that could happen, the deal needed Deal Desk review: a back-and-forth chain over email and Slack involving multiple stakeholders across sales leadership, finance, and deal operations.

At high volume this process consumed two to three hours per deal after numbers were agreed. Even straightforward quotes took one to two hours. For reps processing five deals per week at end of quarter, that translated to up to 15 hours of administrative work weekly, time not spent selling. Across the team the productivity cost was significant, not as an edge case but as the standard operating procedure for every deal that closed.

There was no centralized pricing logic. No automated approval routing. No consistent contract output. Just a sequence of manual steps that depended entirely on individual reps executing a fragile process correctly, every time.

The Business Case

Before committing to a build, Jon ran a formal cost analysis comparing in-house development against commercial alternatives.

Leading enterprise CPQ vendors weren't cheap. Evaluated solutions ranged from $100–$150 per user per month, with one-time professional services fees between $15,000–$20,000. Across 25 users that translated to $165,000 in year one and approximately $150,000 annually thereafter. But the software cost alone understates the true comparison. Commercial CPQ platforms require a dedicated resource to manage configurations, support users, and maintain the platform, typically a Deal Desk Analyst at $120,000 per year in total compensation.

The full five-year cost picture for a commercial solution:

The in-house alternative: approximately $20 per month in hosting fees and $500 per year in platform management tooling. No incremental headcount. The platform was built and maintained by someone already embedded in the GTM team whose salary was already accounted for. Five-year cost difference: approximately $750,000.

The productivity analysis modeled four deal volume scenarios:

Even at worst-case deal volume the recovered selling capacity nearly covered the full annual cost of a commercial solution. At the team's actual operating volume the productivity value exceeded seven figures annually.

The decision to build wasn't instinct. It was arithmetic.

The Approach

Jon evaluated commercial CPQ options before finalizing the build decision. The evaluation confirmed what the cost analysis suggested: available tools were either over-engineered for the company's current scale or insufficiently flexible for their specific deal complexity. Building made more sense than buying.

A formal product brief defined the scope: automated quote generation from CRM data with zero manual document manipulation, integrated approval workflows, seamless e-signature, and real-time deal visibility for all stakeholders. Success metrics were explicit:

• Reduce time-to-quote by 90–95%
• Increase AE selling time by 10+ hours per week
• Achieve full user adoption within the first quarter
• Reduce quote-related errors by 75%
• Decrease average deal cycle time by 15%

Build milestones were sequenced deliberately: CRM and document integrations first, then security review, then UAT with a small cohort of AEs, then stakeholder demo, then full rollout at the sales kickoff.

Using AI-assisted development tools including Claude, Replit, and ChatGPT, Jon built the platform himself, without engineering resources, without a dedicated product team, and without drawing on existing company infrastructure beyond what the integrations required.

The domain knowledge that made this possible came from five years of living the exact problem the platform was built to solve.

The Build

The platform went from zero to production in 50 days. Core components included:

Dual Pricing Engine

Supporting both seat-based and consumption-based models, with a dynamic SKU catalog, bundle triggers, dependency auto-addition, and SKU mutual exclusion enforcement to ensure quote accuracy across deal types.

Multi-Level Approval Chain

Spanning manager through CEO, with re-approval triggers on quote changes and optimistic locking to prevent concurrent edit conflicts, a critical resilience pattern for high-value transactions where two people editing the same quote simultaneously could corrupt pricing or approval state.

LLM-Powered Quote Assembly

Using Groq Llama 3.3 70B, enabling sales reps to assemble quotes through natural language input. Supporting AI features included pricing rationale generation and automated customer and billing data lookup from Salesforce, reducing manual data entry and accelerating quote creation for complex deals.

Six-Layer LLM Security Pipeline

Covering input sanitization, prompt injection detection, prompt hardening, PII redaction, anomaly scoring, and human review gates, with comprehensive guardrail event logging for auditability. Security was not an afterthought; it was architected into the AI layer from the start.

Document Generation

Via Google Docs and PDFKit for order forms and MSA exhibits, with automatic template selection based on deal type and term length. A token-based Deal Room Portal allowed secure sharing of approved quotes, PDFs, and presentations with external stakeholders.

Salesforce Integration

Via OAuth for both production and sandbox environments, with a dry-run preview and field-level selection before any write-back, a deliberate design choice to protect data integrity in the CRM as the single source of truth.

Platform Security

Including Google SSO with domain-restricted access, role-based access control, TOTP two-factor authentication, and a circuit breaker pattern for external service calls to maintain stability under load.

Analytics Layer

Integrated with Mixpanel for usage event tracking, deal velocity visibility, and discount trend monitoring, giving sales leadership the pipeline insight the manual process never could.

Contract Verification

A contract verification layer uses computer vision and document parsing to compare signed order forms against CPQ source records after signature. Discrepancies trigger a Deal Desk alert requiring human review, eliminating the manual line-by-line verification that previously happened at the end of every deal cycle, while preserving human judgment for cases where CPQ itself may have been the source of error.

The CPQ was the anchor but not the only output of this period. Jon designed and launched eight additional internal tools during the same period: a document generator, PDF editor, e-signature tool, AI agent builder, conversational intelligence automation tool, load tester, user journey tester, and slide automation tool, compressing a tooling backlog that would typically require dedicated engineering resources.

He also won an internal engineering hackathon during this period, earning a product development green light.

The Result

Quote creation time dropped by 95%. Sales reps could generate and send a standard quote in under five minutes. Non-standard deals that previously required days of Slack back-and-forth moved through automated approval routing with clear escalation paths. The platform handled all of the company's enterprise deal flow from day one and was adopted by 25 users across the GTM team, hitting the adoption target within the first quarter.

To drive adoption, a contextual sales guide was built directly into the platform: a sidebar that highlights relevant documentation as users hover over each form field, covering quoting workflow, pricing logic, approval rules, document generation, and an FAQ. Rather than supplementing the tool with external training materials, the enablement layer was embedded in the product itself.

Against the original success metrics:

• Time-to-quote reduced by 95%; target was 90–95%
• Full user adoption achieved within first quarter
• Approval back-and-forth eliminated through automated routing
• Consistent contract output replacing error-prone manual assembly

AI Architecture Decisions

One of the core product decisions in the CPQ build was determining where AI actually belongs in the quoting pipeline, and where it doesn't.

The easy path would have been to route everything through an LLM and let the model handle the full flow. That approach introduces unpredictability at exactly the wrong moments. Pricing math has to be exact. Approval thresholds have to be deterministic. A model that occasionally rounds differently or misreads a discount structure isn't a minor bug; it's a commercial liability.

The architecture reflects a deliberate principle: use AI where natural language understanding adds genuine value, use deterministic code where accuracy is non-negotiable.

The LLM handles what it's good at: extracting customer name, agent count, products, quantities, discounts, and term length from a natural language prompt, and interpreting edit instructions on an existing quote. Everything that touches commercial accuracy (pricing calculations, tier selection, approval routing, dependency resolution) runs through deterministic code with no model involvement.

The result is a system that feels conversational to the user and behaves like a financial system underneath.

Platform Evolution

The CPQ shipped in 50 days. What happened after is equally telling.

17 versions across 78 days, built and maintained by one person, in parallel with supporting a 25-person GTM team.

The platform didn't stop at MVP. Each version responded to real user feedback, new security requirements, or capabilities the sales team needed to move faster. The changelog is the product roadmap, and it's still moving.

The Insight

Domain expertise doesn't replace good product process; it accelerates it. The vendor evaluation still happened. The user research still happened. The requirements still got validated against real workflows. But five years of living the problem meant every step of that process moved faster and landed more accurately than it would have for someone coming in cold.

AI tools provided the development velocity. The domain knowledge determined what to build with it. The combination produced in 50 days what a traditional product-engineering cycle would have taken months to deliver, at a fraction of the cost of the commercial alternative it replaced.

And it didn't stop there. The platform that shipped in December is still shipping today.