Client proposal generation from brief to signed contract

A service business wins a new prospect on Friday afternoon. By Monday morning, the client expects a tailored proposal in their inbox, complete with project scope, pricing breakdown, custom visuals, and case study snippets. You've got roughly 48 hours to write compelling copy, source or design relevant infographics, arrange everything into a professional PDF, and send it out. For most service teams, this means two people working late into the weekend, each handling different sections with minimal overlap. The proposal that arrives on Monday is polished, but your weekend wasn't. This workflow doesn't have to exist. The core work of a proposal, taking a brief and turning it into persuasive, visually coherent business documents, is exactly the kind of repetitive, structured task that AI excels at. The trick is connecting the right tools so that copy generation feeds directly into design, which feeds into your final document, all without anyone manually copying and pasting text between applications. We'll build a system using Copy.ai for initial copy generation, HyperWrite for refining longer-form content, Lex for collaborative final editing, and Text2Infographic for turning data points into visual assets. The orchestration layer uses Make (formerly Integromat), which offers a visual interface that's more approachable than n8n for workflows of moderate complexity. For more on this, see Document Writing and Editing Faster: Using Dictation and ....

The Automated Workflow

Start by creating a Google Form or simple web form that captures the proposal brief. This is your single point of entry. Fields should include: project name, client name, service type, key deliverables, budget range, and any existing case study metrics you want to reference. When the form submits, Make receives a webhook notification. This triggers the workflow sequence.

Step 1: Brief ingestion and data routing

Configure a Make scenario with a Webhook trigger set to "watch form submissions". Your Google Form submits JSON data to Make's webhook endpoint. Test the webhook URL by filling out the form once; Make will show you the exact payload structure.

CopyPOST /hook/abc123xyz789/forms/proposal_brief
Content-Type: application/json { "project_name": "E-commerce Platform Redesign", "client_name": "Acme Retail Ltd", "service_type": "UX Design & Development", "deliverables": "Homepage, product pages, checkout flow", "budget_range": "£15,000-£25,000", "case_study_metric": "Increased conversion rate by 34%"
}

Store this data in Make's built-in data store or a simple Google Sheet. You'll reference these values later in multiple AI calls, so centralising them avoids API calls with incomplete context.

Step 2: Copy generation with Copy.ai

Next, add a Copy.ai module to your Make scenario. Copy.ai's API accepts a prompt and returns generated text. Create three separate calls to Copy.ai, one for each section: executive summary, service scope, and value proposition. For the executive summary, your prompt might look like this:

CopyWrite a 150-word executive summary for a proposal to {{client_name}} for {{service_type}}.
The project is called {{project_name}}.
Key deliverables: {{deliverables}}.
Tone: professional but approachable. Emphasise speed and quality.

Map the form fields (wrapped in double braces) to the actual values from your webhook trigger. Copy.ai returns generated text; store this in a text variable within Make. Repeat for scope and value proposition, adjusting the prompt each time. Copy.ai's API endpoint is:

CopyPOST https://api.copy.ai/v1/generate
Authorization: Bearer YOUR_COPY_AI_API_KEY
Content-Type: application/json { "prompt": "Your prompt here with variables interpolated", "tone": "professional", "length": "medium"
}

Step 3: Content refinement with HyperWrite

The copy from Copy.ai is solid but sometimes generic. Route it through HyperWrite's API to refine tone and ensure specificity to the client's industry. HyperWrite accepts a text block and returns an improved version.

CopyPOST https://api.hyperwrite.com/v1/improve
Authorization: Bearer YOUR_HYPERWRITE_API_KEY
Content-Type: application/json { "text": "{{copy_from_previous_step}}", "instruction": "Make this more specific to {{service_type}}. Add one concrete example of past results.", "style": "professional_consultative"
}

Store the refined copy in a new variable. This adds perhaps 30 seconds of processing time per proposal but noticeably lifts quality.

Step 4: Infographic generation from data

Text2Infographic converts raw statistics into visual assets. Before calling it, extract or construct the numerical claims from your case study metrics. If your brief mentioned "Increased conversion rate by 34%", send that to Text2Infographic.

CopyPOST https://api.text2infographic.com/v1/generate
Authorization: Bearer YOUR_TEXT2INFOGRAPHIC_API_KEY
Content-Type: application/json { "data_points": [ "Conversion rate: +34%", "Page load time: -2.3s", "User engagement: +67%" ], "style": "modern", "format": "vertical"
}

Text2Infographic returns a URL to the generated image. Note this URL; you'll embed it in the final document.

Step 5: Document assembly in Lex

Lex is a collaborative word processor with AI built in. Rather than forcing Make to generate a Word document directly, use Make to create a new Lex document and populate it with the content you've generated. Lex has a public API but works smoothly with Zapier and Make through its web interface. Instead of a direct API call, use Make's "HTTP" module to authenticate with Lex and create a new document:

CopyPOST https://api.lex.page/documents
Authorization: Bearer YOUR_LEX_API_KEY
Content-Type: application/json { "title": "{{project_name}} - Proposal for {{client_name}}", "content": "{{executive_summary}}\n\n{{service_scope}}\n\n{{value_proposition}}"
}

Include the infographic URL as an embedded image reference within the document. Lex will render it.

Step 6: Final handoff and notification

Once the Lex document is created, send a notification to your team with the document link and client email address. Use Make's email module to send yourself a summary:

CopyTo: your_email@company.com
Subject: Proposal ready: {{project_name}} for {{client_name}}
Body:
Proposal link: {{lex_document_url}}
Client email: {{client_email}}
Next: Review for 5 minutes, then send to client.

Include a button or one-click action to export the Lex document as PDF and email it directly to the client. Alternatively, add a final Make step that calls the Google Drive API to save the exported PDF there for record-keeping. The entire sequence, from form submission to completed document ready for human review, takes roughly 90 seconds. Your team spends maybe 5 minutes reviewing for brand voice and accuracy, then clicks send.

The Manual Alternative

If orchestration feels too technical, you can replicate this workflow with minimal automation: Run Copy.ai in your browser, paste in your brief, save the copy to a Google Doc. Open HyperWrite as a browser extension, highlight the text, request refinement. Switch to Text2Infographic, upload your metrics, download the resulting image. Open Lex, create a new document, paste in the refined copy, insert the infographic, and export to PDF. Share with the client. This takes roughly 45 minutes per proposal. It's not automated, but it's systematic and requires no API keys or technical setup. Use this if you send proposals infrequently (fewer than two per week) or if your team is uncomfortable with workflow tools.

Pro Tips

Error handling for API rate limits:

Copy.ai and Text2Infographic both enforce rate limits.

If you're generating multiple proposals in a single day, stagger the requests. Make allows you to add a delay module between steps. Set it to 2-3 seconds between API calls. If a call fails, use Make's error handler to retry once after a 10-second pause, then log the failure to Google Sheets so you can troubleshoot manually.

Variable naming and clarity:

Within Make, name your variables descriptively. Instead of "output1" and "output2", use "copy_executive_summary" and "copy_refined_scope". When you return to the workflow in three months, this saves you from guessing what each variable contains.

Testing the workflow:

Before running it live, manually fill out your form three times with different data. Check that the copy from Copy.ai actually reflects the project type and client name you specified. Verify that the infographic includes the metrics you sent. Lex may take 5-10 seconds to render images; don't assume it failed if the document isn't instantly populated.

Cost control:

Set spending limits on your Copy.ai and Text2Infographic accounts if they allow it. Monitor your first week of proposals and note the typical cost per document. If you're surprised by the bill, you can disable certain steps. For instance, Text2Infographic is optional; you can generate infographics manually once per month and reuse them across proposals for the same service type.

Customisation without recreating the workflow:

Store your tone preferences and brand guidelines in a separate Make data store or Google Sheet. Instead of hardcoding "professional but approachable" into your Copy.ai prompt, reference a cell from your settings sheet. This way, you can change the tone for all future proposals in one place.

Cost Breakdown