How to Generate PandaDoc Proposals from Airtable Records Using Make.com

Introduction

Generating proposals by hand is slow and error prone. You copy client details from Airtable into a document, rebuild line items, upload the file to an e-sign tool, then paste the link back into your CRM. That wastes time and creates mismatched records when people edit fields later.

By the end of this guide you will have a production-ready Make.com scenario that watches Airtable, creates a PandaDoc from a template with exact field mappings, optionally sends it for signature, and writes document IDs and links back to Airtable for traceability.

What You'll Need

• Airtable account with the table that holds proposal data, plus a view to trigger on (Pro plan recommended if you use scripted fields or advanced views).
• PandaDoc account with a template that contains named placeholders (API access via token, available on Business or Enterprise plans depending on your org settings).
• Make.com account with access to Airtable and PandaDoc modules (paid Make.com plans required for multi-step scenarios and error handlers).
• Permissions: ability to create API tokens in PandaDoc, edit the Airtable base, and create scenarios in Make.com.

No related posts were found in our blog index for this exact pairing, so this walkthrough is new for our library.

How It Works (The Logic)

Trigger: A new or updated Airtable record appears in a dedicated view. Action 1: Make.com reads the record, normalises fields and builds payloads for PandaDoc. Action 2: Make.com calls PandaDoc to create a document from a specific template_id, passing field values that match the template placeholders. Action 3 (optional): Make.com sends the document for signature or assigns recipients. Action 4: Make.com updates the original Airtable record with document_id, preview_url, and status. Error route: If PandaDoc returns an error, Make.com logs it to a Google Sheet or posts to Slack and retries if appropriate.

Step-by-Step Setup

1. Prepare the PandaDoc template

   • In PandaDoc, create a template and add field tags/placeholders. Use simple lowercase keys without spaces, for example client_name, proposal_total, due_date, line_items.
   • If you plan to use automated signers, add signer roles in the template (Client, Sales). Note each role name exactly for mapping later.

2. Normalise your Airtable schema

   • Add fields: ClientName, ClientEmail, ProposalName, DueDate (use ISO date), LineItems (long text or linked records), ProposalTotal, PandaDocDocumentId, PandaDocUrl, PandaDocStatus.
   • Create a view (e.g., "Generate Proposal") filtered to only records that should produce a document. Use a single-select or checkbox "Generate" to avoid duplicates.

3. Create a Make.com scenario, module by module

   • Module 1: Airtable, Watch Records in a view

     • App: Airtable, Trigger: "Watch Records" or "Watch Records in a View".
     • Configure to the base, table, and the "Generate Proposal" view. Set the polling interval to your required frequency.
     • Map output fields: ClientName, ClientEmail, ProposalName, DueDate, LineItems, ProposalTotal, Record ID.

   • Module 2: Tools, (optional) Formatter or JavaScript for complex mappings

     • Use "Text aggregator" to convert linked-line items into the format your PandaDoc template expects (for example markdown table or serialized JSON). For complex line items use Make.com’s JavaScript module to build the exact JSON structure required by your template.
     • Common gotcha: PandaDoc templates expect certain structures for repeater blocks. Test this with a single record before scaling.

   • Module 3: PandaDoc, Create Document from Template (or HTTP POST)

     • If Make.com provides a PandaDoc app module choose: Action "Create Document from Template" (name may vary). Connect using the PandaDoc API token.
     • If using HTTP: use Make.com HTTP module, method POST to https://api.pandadoc.com/public/v1/documents with header Authorization: Bearer YOUR_TOKEN and Content-Type: application/json.
     • Payload example (HTTP): { "name": "{{ProposalName}} - {{ClientName}}", "template_uuid": "<your_template_id>", "recipients": [ {"email": "{{ClientEmail}}", "role": "Client"} ], "fields": { "client_name": "{{ClientName}}", "due_date": "{{DueDate}}", "proposal_total": "{{ProposalTotal}}", "line_items": "{{LineItemsFormatted}}" } }
     • Map the Airtable outputs into each field value exactly matching the placeholder keys.
     • Common gotchas: PandaDoc uses template_uuid or template_id depending on API version. Check your developer docs and test one request in Postman if necessary.

   • Module 4: (Optional) PandaDoc, Send Document

     • If you want automatic sending, either include recipients in the create call or call PandaDoc’s "send" endpoint. Map signer roles to the emails you included earlier.

   • Module 5: Airtable, Update a Record

     • Update the original record with the returned document_id, preview_url or public_url, and set PandaDocStatus to the returned status. Map the Make.com response fields to Airtable update fields.
     • Use the Airtable Record ID captured in Module 1.

   • Error handling route

     • Add a custom error handler in Make.com. On failure from the PandaDoc module capture the error text and push a row to a Google Sheet or post to Slack with record ID and error details. Optionally, add a delay and retry for transient 5xx errors.

4. Test with a single Airtable record

   • Put a test record in the "Generate Proposal" view, run the scenario, then inspect PandaDoc and Airtable. Confirm placeholders resolved and the link wrote back.
   • Check signer workflow by creating a sandbox recipient email.

5. Go live and monitor

   • Turn on the scenario schedule in Make.com. Monitor the first 50 runs closely, validating the returned document links and statuses. Keep an eye on rate limits and API error codes.

Real-World Business Scenario

A B2B services company we worked with replaced a manual proposal process. Their sales ops team used Airtable to store quotes and line items. After this build they created proposals automatically on agreement, and the finance team received consistent PDF previews in PandaDoc. Result: the sales team cut proposal turnaround from 8 hours to 30 minutes and reduced errors that previously caused contract rework.

Common Variations

• Generate invoices instead of proposals by swapping the PandaDoc template and adjusting line item serialization.
• Use a signed webhook from PandaDoc to update Airtable when a document is completed instead of polling. That requires exposing a webhook endpoint or using Make.com’s webhooks module.
• Add a filtering step to only send proposals automatically for deals above a threshold, otherwise queue for manual review in a Slack channel.

Where this gets you You now have a repeatable pattern: Airtable is the single source of truth, Make.com orchestrates data transformation and API calls, and PandaDoc holds signed agreements with links written back to Airtable for audit. If you want help building this with your exact Airtable fields and PandaDoc placeholders, Olmec Dynamics builds these workflows for clients, and you can learn more about our services on the Olmec Dynamics website.