How to Automate Airtable to PandaDoc Proposals with Make.com

Introduction

If you generate PandaDoc proposals manually from Airtable, you already feel the pain: copy fields out of Airtable, paste them into the template, fix formatting, then copy the generated PDF link back into the record. It works until your line items get complex, a field is missing, or someone edits a record after generation.

This guide walks you through a production-style Cross-Platform Automation (XPA) that removes the copy-paste loop. When an Airtable record is marked ready, Make.com pulls the record, normalizes the data, creates a PandaDoc document from your template, then updates Airtable with the PandaDoc URL and status. When something breaks, Slack gets the exact context.

By the end, you will know how to build Airtable → Make.com → PandaDoc proposals with merge-field mapping, idempotency, and actionable failure alerts.

For the bigger picture on how XPA fits into system design, see Cross-Platform Automation (XPA).

What You'll Need

• Make.com scenario builder, with Airtable, PandaDoc, and Slack connections available.
• Airtable base with:
  • A proposals table (example: Opportunities or Orders).
  • Fields to drive the workflow:
    • A boolean or status field like generate_proposal.
    • Output fields like panda_doc_document_id, panda_doc_url, proposal_status.
    • Line items stored either as linked records or as a pre-built string.
• PandaDoc:
  • A proposal template created with merge fields that match the data you will send.
  • The right template fields for customer details, proposal metadata, and the items block (often a single merge field).
• Slack:
  • A channel the scenario can post into.
  • Make connection permissions to post messages.

How It Works (The Logic)

At a high level, your XPA flow is:

1. Trigger: Make.com watches Airtable records for changes (new/updated).
2. Guard: It filters to only records where generate_proposal is set.
3. Data prep: Make.com loads the full Airtable record, builds a PandaDoc-ready items value, and normalizes dates and currency.
4. Idempotency: If panda_doc_document_id already exists, it stops to avoid duplicate proposals.
5. Action: It creates a PandaDoc document from your template, mapping Airtable fields to PandaDoc merge fields.
6. Update: It writes panda_doc_url and proposal_status back into Airtable.
7. Failure visibility: If validation fails or PandaDoc errors, it posts a Slack message with what failed and which Airtable record to fix.

Step-by-Step Setup

This is the advanced build pattern that stays maintainable when you add more fields later.

1) Create the Make.com scenario with an Airtable trigger

• Add an Airtable trigger: Watch Records (or the closest equivalent watch module).
• Choose the proposals table.
• Immediately follow the trigger with a filter:
  • Condition: generate_proposal equals true (or proposal_status equals Ready).

Gotcha: If you do not filter here, every record edit will run PandaDoc again.

2) Fetch the complete record for reliable mapping

• Add Airtable: Get Record using the record ID from the trigger.
• Select all fields you need for PandaDoc merge fields:
  • Customer fields (name, email, company)
  • Proposal fields (number, issue date, due date, currency)
  • Items source (linked line items or an Airtable string)

3) Build the items block Make-computes for PandaDoc

PandaDoc templates typically want merge fields, not raw linked-record structures. Most teams use a single merge field like {{items}}.

• If you store items as linked records:
  • Use Airtable modules to retrieve the linked line items.
  • Add Iterator over line items.
  • Build each line into a formatted fragment, then combine with a Text aggregator.
  • Example output style:
    • Consulting Session x2 @ 250.00
    • Implementation Support x1 @ 500.00
• If items already exist as a text field in Airtable:
  • Skip the transformation and map it directly.

Gotcha: Multi-select and linked-record fields usually need conversion. If you pass arrays directly to a merge field, the document can show empty content or throw errors.

4) Validate required fields before you call PandaDoc

Add a filter (or route logic) before the PandaDoc module.

Recommended required checks:

• customer_email is not empty
• customer_name is not empty
• proposal_number is not empty
• items_list_text (or computed items string) is not empty
• total_amount is not empty

If validation fails, route to Slack (next step).

5) Add a dedicated Slack route for “missing data”

• Add a Slack module: Slack: Post Message.
• Include fields in the message so ops can fix quickly:
  • Airtable record ID
  • proposal number
  • which fields failed validation

This prevents your scenario from failing silently.

6) Add idempotency so reruns do not duplicate documents

Before creating a PandaDoc document, add a conditional:

• If panda_doc_document_id is not empty:
  • Stop scenario execution (or set proposal_status to Already Created).
• Else:
  • Continue to the PandaDoc creation step.

Gotcha: This is the main control against duplicate PDFs when users update records after generation.

7) Create the PandaDoc document from a template

Add PandaDoc: Create Document from Template.

Configure:

• template_id: your PandaDoc template
• Merge field mapping:
  • customer_first_name ← Airtable first_name
  • customer_last_name ← Airtable last_name
  • customer_email ← Airtable customer_email
  • proposal_number ← Airtable proposal_number
  • proposal_date ← formatted Airtable date
  • items ← Make-computed items_list_text
  • total_amount ← formatted currency string

Best practice: Normalize dates and currency in Make before mapping. Do it consistently for both formatting and locale expectations.

8) Capture the PandaDoc URL and document ID

Right after the PandaDoc creation module, extract:

• PandaDoc document ID
• PandaDoc document URL (or share URL, depending on your PandaDoc configuration)

If your PandaDoc module returns a response with different property names, map from the response fields you actually receive in Make.

9) Update Airtable with output fields

Add Airtable: Update Record. Update:

• panda_doc_document_id ← PandaDoc response document ID
• panda_doc_url ← PandaDoc response URL
• proposal_status ← Created (or Sent, if you share in the same run)
• generate_proposal ← false
• optionally proposal_generated_at ← current timestamp

Gotcha: Use the same record ID you got from the trigger, not a line item record ID.

10) Add a final error path for PandaDoc API failures

Wrap with error handling so PandaDoc failures do not just end the run.

• Route errors to Slack: Post Message.
• Include:
  • Airtable record ID
  • PandaDoc step
  • the raw error message text from Make

This makes debugging fast, especially when you add more templates.

Real-World Business Scenario

An agency runs delivery proposals from Airtable. Ops marks generate_proposal = true when a scope is approved. The Make.com scenario generates the PandaDoc proposal instantly, using a strict merge-field map and a computed items block.

Ops then sees the generated PandaDoc URL and proposal_status = Created directly in Airtable. If someone forgets to add a customer email or a required item, Slack gets a message with the exact record ID and missing fields. The team stops spending time hunting for what went wrong and returns to delivery work.

Common Variations

1. Create then approve, then send

• Split into two scenarios:
  • Scenario A generates the PandaDoc document and stores the URL.
  • Scenario B sends it only when an Airtable approval checkbox flips.

2. Route by proposal type to different PandaDoc templates

• In Make, add a router based on Airtable proposal_type:
  • Template A for retainers
  • Template B for one-off projects

3. Filter by business rules, not just generate_proposal

• Only generate when client_approved = true and total_amount > 0.

The outcome you should expect

Your Airtable records now produce PandaDoc proposals automatically via Make.com, with:

• Correct merge-field mapping
• Consistent formatting for dates and currency
• Line item normalization into a PandaDoc-ready items block
• Idempotency so reruns do not spam duplicates
• Slack alerts that tell you exactly which record needs attention

If you want a hand mapping your exact Airtable fields to your PandaDoc template merge fields, Olmec Dynamics builds these Cross-Platform Automation workflows for real teams. You can see how we approach XPA delivery on our site and Cross-Platform Automation (XPA) for the XPA mindset behind the build.