Olmec Dynamics
A
·7 min read

Automate Airtable to PandaDoc and Google Drive Using Make.com

Automate Airtable to PandaDoc with Make.com, then store the generated PDF in Google Drive, with field mapping, status write-back, and Slack alerts for ops teams.

Automate Airtable to PandaDoc and Google Drive Using Make.com

If you generate proposals from Airtable, the manual version usually looks like this: copy fields into PandaDoc, generate the document, download the PDF, rename it consistently, upload it to Google Drive, then update Airtable so the team can see it is done. Miss one of those steps and you get duplicate proposals, broken links, and Slack pings like “can someone find the PDF?”

This guide shows you how to build a production-ready Cross-Platform Automation (XPA) with Make.com. Your Airtable record becomes the trigger, Make generates the PandaDoc document, and then the PDF is saved into Google Drive with the right links written back to Airtable and shared in Slack.

By the end, you will know exactly how to wire Airtable to PandaDoc, export to PDF, save to Drive, and keep everything traceable.

What You'll Need

  • Make.com account (paid plan recommended, because this is a multi-step scenario)
  • Airtable base and table for proposals (permissions to read and update records)
  • PandaDoc account and a template set up with tokens that match your Airtable fields
  • Google Drive access and a destination folder strategy
  • Slack access for notifications (permissions to post to your channel)
  • Operational prerequisites:
    • You have a clear “gate” field in Airtable, typically Status = Ready to generate
    • You have fields to store write-backs like PandaDoc Document ID, PandaDoc Document URL, and Google Drive File URL

If you want the core Airtable to PandaDoc pattern first, start here: How to Build an Advanced Airtable 'PandaDoc Automation Using Make.com' and How to Automatically Create PandaDoc Documents from Airtable Using Make.com.

How It Works (The Logic)

When an Airtable proposal record reaches Ready to generate, Make.com triggers and does this chain:

  1. Pull the Airtable record data, normalize it, and map fields to your PandaDoc template
  2. Create the PandaDoc document from the template
  3. Write the PandaDoc identifiers and status back into Airtable
  4. Export or retrieve the generated PDF and upload it into the correct Google Drive folder
  5. Write the Drive file link back to Airtable and notify the team in Slack

That logic gives you state-driven execution, which is what makes Cross-Platform Automation (XPA) maintainable.

Step-by-Step Setup

1) Model your Airtable table for write-back

In your Proposals (or equivalent) Airtable table, create fields like:

  • Status (single select): Draft, Ready to generate, Generated, Needs review, Sent
  • Template ID (text)
  • Recipient Name (text)
  • Recipient Email (email)
  • Proposal Number (text/number)
  • PandaDoc Document ID (text)
  • PandaDoc Document URL (url)
  • Google Drive File URL (url)
  • Automation error (long text, optional but highly recommended)
  • Last automation run (date/time)

Common gotcha: decide which field prevents duplicates. You want the Make scenario to only run when Status = Ready to generate, and you want the scenario to move that record out of the gate state early.

2) Trigger in Make from Airtable using a filtered view

In Make.com, create a new scenario and add:

  • Module 1: Airtable > Watch Records
  • Configure it to watch your proposals table
  • Add a filter so the scenario only returns records where:
    • Status equals Ready to generate

If you can, point Make at an Airtable view (like Proposals - Ready to generate). It keeps filtering clean and avoids messy logic inside Make.

3) Normalize fields and prepare PandaDoc token inputs

Add a step that prepares your PandaDoc inputs. In practice, this means you ensure:

  • dates are consistently formatted
  • currency values are in the format your PandaDoc template expects
  • recipient fields are not empty
  • any “line items” data is converted into a structure your PandaDoc template can consume

This is where most failures happen, because Airtable fields can come through in unexpected shapes. Normalize until your output is flat and predictable.

4) Create the PandaDoc document from a template

Add:

  • Module: PandaDoc > Create Document

Map key values:

  • template_id from your Airtable Template ID
  • token fields from Airtable to the PandaDoc template fields (example: Recipient Email, Proposal Number, etc.)

Validation tip: run one test record end-to-end and confirm token names match exactly between Airtable mapping and PandaDoc template fields.

5) Write PandaDoc IDs and URLs back into Airtable

After Create Document returns, add:

  • Module: Airtable > Update a Record

Update at minimum:

  • PandaDoc Document ID = returned PandaDoc document id
  • PandaDoc Document URL = returned document url
  • Status = Generated
  • Last automation run = now

Common gotcha: set Status to Generated (or another non-gate value) as part of the write-back. That prevents duplicate runs if the PDF export step fails.

6) Retrieve the generated PDF and upload to Google Drive

Add the Drive file workflow:

  • Module: PandaDoc > Export/Download PDF (or the available PandaDoc action that provides the PDF file content for Make)
  • Module: Google Drive > Upload a File

Set:

  • File name: Proposal-{Proposal Number}-{Recipient Name}.pdf
  • Destination folder: choose a stable folder or compute a folder path from date (for example Proposals/2026-08/)

If the PDF is not ready instantly, you have two practical options:

  • confirm your PandaDoc action returns immediately with file content
  • add a short wait and only then export, or only proceed when the returned payload indicates readiness

7) Write the Google Drive link back into Airtable

Add:

  • Module: Airtable > Update a Record

Update:

  • Google Drive File URL with the uploaded file’s share/link URL
  • set Status to Needs review (or Sent) depending on your internal process

8) Post a Slack notification with the links

Add:

  • Module: Slack > Send Channel Message

Message should include:

  • Proposal number
  • Recipient name/email (if appropriate)
  • PandaDoc link
  • Google Drive link
  • New status (example: Generated or Needs review)

This turns the automation into an operational system. People know where things are without hunting.

9) Add failure visibility so you can debug fast

Make sure you have an error path that writes to:

  • Automation error

Even a single text field that says “Failed at PDF export” versus “Failed at Drive upload” saves hours.

Real-World Business Scenario

A UK B2B services firm used Airtable as their proposal pipeline. Their weekly pain was consistent and predictable: 20 to 40 proposals created, team members manually generated PDFs in PandaDoc, uploaded to Drive, then updated Airtable after the fact.

After implementing this Airtable to PandaDoc to Google Drive Make.com setup, every proposal that moved into Ready to generate automatically:

  • created the PandaDoc proposal
  • wrote the PandaDoc URL back to Airtable immediately
  • uploaded the PDF to the correct Drive folder with a consistent filename
  • stored the Drive URL in Airtable
  • posted a Slack message to the review channel

The outcome was straightforward: fewer missing PDFs, fewer duplicates, and faster approvals because the team stopped chasing files.

Common Variations

  1. Route Slack by deal value

    • If Total value > 5000, notify an executive approvals channel.
    • Otherwise notify the standard sales channel.

  2. Generate multiple documents per record

    • Create a second PandaDoc document (for example an annex or scope of work) and upload both PDFs to Drive.
    • Store both links back in Airtable.

  3. Regeneration logic

    • If a proposal changes after Generated, either block regeneration or create a new version.
    • Append -v2 to the Drive filename to keep history.

If you want to see the broader XPA pattern across systems, keep this in mind: treat your database record in Airtable as the source of truth and write every downstream identifier back to it. That’s the Cross-Platform Automation (XPA) pattern we apply in builds like automating proposals with Make and Slack.

Keep It Traceable, Not Just Connected

You built an intermediate XPA that actually works in the real world: Airtable triggers the workflow, Make generates PandaDoc content, the PDF lands in Google Drive, and Airtable plus Slack tell everyone what happened.

Olmec Dynamics builds exactly these kinds of reliable automations for teams that need operational clarity, not fragile “one-click” scripts. If you want examples of how we approach Cross-Platform Automation (XPA), you can start with this overview of our XPA approach and then adapt the same pattern to your stack.