Proposal assistant for services
Discovery evidence becomes a commercially coherent proposal package, with scope controls, a review path and the next client action already prepared.
Case note
The implementation was treated as a small operating system: visibility first, ownership next, automation only after the workflow was clear.
Use case
Turn discovery into a reviewable proposal package
The team starts from discovery notes, transcripts, CRM context and commercial decisions that normally live in different places. The workflow creates one path: check whether there is enough context, extract the commercial facts, recommend the offer path, prepare SOW, assumptions, exclusions and follow-up, and leave everything ready for human review before anything is sent.
Result: the first draft already has commercial structure, scope controls and a review checklist; senior people review judgment and risk instead of rebuilding the proposal from zero.
Workflow map
From discovery to reviewable proposal
The system does not replace commercial judgment. It organizes context, prepares the pack, and blocks client-facing output until a person reviews it.
Main database: Supabase
The workflow uses Supabase as the source of truth: it stores each record, status, and key event so the team can see what happened, retry failures, and debug without searching every tool.
Tool icons
System rationale
The value is not just writing faster; it is reviewing better
Weak proposals usually fail before writing starts: responsibilities are missing, the promise is too broad, scope is not closed, or the CRM does not hold the full story. This workflow turns discovery into a reviewable package so the conversation is about commercial judgment, not hunting for notes.
Context first, drafting second
The automation does not try to polish incomplete notes. If scope, outcome, owner, timeline or commercial data are missing, it asks precise questions before creating a document.
One source for proposal and CRM
The brief, CRM note, outline, SOW and follow-up come from the same package. That avoids the proposal saying one thing while the deal record says another.
Approval is part of the system
AI prepares structure and language, but sending stays blocked until a person checks pricing, risk, assumptions and promises made to the client.
Professional add-ons on top
The starting point
A growing professional-services firm was building proposals from call notes, transcripts, CRM history and senior memory. The real delay happened before writing: scope had to be reconstructed, assumptions were discovered late and reviewers spent expensive time repairing the commercial logic rather than improving it.
The diagnosis used real volume, connected tools, decision points and exceptions. The question was not only what to automate, but what proof would show that the workflow had completed correctly. The operating proof mattered as much as the automation.
The implementation
Ductio built a proposal request workflow around a simple control: no draft starts until minimum context is present. Once ready, OpenRouter turns discovery material into a proposal package with discovery brief, offer path, SOW bullets, assumptions, exclusions, client responsibilities, CRM note, review checklist and follow-up draft.
The implementation separated rules, free-text context, human decisions and external effects. That let the system improve daily work without turning every exception into a black box. AI as support inside the process, not as autopilot.
What was used
Tooling was chosen from the process outward, not from a pre-decided technical preference. Each piece needed a clear owner, a stable integration path and a simple way to inspect errors.
In practice, the build combined Supabase, Python/FastAPI, OpenRouter, Google Workspace adapter, HubSpot-ready note. The tools visible to the team stayed close to their daily work, while integration logic was documented and kept separate from sensitive commercial decisions.
The improvement showed up in daily work.
Rather than treating the result as a dashboard, the team felt it in three specific moments: less manual preparation, less context hunting, and fewer doubts about who needed to act.
Draft prep: Typical discovery-to-reviewable-draft cycle moved from 150 min to 45 min.
Scope clarity: Scope, assumptions, exclusions and responsibilities made explicit moved from Variable to Checklist.
Review effort: Senior time moved from formatting to commercial review moved from Rewrite to Judgment.
Before/after proof
What changed in the operation
Before
After
Visible artifacts
- Structured discovery brief
- Offer recommendation with confidence
- Proposal outline and SOW bullets
- Assumptions, exclusions and client responsibilities
- CRM note draft
- Human review checklist
- Follow-up email draft
Controls
- Missing-context branch stops thin proposals
- Human review required before any client-facing send
- Assumptions and exclusions are explicit
- Google document creation is optional and logged
- CRM context and proposal content come from the same source
What changed after launch
The first draft now arrives as a reviewable commercial package rather than a formatted blank canvas. Senior reviewers focus on pricing, risk and client promises; sales keeps the proposal, CRM note and follow-up aligned from the same approved facts.
The result was not only saved minutes. The team gained a shared sequence for reviewing inputs, understanding context, deciding, acting and checking that the workflow had been recorded. 70% faster prep
The workflow in one line
How it was built
The system processes a proposal request from Supabase, checks minimum context, generates the proposal package with OpenRouter, stores the draft payload, optionally creates a Google Workspace document, and marks the request ready for human review.
The stack was pragmatic: Supabase, Python/FastAPI, OpenRouter, Google Workspace adapter, HubSpot-ready note. Tools were chosen for ownership, integration and maintainability, not for theater. The result is a system the team can understand and operate.
What was delivered
- Minimum-context gate
- Discovery brief
- Offer recommendation
- Proposal package
- Review checklist
- Google Docs adapter
- Follow-up draft
- Reviewable proposal preparation became roughly 70% faster, typically moving from several hours to well under one.
- Every package exposes scope, assumptions, exclusions, client responsibilities and unanswered questions before approval.
- Senior review shifted from rebuilding documents to checking commercial judgment, risk and pricing fit.
- Proposal, CRM note and follow-up remain aligned because they are produced from the same approved evidence.
- Incomplete discovery is converted into a focused question list instead of a weak draft.
- Nothing client-facing leaves the workflow without an explicit human decision.
