Olmec Dynamics
H
·8 min read

How to Automate Airtable to PandaDoc PDF Generation Using Make.com

Automate Airtable to PandaDoc PDF generation with Make.com, including template merge fields, email delivery, and Drive storage logs.

Introduction

If you are generating quotes, statements, or proposals from Airtable, the manual version usually looks like this: pull a record, copy values into a document template, export a PDF, email it, then manually save the PDF somewhere so you can find it later.

After a few weeks, the problems get predictable. Someone updates a template, older PDFs look different, fields end up blank in some documents, and when a customer asks "did you send the right quote?" you have no clean audit trail.

This Airtable to PandaDoc PDF generation build turns that into a repeatable Cross-Platform Automation (XPA) where Make.com generates the PDF, stores it, emails it, and logs exactly what happened back in Airtable.

What You’ll Need

  • Airtable
    • A base and table that holds your document data (example: Quotes)
    • A field that indicates readiness to send (example: Status = Ready)
    • A way to store results back (example fields below)
  • PandaDoc
    • A reusable template with merge fields that match your expected inputs
    • Permission to generate documents from that template
  • Make.com
    • An account to run an intermediate scenario using Airtable, PandaDoc, Google Drive, and Gmail modules
  • Google Drive
    • A destination folder for the generated PDFs
  • Gmail
    • Permission to send emails from your mailbox

Two production prerequisites:

  1. You must pre-map your PandaDoc template merge fields so the keys you send from Make.com always line up.
  2. You need idempotency so retries do not generate multiple PDFs and multiple emails.

If you want the design mindset for this kind of workflow, start with Cross-Platform Automation (XPA).

How It Works (The Logic)

Your XPA logic is:

  • Trigger: when a new Airtable record is created (or when it enters Status = Ready)
  • Guardrails: Make.com checks whether a document was already generated for that record
  • Action: Make.com creates a PandaDoc document from a template and pre-fills merge fields
  • Action: Make.com downloads or captures the generated PDF output
  • Action: Make.com uploads the PDF to Google Drive
  • Action: Make.com emails the PDF (or a Drive link) to the customer email stored in Airtable
  • Write-back: Make.com updates the Airtable record with PandaDoc IDs, Drive links, and a sent timestamp

Step-by-Step Setup

1) Prepare Airtable fields for both input and output

In your Quotes (or equivalent) table, add fields like:

  • Status (single select): Draft, Ready, Sent, Error
  • Customer Email (email)
  • Quote Number (text)
  • Company Name (text)
  • Contact Name (text)
  • Line Items (text, optional depending on your template)
  • Valid Until (date, optional)

And add output fields for traceability:

  • PandaDoc Document ID (text)
  • Drive File URL (url)
  • Email Sent At (datetime)
  • Automation Run Status (text)
  • Automation Error (long text)

Idempotency recommendation:

  • Use the Airtable record ID (or a stable Quote Number) and rely on PandaDoc Document ID being blank until the first success.

2) Build your PandaDoc template merge fields to be map-friendly

In PandaDoc, create your template and add merge fields for each variable you want filled.

Practical rules that prevent 90 percent of template breakages:

  • Keep merge field names consistent (no spaces, no ambiguous duplicates)
  • Match field types, for example text vs checkbox vs dropdown
  • Avoid forcing long free-form text into a field that expects short strings

When you are filling fields programmatically, PandaDoc’s pre-fill approach depends on merge field mapping. A useful reference is PandaDoc’s pre-fill fields documentation.

3) Create a new Make.com scenario

In Make.com:

  1. Create a Scenario
  2. Add the Airtable trigger, typically a “watch records” style trigger for created records
  3. Select your base and your Quotes table

Run a test so you can see the exact output fields Make.com receives.

4) Filter early: only generate when the record is ready

Add a Filter module immediately after the Airtable trigger:

  • Condition: Status equals Ready
  • Condition: PandaDoc Document ID is empty

This is your first dedupe layer. It prevents duplicate PandaDoc generation even if Make.com retries the scenario.

5) Normalize values for merge field filling

Add a Tools step (Set variables / text functions) to normalize inputs:

  • Normalize email: trim whitespace, lowercase if you store inconsistent emails
  • Ensure dates are in the format your PandaDoc template expects

Why this matters: document generation can fail or silently fill blank if the payload shape or data type does not match the expected template field.

6) Generate the PandaDoc document from your template

Add the PandaDoc module for document creation from a template.

You will pass:

  • Template identifier
  • Document name (include something human like Quote {{Quote Number}} - {{Company Name}})
  • Prefill/merge field values mapped to the exact merge keys in your template

Gotcha to watch:

  • If your template merge fields use bracket syntax internally, the mapping keys in the API or Make.com module must still match those field identifiers. Test with one record before automating the rest.

7) Capture the generated PDF output

After PandaDoc creates the document, add the next step to obtain the PDF.

Depending on how Make.com presents the PandaDoc response, you might:

  • read a returned PDF download URL
  • or call a second step to fetch the document asset

Store whatever you need for the next modules, especially the binary/file output Make.com can upload to Drive.

8) Upload the PDF to Google Drive with a predictable filename

Add a Google Drive module:

  • Action: Upload file
  • Folder: your chosen destination folder
  • Filename: {{Quote Number}} - {{Company Name}}.pdf

You want deterministic filenames because it reduces the time it takes to locate documents when something goes wrong.

9) Send the email using Gmail

Add a Gmail module:

  • To: Customer Email
  • Subject: Your quote {{Quote Number}}
  • Body: include Company Name, Quote Number, and Valid Until if present

For attachments, pick the approach that works best with how Make provides the PDF:

  • attach the PDF file if available as a binary
  • or attach nothing and include the Drive link if your Drive permissions are set correctly

10) Write back to Airtable, always

After the PDF upload and email send succeed, update your Airtable record:

  • PandaDoc Document ID = document id from PandaDoc
  • Drive File URL = the Drive link from upload
  • Email Sent At = now
  • Automation Run Status = Sent
  • clear Automation Error

11) Add an error branch that updates Airtable

Use Make.com’s error handling flow:

  • Set Status to Error (optional but recommended)
  • Set Automation Run Status to Error
  • Save the error text into Automation Error

This gives your team an operational view without digging through Make.com logs.

12) Test with real records, in this order

Test these scenarios:

  1. Status = Ready, all fields present
  2. Status = Ready, optional fields missing (verify template still renders)
  3. Re-run or simulate a retry for the same Airtable record (verify PandaDoc Document ID guard stops duplicates)

Real-World Business Scenario

A B2B agency stores quote inputs in Airtable and uses PandaDoc to deliver branded PDFs. Their old workflow had two failure points: inconsistent manual copy-paste into the template, and no reliable way to prove what was sent.

After implementing this Airtable to PandaDoc PDF generation XPA in Make.com:

  • moving a quote record into Status = Ready automatically produced one PandaDoc document
  • merge fields stayed consistent because Make.com mapped directly to the template keys
  • PDFs were stored in Google Drive with predictable filenames
  • Airtable records captured PandaDoc IDs and Drive URLs, so ops could answer "which PDF did we send?" in seconds

Common Variations

  1. Generate on update instead of create
  • Use an Airtable update trigger and filter for when Status becomes Ready.
  1. Insert an approval gate
  • Only generate when Approved = Yes.
  • Route non-approved records to a Slack or Teams message for review.
  1. Add contract signing as a second stage
  • Instead of just emailing the PDF, configure PandaDoc workflows to request e-signatures after generation, then write the signing status back to Airtable.

What You Built, and why it holds up

You built an Airtable-driven XPA in Make.com that turns Status = Ready records into PandaDoc-generated PDFs, stored in Google Drive and delivered via Gmail, with write-back status and error logging in Airtable.

If you want help getting the merge-field mappings exactly right for your PandaDoc template, and wiring the scenario to match your Airtable schema and approval rules, Olmec Dynamics builds these XPAs for businesses. You can see what we do here and return to Cross-Platform Automation (XPA) for more patterns like this.