How to Automate Proposal and Quote Generation

The gap between "send me a quote" and the quote actually landing in a buyer's inbox is where deals go cold. When you automate proposal generation, you close that gap: the rep submits a short form or clicks one button, and a drafted, priced, correctly formatted proposal is waiting for review minutes later instead of at the end of the week. You do not need a CPQ implementation project to get there. You need a repeatable pricing source, a template, and a workflow that assembles the two.

This guide shows how to build that workflow in Skopx by describing it in plain English, where the honest boundary sits between machine work and human judgment, and how to verify the thing is actually running correctly once it is live.

What manual proposal and quote generation costs teams

The cost is rarely one big number. It is a pile of small ones that compound across every deal in the pipeline.

A rep gets a request. They open the CRM to confirm the company name, contact, deal size, and which products are in play. They open last quarter's pricing sheet, or ask someone in finance which version is current. They find the most recent proposal that looks similar, duplicate it, and start deleting the previous customer's name from a dozen places. They rewrite the scope paragraph. They recalculate a discounted line item by hand. They export a PDF, notice the header still says the old client, and do it again.

The failure modes that follow are predictable:

Measure your own number before you build anything. Take the last ten quotes your team sent, note the timestamp of the request and the timestamp of delivery, and look at the median. That single figure is the benchmark your automation has to beat, and it is the one you will report on afterward. Do not use a number you read somewhere; use yours.

The workflow design behind automated proposal generation

A proposal is an assembly job. Four inputs go in, one artifact comes out.

1. Deal facts. Company, contact, deal value, products, close date. This lives in your CRM.
2. Pricing. Unit rates, tiers, discount rules, currency. This should live in exactly one place, usually a sheet, a database table, or a product catalog in your billing system.
3. Narrative. The scope paragraph, the value framing, the assumptions section. This is the part an AI step writes well when it is fed real data.
4. Format. Your template, your legal terms, your branding.

The workflow's job is to fetch one and two, generate three, and pour everything into four. Skopx workflows are built by describing them in chat, and the four available step types map cleanly onto this: integration actions fetch the deal and the pricing, an AI step drafts the narrative on your own provider key, if/else conditions branch on things like discount depth, and field transforms handle the arithmetic and formatting in between.

Here is the basic version.

Basic proposal generation

Quote request webhook

Fetch CRM deal

Pull price book

Calculate totals

Draft proposal copy

Create proposal doc

Notify rep

Seven steps, well inside the twenty step ceiling, and no loops required, which matters because Skopx workflows are acyclic. If you need to price ten line items, you do not iterate; you pass the whole line item array into a single AI step or transform and let it handle the set at once.

Data moves between steps with expressions. The CRM lookup uses the deal ID from the webhook payload as {{ trigger.deal_id }}. The pricing filter matches on {{ steps.crm.output.products }}. The AI step receives both. The doc step consumes {{ steps.draft.output.text }}. The Slack message carries {{ steps.doc.output.url }}.

What to automate and what stays human

This is the part most teams get wrong in the enthusiastic direction. A proposal is a commercial commitment. The moment it leaves your domain, it is a promise about price, scope, and timeline that a buyer can hold you to.

Skopx has no human-approval step, and that constraint pushes you toward the correct design anyway: the workflow prepares and notifies, a person decides and sends. Nothing about the sensitive act of quoting a price to a customer should happen without a named human putting their eyes on it first.

The practical shape is: the workflow builds a complete, correct, ready-to-send draft and puts it in front of the owner with everything they need to approve it in thirty seconds. That is a much better outcome than auto-sending, and it is also the version your finance lead will approve. If your process has a discount threshold, the workflow's job is to detect that the threshold was crossed and route the draft to whoever owns that decision, not to grant the discount.

The same principle appears in adjacent sales workflows. Assigning an owner is safe to automate, which is why automated lead routing works well end to end; committing to a price is not.

Build it in Skopx step by step

Open the Workflows page and start a new workflow. You describe what you want in chat and Skopx assembles the steps. There is no canvas to drag nodes onto.

Before you start, connect the accounts you will reference: your CRM, wherever your price book lives, your document tool, and your team chat. Skopx connects to nearly 1,000 business tools, so the specific combination is usually available. Also add your own AI provider key in settings, because AI steps run on your key with zero markup and will not execute without one.

Step 1: describe the workflow. Type a single sentence that names the trigger, the lookups, the generation, and the delivery. Something like this:

When my quote request webhook fires, look up the deal in HubSpot using the deal ID in the payload, pull the matching rows from my Pricing sheet in Google Sheets, calculate the subtotal and total, use an AI step to draft the scope and value sections in our proposal voice using that deal and pricing data, create a Google Doc from the draft in our Proposals folder, and post the doc link to the deal owner in Slack with the company name and total.

Step 2: choose the trigger. A webhook is right here, because proposal requests arrive on demand rather than on a clock. Skopx gives the workflow a unique URL with its own secret. Point your intake form, your CRM automation, or a Slack shortcut at it. If you would rather batch, a schedule trigger works too: daily at 08:00 in your chosen timezone, sweeping every deal marked "quote requested". Schedules support 15 minute, hourly, daily, and weekly cadences.

Step 3: pin the pricing source. Point the lookup at one sheet or table and nothing else. If pricing lives in three places, fix that first. The workflow will faithfully reproduce whatever inconsistency you feed it.

Step 4: write the AI step prompt properly. Give it the deal fields, the calculated totals, your tone rules, and a hard instruction: use only the numbers provided, never invent a price, and never promise a delivery date that is not in the input. Ask for structured output so the document step gets clean sections instead of a wall of prose.

Step 5: add the guardrail transforms. A field transform that formats currency, another that computes the validity date, another that builds the proposal reference number. Doing arithmetic in a transform rather than in the AI step means the numbers are deterministic and auditable.

Step 6: deliver to a person. The final step is a notification, not a customer email. Include the doc link, the total, the discount percentage, and the deal name so the owner can approve without opening four tabs.

Step 7: run it manually first. Trigger a manual run against a real closed deal where you already know what the correct quote looks like. Compare line by line.

The advanced version with discount routing

Once the base workflow is trustworthy, add the branch that most sales teams actually need: standard quotes go straight to the rep, discounted ones go to whoever owns pricing approval.

Proposal generation with discount routing

needs approvalwithin policy

Quote request webhook

Fetch deal and pricing

Draft quote

Discount above policy?

Prepare approval note

Alert pricing owner

Create proposal doc

Notify deal owner

The condition is a straightforward comparison: is the calculated discount greater_than your policy threshold. Skopx conditions handle equals, contains, greater_than, is_empty and similar checks, which covers almost every branching rule a quoting process needs.

Note what the "needs approval" branch does not do. It does not apply the discount, does not create the customer-facing document, and does not send anything outward. It assembles a summary with the requested discount, the margin impact, the deal history, and the rep's stated reason, then pings the person who owns that call. They approve in their own tool and the document gets created from the approved terms. The workflow removed the assembly work and left the decision exactly where it belongs.

The quality of that summary depends entirely on the quality of the deal record behind it, which is why automated CRM data enrichment tends to be the prerequisite project rather than a nice-to-have.

How to tell it is working

Every run in Skopx is inspectable. Each step records its real output, how long it took, and the exact error if it failed. That gives you three concrete checks.

Check the run log after each of the first twenty runs. Open the run, expand the pricing lookup step, and confirm the rates it actually returned. Expand the AI step and read the draft it actually produced. You are looking for silent wrongness, not crashes. A crash is obvious. A quote built from an empty pricing result that the AI cheerfully narrated around is not.

Track the two timestamps. Request received and draft delivered. If the median is not dramatically better than the manual baseline you measured earlier, something in the chain is stalling, and the run durations in the log will tell you which step.

Track edit distance informally. Ask reps how much they change before sending. Heavy edits in the same section every time means the AI prompt needs the missing input, not that the automation failed.

Watch for failed runs. If you used a schedule trigger, a run that misses its window beyond the two hour grace period is recorded as failed rather than fired late. That is deliberate: a proposal batch that quietly fires six hours late is worse than one that visibly failed.

Common mistakes when you automate proposal generation

Auto-sending to the customer. Covered above, worth repeating. Prepare and notify.

Letting the AI step do the math. Language models are excellent at scope paragraphs and unreliable as calculators. Every number in the document should originate from a transform or an integration output, and the AI step should be instructed to reproduce provided numbers verbatim.

Building on scattered pricing. If the workflow has to check two sheets and a Notion page, you have not automated proposal generation, you have automated confusion at higher speed.

Templating in the AI step. Legal terms, payment windows, and signature blocks belong in the document template where they are version controlled by a human. Do not ask a model to reproduce your terms from memory each run.

Skipping the notification payload. A Slack message that says "proposal ready" with a bare link forces the owner to open the doc to evaluate anything. Put the company, total, discount, and expiry in the message itself.

Ignoring the twenty step ceiling. If your quoting logic genuinely needs more, split it: one workflow assembles and prices, a second triggered by webhook handles document generation and distribution.

Forgetting the provider key. AI steps run on your own key. No key, no draft, and the run will tell you so plainly in the step error.

Once quoting is dependable, the natural next automation is the call that follows it. Automated meeting prep briefs put the quote, the deal history, and the open objections in front of the rep before they dial.

Frequently asked questions

Do I need a CPQ product to automate proposal generation?

Not for most teams. CPQ earns its keep when you have complex configurable products, thousands of SKUs, and hard entitlement rules. If your pricing fits in a well-maintained sheet and your proposals follow one or two templates, a workflow that reads the sheet, drafts the narrative, and builds the document covers the same ground with far less implementation cost.

Can the workflow send the proposal to the customer automatically?

It can technically perform an email action, but you should not design it that way. A quote is a commitment, and Skopx has no human-approval step to gate it. The correct pattern is that the workflow produces a finished draft and notifies the owner, who reviews and sends. Design the notification so that review takes seconds, and the human step stops feeling like friction.

What if the pricing lookup returns nothing?

Add an if/else condition that checks whether the pricing result is_empty, and route that branch to an alert instead of to the AI step. Without it, you get a confidently written proposal wrapped around missing numbers, which is the single most dangerous failure mode in this whole process.

Can I generate quotes in multiple currencies or languages?

Yes. Keep the currency and locale on the deal record, branch on it with a condition, and pass it into both the transform that formats the totals and the AI step that writes the narrative. Keep separate document templates per language rather than asking the AI to translate your legal terms.

What does running this cost?

Skopx is Solo at $5 per month, Team at $16 per seat per month, and Enterprise at $5,000 per month, billed from day one on every plan. The AI steps bill to your own provider key with zero markup, so model usage goes straight to your provider at their rates with nothing added on top.

Start with one deal

Do not try to model every pricing scenario on day one. Pick your single most common deal shape, build the seven step version, run it manually against three closed deals you already know the answer to, and only then point a real intake form at the webhook. Add the discount branch in week two. Add the second product line in week three.

The version that runs beats the version that models everything. Open Workflows, describe the sentence above in your own words, and watch the first run log line by line.