A small consulting firm can cut proposal creation time from four-plus hours down to under 25 minutes by connecting a structured intake form, an AI writing layer, and a CRM—without writing a single line of code. The key is treating proposals not as documents but as data pipelines. Here’s exactly how we did it.
The Problem Worth Solving
Proposals are one of those tasks that feel creative but are mostly templated. You’re pulling the same information—client name, pain points, scope, timeline, price tier—and arranging it in a slightly different order every time. For Meridian Consulting Group, a 6-person operations consultancy based in Austin, every proposal was taking two senior staff members somewhere between 3.5 and 5 hours total. That included the discovery call debrief, pulling previous case studies from a Notion wiki, drafting in Google Docs, reformatting the PDF, and chasing down the right pricing table from a shared spreadsheet nobody fully trusted.
Three hours per proposal, roughly 12 proposals per month. Do the math: that’s 36+ hours of senior-level time gone to document production every single month. At a blended billing rate of around $175/hour, that’s over $6,300 in opportunity cost. Monthly. Not a small number.
The fix wasn’t to buy some $500/month “proposal software.” It was to wire together tools they mostly already had.
The Stack We Used
Before getting into the steps, here’s what’s actually running under the hood—and what you should know about each tool before committing to it.
Make.com (formerly Integromat)
Make.com is the orchestration layer. It listens for a trigger, moves data between apps, and calls the AI API. Pricing starts free and goes to $9/month for the Core plan, which covers 10,000 operations monthly—plenty for a sub-20-proposal-per-month workflow. The real advantage Make has over Zapier here is its ability to handle multi-step branching logic and JSON parsing without needing a paid add-on. The downside: the visual interface has a steeper learning curve than Zapier. Plan for a few hours of setup time if you’re new to it. We compared the platforms in depth in our Zapier vs. Make vs. n8n breakdown if you want the full picture.
Claude (Anthropic’s API)
We used Claude 3 Sonnet via the API for the actual writing. At roughly $3 per million input tokens and $15 per million output tokens, a full proposal draft costs about $0.04 in API fees. Not a rounding error—literally four cents. Claude was chosen over GPT-4o here for one specific reason: it’s noticeably better at following long, structured system prompts without drifting. When you give it a 600-word prompt that says “write in this tone, use these headers, never mention competitors,” it actually obeys. GPT-4o occasionally wanders. For structured document generation, Claude’s instruction-following is tighter in my experience. The limitation is that Claude’s API has slightly slower response times under load, and the Anthropic developer console is less polished than OpenAI’s.
Notion (as the knowledge base and output destination)
Meridian already used Notion to store case studies, service descriptions, and pricing tiers. The Make.com Notion integration can both read from and write to databases, which makes it a natural fit for pulling relevant case studies into the prompt and then storing the finished draft. Notion’s API is solid but has quirks—rich text blocks require a specific JSON format that trips people up. Budget an hour just to get Notion writes working correctly in Make.com. Notion AI (available on the Plus plan at $16/member/month) is an option but wasn’t used here; we went straight to the Claude API for more control over the output.
The Workflow, Step by Step
Step 1: Structured Intake via Typeform
After every discovery call, the account lead fills out a Typeform instead of writing a debrief email. The form has 14 fields: company name, industry, primary pain point (dropdown with 8 options), secondary pain points (multi-select), desired timeline, budget range, decision-maker name and title, and three open-text fields for context that doesn’t fit a dropdown. This takes about 8 minutes to complete while the call is still fresh. The form submission is the trigger that starts the entire automation.
Step 2: Make.com Receives the Submission and Pulls Context
The Typeform webhook fires into Make.com. The scenario then queries the Notion case studies database, filtering by industry tag. It pulls the two most relevant case studies—titles, one-sentence summaries, and quantified outcomes—and formats them as plain text strings. This is the retrieval step, and it’s the part most people skip when they try to build this themselves. Without pulling real context, the AI output is generic. With it, the proposal mentions that Meridian helped a Denver-based logistics company reduce invoice processing time by 40%. That specificity is what makes the document feel handcrafted.
Step 3: Building the Prompt
Make.com assembles a structured prompt using a text aggregator module. The system prompt (stored as a Make.com text variable, not hardcoded) defines tone, structure, and firm voice. The user prompt injects all the Typeform data and the retrieved case studies. Total prompt length is usually around 900-1,100 tokens. The prompt explicitly tells Claude to output the proposal in five sections with exact headers: Executive Summary, Where You Are Now, What We’ll Do Together, Investment and Timeline, and Why Meridian. That last instruction—naming the exact headers—is non-negotiable. Without it, Claude invents its own structure and the output needs manual reformatting.
Step 4: Claude Generates the Draft
The Make.com HTTP module sends the assembled prompt to the Anthropic API and receives the response. Average response time is 18-35 seconds for a 1,200-word proposal draft. The output is clean prose, not bullet soup. This is where Claude earns its keep—given the structured prompt and the injected context, the draft is typically 70-80% usable without edits. Occasionally it misjudges tone on highly technical proposals, which is why a human still reviews before sending. But “review and light edit” is very different from “write from scratch.”
Step 5: Draft Lands in Notion and HubSpot Simultaneously
Make.com writes the Claude output to a new Notion page inside a “Proposals” database, tagged with client name, date, and status “Draft.” In parallel, a second module updates the HubSpot deal record with a note that the proposal draft is ready and a direct link to the Notion page. The account lead gets a Slack notification via a third module. Total elapsed time from Typeform submission to Slack ping: 22 minutes on average, mostly waiting on Claude. Actual human time invested at this stage: 8 minutes filling out the form.
What Didn’t Work the First Time
Honestly, the first version of this broke in three places. The Notion API writes failed because we passed plain text instead of Notion’s rich text block format. The Claude prompt initially produced proposals that were too long—averaging 2,100 words—because we didn’t specify a target length. And the Typeform-to-Make.com webhook connection dropped silently on two test submissions because we hadn’t enabled webhook response handling correctly in Typeform’s settings. None of these were catastrophic, but all three required debugging sessions. If you’re building this yourself, add a Make.com error notification module on day one so failures don’t disappear quietly.
This kind of brittleness is real, and if you’ve read our piece on AI workflow orchestration, you’ll recognize it as the classic “last mile” problem. The AI part works. The plumbing around it is where things break.
The Results After 90 Days
Meridian tracked proposal metrics for three months post-launch. Average proposal creation time dropped from 4.1 hours to 22 minutes. Close rate on proposals stayed flat at 34%—which matters, because it confirms the AI-assisted proposals aren’t worse, just faster. In month three, they sent 17 proposals. The old process would have consumed 70 hours. The new one consumed roughly 6. That’s 64 hours returned to billable work, client strategy, and—frankly—not burning out their two senior people on document formatting.
The workflow also caught a gap they hadn’t noticed: because the Typeform forced structured intake, discovery calls got more focused. Consultants started asking better questions because they knew they’d have to fill in specific fields afterward. The automation improved the process before it even ran.
It’s worth being clear about what this isn’t. This isn’t a fully autonomous system. A human reviews every draft, adjusts pricing when needed, and makes the relationship call on tone. If you’ve been following the conversation about AI-first business claims, you’ll know that the “AI does everything” framing usually overpromises. This workflow saves hours. It doesn’t replace judgment.
Should You Build This?
If your business produces more than 6 custom proposals per month, yes, this is worth the setup time. Expect 8-12 hours of initial build time spread across a week, mostly on the Make.com scenario and getting the Claude prompt right. The ongoing cost is negligible—Claude API fees plus Make.com Core at $9/month. If you’re already paying for Notion and HubSpot, you’re adding less than $15/month in new costs.
If you produce fewer than 6 proposals monthly, the ROI math gets thinner. But the Typeform-to-AI-to-Notion pattern applies to a lot more than proposals—SOWs, project briefs, client onboarding packets. Build it once and you’ll find yourself reusing 80% of it for the next workflow. Similar to how the team in our e-commerce admin automation case study found that one working automation became the template for five more.
Start with the prompt. Get Claude producing a draft you’d be proud to send before you wire up a single API connection. The AI output quality is the ceiling of the whole system—no amount of clever automation compensates for a weak prompt.
FAQ
Do you need coding skills to build this proposal automation?
No. Make.com’s visual builder handles the logic without code. The trickiest part is formatting data correctly for the Notion API, which requires reading Notion’s documentation on rich text blocks—but it’s JSON configuration, not programming. If you can follow a recipe, you can build this.
Can you use ChatGPT instead of Claude for the proposal drafts?
Yes, and GPT-4o will produce solid results. The practical difference is that Claude tends to follow long, structured system prompts more consistently, which matters when your prompt specifies exact headers and a firm-specific tone. Run both on 5 test prompts and judge for yourself—your use case may tilt differently than Meridian’s did.
What’s the biggest risk with automating proposals this way?
The draft sounds confident even when the underlying data is wrong. If someone fills out the intake form carelessly—wrong budget range, vague pain point—Claude will write a polished proposal built on bad inputs. The automation doesn’t validate assumptions; a human reviewer does. Never skip the review step before a proposal goes to a client.
This article was produced with the assistance of AI, and its featured image was AI-generated. We review for accuracy, but please verify critical details.
