How to

How to build a CPQ tool

Quotes get built in a spreadsheet copied from the last one, with a discount nobody approved and a price list from two quarters ago. Here is the model behind a configure, price, quote tool, the prompts to build it, and what it takes to run it.

The short answer

A CPQ tool is four parts: a price book that is the only source of list prices, a quote builder that configures products and quantities from it, pricing rules that check every discount as it is entered and say who has to approve it, and a quote document generated from the approved version. The hard part is not the maths, it is keeping every quote on the current price book and inside the rules without slowing the seller down. Build it so the right quote is the easiest one to send.

configure-price-quote.helix-app.ai

Configure, Price, Quote

38

Quotes in flight

2.6M

Total quoted

14%

Average discount

5

Expiring this week

LineListQtyDiscountRule
Professional plan38 / device1,20012%Within guardrail
Platform fee24,000 / yr10%Within guardrail
AI add-on9 / device1,20025%Needs VP, over 20%
Gateways640408%Within guardrail
Handhelds1,15012015%Needs manager, over 10%
A sketch of the pricing step. The last column is the point: each line says whether it clears and, if not, which rule it breaks and who has to approve it, before anything is submitted.

What matters here

  • A CPQ tool is four parts: a price book, a quote builder, pricing rules with an approval path, and a quote document.
  • The price book is the only place list prices live. A quote copies the price at the moment it is built, so a later price change never rewrites a quote already sent.
  • Check discounts as they are typed, and say plainly which rule a discount breaks and who has to approve it. A seller should never find out at submission.
  • Show the margin effect next to the discount. A seller who sees what a discount costs asks for less of it.
  • Version every quote. What changed between v2 and v3 is the first question a deal desk or a customer asks.
  • Quotes become contracts, so SSO, scoped access and a record of every approval are part of the build, not an afterthought.

Who this is for

You run revenue operations, a deal desk or sales finance. You know your price book and your discount rules. What you want is quotes that are right the first time, discounts that are approved before they are offered, and a quote document that looks like your company sent it.

How it works in practice

What a seller and an approver each do, and why the rules check as you type.

  1. 1

    A seller starts from the deal

    Pick the account or deal and the quote starts with its devices, plan and term, so nobody retypes what the CRM already holds.

  2. 2

    Configure from the price book

    Choose the plan, quantities by product, add-ons and term. Prices come from the current price book and volume tiers apply on their own.

  3. 3

    Price with the rules in view

    Line and quote discounts, the yearly fees, total contract value and the margin effect, with each rule checked as the numbers change.

  4. 4

    Within the rules, it is ready to send

    A quote inside every guardrail is approved on submit. Most quotes should take this path.

  5. 5

    Beyond them, it goes to the deal desk

    The request carries the full economics and the rule it breaks, so the approver decides without opening another system.

  6. 6

    The customer gets a document, not a spreadsheet

    A branded, printable quote with line items, terms, validity and both parties' names, generated from the approved version.

What a CPQ tool is made of

A CPQ tool is not a spreadsheet with a logo on it. It is four parts, and the first one decides whether the others can be trusted.

A price book

Products, plans and add-ons with list prices, units and volume tiers, kept in one place and edited by one team. Every quote reads from it.

A quote builder

A step-by-step flow: configure the products and quantities, price them, review the document, submit. Each quote is versioned, and each version keeps the prices it was built with.

Pricing rules and an approval path

The discount guardrails by product, depth and deal size, checked on every change, with the approver each breach needs. Anything beyond them becomes a deal desk request.

A quote document

A branded, printable document generated from the approved version: line items, totals, terms, validity date, and the seller's and customer's names.

These prompts start from a Helix project, which is what handles sign-in, credentials and hosting. Start with Helix

The prompts

Paste these into Claude Code, Codex or Cursor in order. Each one leaves you with something that runs, so you can stop after any step.

  1. The price book and the quote

    One source of list prices, and quotes that keep their own copy.

    Create a Helix app: a configure, price, quote tool.
    
    Start with a read-only price book: plans priced per device per month, a
    yearly platform fee, add-ons, and hardware with one-off prices and volume
    tiers. Keep it in one editable file.
    
    A quote belongs to an account or a deal, and has an owner, a term, a
    status (draft, awaiting approval, approved, sent, accepted, lost or
    expired) and a validity date. Copy each line's list price onto the quote
    when it is built, so changing the price book never rewrites a quote that
    has already gone out.
    
    Give me a list of quotes I can search and filter by status, owner and
    account.
  2. The quote builder

    Configure and price in one flow, with the rules checked as you type.

    Now the quote builder as a step-by-step wizard.
    
    Step 1, configure: pick the account or deal, which fills in what it
    already knows, then the plan, the number of devices by hardware type,
    add-ons and the term.
    
    Step 2, price: list price per line, quantity, line and quote discounts,
    the yearly platform fee, recurring ARR, the one-off hardware total and
    total contract value. Show the margin effect of the discount next to it.
    
    Keep the discount guardrails in one editable file, by product and by
    deal size. Check every line as the numbers change, and say plainly which
    rule a discount breaks and who has to approve it.

    Worth knowing. Saying which rule breaks before submission does more for discount discipline than any policy document.

  3. Submit, approve and version

    Most quotes clear on their own. The rest go to the deal desk with the context to decide.

    Step 3 previews the quote document. Step 4 submits it.
    
    A quote within every guardrail is approved on submit and marked ready to
    send. A quote beyond them creates a deal desk request carrying the full
    economics, the rules it breaks and the approvers it needs, and the quote
    waits on that decision.
    
    Saving changes to a submitted quote creates a new version. Show the
    versions on the quote page with what changed between each, and the
    approval history with who decided what and when. Let me mark a quote as
    sent, accepted or lost.
  4. A quote document worth sending

    The part the customer actually sees.

    Generate the quote document from the approved version as a printable
    page: our logo and name, the customer and the seller, line items with
    quantities, prices and discounts, the recurring and one-off totals,
    payment terms, the term, and the date the quote is valid until.
    
    Make it look like a polished commercial document, not a screen from the
    app. It should print cleanly to PDF on one or two pages.
  5. Add a quote assistant agent

    An agent where the quote already lives, which drafts and never sends.

    Add a Helix agent called the quote assistant. On a quote, a seller can
    ask it to draft the case for the deal desk and a cover email for the
    customer.
    
    Give it read-only tools for the quote, the account, the price book, the
    guardrails and comparable quotes that were approved before. The case
    should say why the discount is justified using those facts, and say
    where the facts are thin.
    
    It never submits or sends anything. Show its draft with a button that
    copies it into the justification field, and the seller decides whether
    to use it.

    Worth knowing. The agent reads through tools that only read. The seller confirms every change, so what reaches the deal desk is still the seller's case.

  6. Connect it to real systems

    The step that turns a working prototype into something with your data in it.

    Now connect it to the systems we actually run, so it works on real data
    rather than the rows you seeded.
    
    Anything in angle brackets is a placeholder. Swap it for whatever we use
    instead, and have the app name the connection it wants rather than assume
    a vendor, so changing my mind later is a config change and not a rewrite.
    
    <Salesforce>. Read the opportunity, account and contacts to start a
    quote, and write the quote total and status back to the deal.
    
    <NetSuite>. Read item costs, so the margin effect of a discount is
    calculated rather than guessed.
    
    <DocuSign>. Send the approved quote for signature and read back when it
    is signed.
    
    <Stripe>. Create the subscription from an accepted quote, so billing
    starts from exactly what was signed.
    
    <Okta>. Read the manager chain, so the approval path comes from the real
    org rather than a list of names.
    
    <Snowflake>. Land every quote version and approval beside closed deals,
    so discount and win rate by segment become a query.
    
    Only write where I have said to write. Everything else is read only.

    Worth knowing. Every name in angle brackets is a placeholder for whatever you run. Helix holds the credential as a workspace authentication, so the app references an alias and never the secret itself.

  7. Ship it

    The last step of every build: a URL, and the right people on it.

    Deploy my app.

    Worth knowing. Your assistant runs helix deploy underneath and the app comes back as a URL. Set Access Control before sharing: sellers see their own quotes, the deal desk sees everything, and only revenue operations can edit the price book.

What it connects to

A CPQ tool sits between the CRM and billing. It reads the deal, and what it produces becomes an order.

  • Salesforce

    Read the opportunity, account and contacts to start a quote, and write the quote total and status back to the deal.

  • NetSuite

    Read item costs, so the margin effect of a discount is calculated rather than guessed.

  • DocuSign

    Send the approved quote for signature and read back when it is signed.

  • Stripe

    Create the subscription from an accepted quote, so billing starts from exactly what was signed.

  • Okta

    Read the manager chain, so the approval path comes from the real org rather than a list of names.

  • Snowflake

    Land every quote version and approval beside closed deals, so discount and win rate by segment become a query.

Each line says whether the app reads, writes or both. Anything not described as writing should be read only.

Named systems are the ones most teams actually run, not a list of the only ones that work. Swap in whatever you use.

Each connection is an authentication in your Helix workspace, referenced by alias. The app names the connection it wants and never holds the credential, so nothing here ends up in your code and any of it can be rotated or revoked without a redeploy.

Running it for real

The build gets you a working quoting tool. What it produces becomes a contract and an invoice, so it needs to be run properly.

AI Deployment

Get it to a URL people can open

One command takes the app from your assistant to a live address, so sellers get a link rather than instructions for running it locally.

App Security

Put your identity provider in front of it

Sellers sign in with their existing account, and discount authority follows real roles rather than whoever has the spreadsheet.

App Security

Connect your systems with managed credentials

Reading deals and costs and creating subscriptions needs real access. Granting it to the app rather than pasting a key into it means it can be rotated or revoked without a redeploy.

App Registry

Put a name on it

Every app carries a named owner and an entry IT can see, so the quoting tool does not become nobody's problem when the person who built it changes role.

Questions people ask

What is a CPQ tool?

Configure, price, quote: a tool that builds a quote from your price book, prices it inside your discount rules, routes anything beyond them for approval, and produces the quote document a customer signs.

What should a CPQ tool include?

A price book that is the only source of list prices, a quote builder, pricing rules with an approval path, and a quote document generated from the approved version. Versioning each quote is what makes the history readable.

How should discount rules work in a CPQ tool?

Checked on every change rather than at submission, by product and by deal size, with the approver each breach needs shown next to the line. Show the margin effect too, because a seller who sees what a discount costs asks for less.

How is a CPQ tool different from a deal desk app?

A CPQ tool builds and prices the quote. A deal desk app decides the exceptions. The quote tool sends anything beyond the guardrails to the deal desk, with the economics already attached.

Can an AI agent help with quotes?

Yes. A Helix agent can read the quote, the price book and comparable approved quotes through read-only tools, then draft the case for the deal desk or a cover email. Keep it read only and let the seller decide what to use.

Can I build this without an engineering team?

Yes. The prompts here are written for Claude Code, Codex or Cursor and stage the build. The judgement calls are your price book and your discount guardrails, and neither is something a tool can decide for you.

Tray.ai

Integration and automation guides

Build the integrations that keep it fed

An app is only as good as the data in it. These build the integrations and automations that keep this one current, on the Tray platform. Same kind of guide, same kind of prompts.

Last reviewed November 2026.

Build it, then run it properly

Helix runs the apps and agents you build. Deploy what you build, put SSO in front of it, connect it to your systems with managed credentials, and give it a named owner.

Want to talk to someone first? Contact us