Olmec Dynamics
H
·7 min read

How to Connect Airtable to PandaDoc and Google Drive Using Make.com

Automate proposals by connecting Airtable to PandaDoc in Make.com, then upload, rename, and file results in Google Drive with status tracking.

Introduction

If you generate proposals manually, the workflow is always the same messy loop. A team updates a record in Airtable, you copy fields into a PandaDoc template, you attach the right annexes, then you download a PDF and rename it to match whatever convention you used last time.

Two weeks later, you are still asking: which proposal version is the latest, and who stored the Drive file? The admin cost is usually hidden, but it shows up as rework, missing attachments, and Slack pings.

In this guide, you will build an Airtable to PandaDoc automation using Make.com, then automate the Google Drive upload and rename so your documents land in the right place every time.

What You'll Need

  • Make.com scenario builder (Make module access for Airtable, PandaDoc, Google Drive, and error notifications). Paid plan is usually required for reliable multi-step runs.
  • Airtable base with a table such as Proposals and fields you can map into PandaDoc.
  • PandaDoc template(s) set up for proposal generation, with merge fields that correspond to your Airtable data model.
  • Google Drive folder where you want documents stored, plus Make.com permissions to read/write that folder.
  • Optional: Slack for failure alerts.

How It Works (The Logic)

This Cross-Platform Automation (XPA) is a simple trigger-to-actions chain with guardrails:

  1. Trigger: Make.com watches Airtable for rows where Record Status = Ready.
  2. Decide: A router checks whether PandaDoc Document ID is already present.
  3. Create or Update: Make.com uses the PandaDoc module to generate the document from your template, mapping Airtable fields into PandaDoc.
  4. Files in Drive: If your proposal includes annexes or you want the final PDF stored, Make.com uses the Google Drive module to upload/prepare the file and then rename/move it.
  5. Write back: Make.com updates Airtable with PandaDoc URL, PandaDoc Document ID, Drive file info, and a new Record Status.
  6. Observe: On errors, Make.com writes Failed to Airtable and posts a Slack message.

Step-by-Step Setup

1) Add control fields in Airtable

In your Proposals table, add these fields (names are flexible, logic is not):

  • Record Status (single select): Draft, Ready, PandaDoc Created, PandaDoc Updated, Failed
  • PandaDoc Document ID (text)
  • PandaDoc URL (text or URL field)
  • Drive File ID (text)
  • Last Synced At (datetime)
  • Idempotency Key (text), typically set to {RECORD_ID} or {ClientName}_{ProposalName}
  • Optional: Error Details (long text)

Why the idempotency key: Airtable updates and Make retries can make scenarios run again. The goal is that “run again” does not create duplicate PandaDoc documents.

2) Build the Make.com scenario with the Airtable trigger

In Make.com:

  1. Create a new scenario.
  2. Add an Airtable module as the trigger.
  3. Select a trigger for “new or updated record” (or equivalent).
  4. Add a filter immediately after the trigger:
    • Keep only records where Record Status = Ready.

Common gotcha: if you trigger on “updated,” and you do the Airtable status update at the end, your filter prevents a retrigger loop.

3) Add a Router: create vs update

Add a Router module after the trigger.

  • Branch A (Create): filter condition PandaDoc Document ID is empty
  • Branch B (Update): filter condition PandaDoc Document ID is not empty

This ensures your scenario does not spam PandaDoc with duplicate documents.

4) Configure the PandaDoc document generation step

On both branches, add your PandaDoc module action:

  • Choose the action that creates a document from a template (your template should match your merge fields).
  • Select your template.
  • Map Airtable fields to PandaDoc inputs.

Field mapping example you should implement:

  • Airtable Client Name → PandaDoc client_name
  • Airtable Client Email → PandaDoc client_email
  • Airtable Proposal Name → PandaDoc proposal_title
  • Airtable Total and Currency → PandaDoc totals fields
  • Airtable line items → either formatted text or structured fields, depending on your PandaDoc setup

Gotcha: normalise data formats in Make before mapping. Date and currency fields are where template mapping tends to break.

5) Decide how you handle Google Drive files (annexes and/or final output)

There are two common patterns. Pick one based on what your PandaDoc template expects.

  • Pattern A: annexes stored in Google Drive

    • Store annex identifiers in Airtable, such as Annex File ID (Google Drive file ID) or a Drive URL.
    • In Make, fetch those files from Google Drive and attach them where your PandaDoc module expects file inputs.

  • Pattern B: you just want the final proposal stored in Drive

    • After PandaDoc generates the document, export or retrieve the resulting PDF file (how you do this depends on your PandaDoc setup and the PandaDoc module output fields).
    • Then push it into your target folder in Google Drive.

Make sure you can get a Drive file reference or file content from the PandaDoc step output before you attempt Drive rename operations.

6) Rename and store in Google Drive using a deterministic rule

Add a Google Drive module step for file handling:

  1. Determine the target folder in Drive, for example:
    • /{Client Name}/Proposals/{YYYY}/
  2. Rename the file using a stable format, for example:
    • {{ClientName}}_{{ProposalName}}_{{formatDate(LastModified)}}_PandaDoc

Important: rename usually requires the Drive file ID. If your PandaDoc module does not provide a Drive file ID, insert the step that creates/uploads the file in Drive first, then rename it.

7) Update Airtable with status and links

At the end of each branch, add an Airtable update module. Update:

  • Record Status → PandaDoc Created (create branch) or PandaDoc Updated (update branch)
  • PandaDoc Document ID (if not already populated)
  • PandaDoc URL
  • Drive File ID
  • Last Synced At

Order matters: do this after Drive rename succeeds.

8) Add error handling that makes failures actionable

In Make, configure error handling for PandaDoc and Google Drive steps:

  • Update Airtable Record Status = Failed
  • Write Error Details
  • Send a Slack message to a channel like #ops-automation-errors with:
    • Airtable record link
    • Client Name, Proposal Name
    • the PandaDoc step error message

This is the difference between an automation you “hope works” and a Cross-Platform Automation (XPA) you can run confidently.

Real-World Business Scenario

A consulting business runs proposal cycles from Airtable. Their workflow used to look like this: someone updates a record, a coordinator regenerates the PandaDoc, and an admin renames and files the PDF in Drive.

We implemented an Airtable to PandaDoc automation in Make.com with strict status filtering and idempotency routing. Result: every time a proposal enters Ready, the correct PandaDoc template is generated, Google Drive receives the final PDF with a consistent filename format, and the Proposals row in Airtable ends at PandaDoc Created or Failed.

The operational win was immediate: fewer “wrong file” issues and zero manual tracking to find the latest version.

Common Variations

  1. Route by template type in Airtable Add a router layer before PandaDoc: Template Type chooses the correct PandaDoc template for quotes, amendments, or onboarding packs.

  2. Only update PandaDoc when specific fields change Add filters so the update branch runs only when key fields (totals, scope, dates) change. This reduces unnecessary PandaDoc regeneration.

  3. Attach extra documents from Drive based on intake answers If your intake process stores “annex required: yes/no,” you can conditionally fetch annex files from Google Drive and attach them only when needed.

The Build You Now Have

You now have an Airtable-triggered Cross-Platform Automation (XPA) that generates PandaDoc proposal documents and automatically manages Google Drive filing with deterministic renaming, plus idempotency and status reporting.

If you want to see the broader XPA patterns we build (and how we approach field mapping, idempotency, and failure modes), start with Cross-Platform Automation (XPA) patterns. And if you want a version tailored to your Airtable schema, PandaDoc templates, and Drive structure, Olmec Dynamics builds these workflows for teams in the real world at Olmec Dynamics.