Olmec Dynamics
H
·6 min read

How to Automatically Create PandaDoc Documents from Airtable Using Make.com

Automate creating PandaDoc documents from Airtable records in Make.com, pre-fill template fields, then send for signature automatically.

Introduction

If you are still exporting Airtable records and then re-typing details into PandaDoc templates, you are paying a tax in two places: time and accuracy. The manual version usually becomes a copy-paste session, then an uncomfortable check to confirm the right values actually landed in the right PandaDoc field tags.

This is exactly the kind of Cross-Platform Automation (XPA) workflow you should wire up. In this guide, you will connect Airtable to PandaDoc via Make.com, auto-create documents from a template, pre-fill fields from your Airtable columns, and send for signature.

By the end, you will have an Airtable-to-PandaDoc document generation pipeline you can trust.

What You'll Need

  • Airtable: base and table that stores the record that should trigger a document (for example, “Proposal requests”)
  • PandaDoc: a document template with field tags/tokens for every value you want to pre-fill
  • Make.com: an account with working connections to Airtable and PandaDoc
  • Your PandaDoc template needs to expose the field tags you plan to map. If you cannot see the field tag names in the template editor, you cannot reliably pre-fill them from Make.

Optional but recommended for cleanliness:

  • An Airtable field like PandaDoc Status (so you can stop duplicates)
  • Airtable fields to store PandaDoc Document ID and/or a PandaDoc Link

How It Works (The Logic)

At a high level, Make.com runs this logic:

  • Trigger: when a new record is added in Airtable
  • Action 1: Make.com creates a PandaDoc document from your template
  • Action 2: Make.com pre-fills the PandaDoc template fields using Airtable values that match the template’s field tags
  • Action 3: Make.com sends the generated document for signature to the recipient email in your Airtable record
  • Action 4: Make.com writes status back to Airtable so reruns do not create extra documents

This is the classic XPA pattern: one system owns the data (Airtable), one system owns the document engine (PandaDoc), and Make.com keeps the workflow deterministic.

Step-by-Step Setup

1) Design your PandaDoc template for mapping (this is where most failures start)

Open your PandaDoc template and confirm:

  • Every field you want populated has a field tag (not just a static label)
  • You know the exact field tag name that Make.com will send

Practitioner gotcha: field tags are often case sensitive, and template tags sometimes look similar but differ by punctuation. If your Make mapping key does not exactly match, PandaDoc will generate a document with blank fields.

2) Add required columns in Airtable

In your Airtable table, ensure you have at least:

  • Client Name
  • Client Email
  • Project Name (or equivalent)
  • Total (or equivalent)
  • PandaDoc Status (recommended)

Optional but useful:

  • PandaDoc Document ID
  • PandaDoc Link

3) Create the Make.com scenario

In Make.com:

  1. Create a new Scenario
  2. Add an Airtable module as the trigger
  3. Select the Base and Table that contains the new records you want to document

Run a single test so Make.com gives you a sample record payload. You need that sample payload for field mapping.

4) Add a filter to prevent duplicate sends

Add a Filter module right after the Airtable trigger.

A simple condition set:

  • PandaDoc Status is empty

If your team sometimes edits old records, you can also filter for PandaDoc Status not equal to Sent.

This single filter prevents the “why did we send three versions” support ticket.

5) Create the PandaDoc document from your template

Add a PandaDoc module for “create a document from template” (the Create-from-template action).

Configure:

  • Template ID: select or input your PandaDoc template ID
  • Field pre-fill / Include fields: enable the option that lets you provide template field values

6) Map Airtable fields to PandaDoc template fields

Now map Airtable values to the exact template field tags.

Example mapping strategy:

  • PandaDoc field tag ClientName ← Airtable Client Name
  • PandaDoc field tag ClientEmail ← Airtable Client Email
  • PandaDoc field tag ProjectName ← Airtable Project Name
  • PandaDoc field tag Total ← Airtable Total

Practitioner gotcha: if your Total is numeric in Airtable but your PandaDoc field is expecting formatted text, you may need a formatting step in Make to match your template expectations.

7) Send for signature (separate step in most builds)

In many real PandaDoc + Make setups, you use one PandaDoc action to create the document and another PandaDoc action to send it.

Add the PandaDoc send action after the create step, then set the recipient email from Airtable Client Email.

If your template has multiple signer roles, map the email into the correct recipient role fields.

8) Write back status and document identifiers to Airtable

After the send step succeeds:

  • Update the same Airtable record
  • Set PandaDoc Status to Sent
  • Store PandaDoc Document ID and PandaDoc Link if Make’s PandaDoc module outputs them

This makes your automation observable, and it reduces time spent debugging when something goes wrong.

9) Test with one real Airtable record, then retry

Test in two passes:

  1. Create one Airtable record with complete data, then confirm:
    • the generated PandaDoc document opens correctly
    • all relevant fields are filled
    • the signature email was sent
  2. Trigger the scenario again or re-run manually for that record, then confirm your filter stops duplicate sends

Real-World Business Scenario

A UK marketing agency uses Airtable to collect proposal requests. Their workflow required generating an SOW or proposal document in PandaDoc, but the manual process involved exporting data, pasting it into the template, generating, then sending.

With this Make.com XPA, each new Airtable row generates a fresh PandaDoc document from a template and pre-fills fields like client details, project scope, and totals. The team wrote back PandaDoc Status to Airtable so the document send is idempotent. Over time, they stopped wasting cycles on “did we fill the right field tag?” and shifted effort into actual delivery.

Common Variations

  1. Branch by deal size
  • If Total is above a threshold, use a different PandaDoc template ID for enterprise proposals.
  1. Add internal approval before sending
  • Create the PandaDoc document, then only send it when Approved = Yes in Airtable.
  1. Write a summary log to Google Sheets for audit
  • Record the PandaDoc Document ID, created timestamp, and Airtable record link for auditing and reporting.

If you want a parallel pattern for keeping ops channels readable when you send updates, see how we built batching notifications from Google Sheets to Slack with Make.com in this Google Sheets digest guide.

Keep it reliable after you launch

This workflow stays stable when:

  • your PandaDoc template field tags match the Make mapping keys exactly
  • you filter out duplicates using PandaDoc Status
  • you store PandaDoc Document ID or a link back in Airtable

If you want this built to your exact Airtable schema and your exact PandaDoc template field tags, Olmec Dynamics builds these Cross-Platform Automation (XPA) document pipelines for real teams. Start by reading Cross-Platform Automation (XPA), then see what we do here.