How to Build an Advanced Airtable 7 PandaDoc Automation Using Make.com

Introduction

Many teams keep contract or proposal data in Airtable and then manually copy fields into PandaDoc. That costs hours each week and introduces copy errors: wrong names, missing dates, incorrect signers. You want a single source of truth in Airtable that reliably creates a PandaDoc document, assigns the correct signer(s), writes the document id back to Airtable, and alerts your team if anything fails.

By the end you will have an advanced Make.com scenario that watches Airtable, creates a PandaDoc document from a template, handles recipients and conditional tokens, writes a back-reference to Airtable, and implements retries and logging.

What You'll Need

• Airtable account with the base containing your source records and a field to receive PandaDoc document_id (paid plan recommended for automation reliability).
• PandaDoc account with at least one template prepared and token names noted (API access requires a PandaDoc plan that includes API or integrations).
• Make.com account (scenarios and error handlers used; paid tier recommended for large volume and advanced error handling).
• Slack workspace and webhook or Slack connection in Make.com for notifications (optional but recommended).
• API keys for PandaDoc and Make.com connections, and an Airtable API key or OAuth credentials.

How It Works (The Logic)

When an Airtable record enters a "Ready to Send" view or a checkbox is ticked, Make.com reads the record, assembles template tokens and a recipients array, calls PandaDoc to create a document from a template, stores the returned document_id and document_url back on the Airtable record, and posts a Slack message with the document link. If the call fails, Make.com retries certain errors, logs the failure to a dedicated Airtable log table, and notifies a human.

Step-by-Step Setup

Follow these numbered steps inside Make.com. Names refer to Make modules and common field names in Airtable and PandaDoc.

1. Prepare Airtable

• Add fields: CompanyName, ContactFirstName, ContactLastName, ContactEmail, TemplateId (optional), DocStatus (single select: Draft, Ready, Sent, Signed), PandaDocId (text), PandaDocUrl (url), ReadyToSend (checkbox).
• Create a view called "Ready to Send" that filters ReadyToSend = checked and PandaDocId is empty. This view protects against duplicate sends.

2. In PandaDoc, prepare your template

• Use simple token names: CompanyName, ContactFirstName, ContactLastName, ContactEmail, InvoiceDate, TotalAmount.
• If you need conditional blocks, include boolean tokens like IncludeDiscount.
• Note the template_id exactly as shown in PandaDoc.

3. Create a new scenario in Make.com

• Module 1: Airtable, Watch Records (select the "Ready to Send" view). Set the polling interval appropriate to your plan and volume. Use "Limit" to control batch size if needed.
• Gotcha: If you expect frequent edits in the same record, prefer Watch Records with a view rather than Watch Changes on all records.

4. Add a Router with validation path and a main path

• Path A: Validation. Use a filter that checks required fields exist (ContactEmail not empty, TemplateId or default template present). If validation fails, route to an Airtable Create Record in a "Doc Errors" table with error details and stop. This prevents silent failures.
• Path B: Build payload. Use Tools > Set Multiple Variables to create these variables:
  • doc_name = "Proposal - {{CompanyName}} - {{InvoiceDate}}"
  • tokens = JSON object mapping PandaDoc token names to Airtable values
  • recipients = JSON array: [{"email":ContactEmail,"first_name":ContactFirstName,"last_name":ContactLastName,"role":"signer"}]

5. Module: HTTP or PandaDoc app to Create Document from Template

• If Make.com has a PandaDoc app, use Create Document from Template. If not, use HTTP > Make a request to POST /public/v1/documents with a JSON body. Map the variables:
  • template_uuid or template_id = TemplateId or your default
  • name = doc_name
  • tokens/merge_fields = tokens JSON
  • recipients = recipients JSON
• Field mapping example (JSON body conceptual): { "template_id":"{{TemplateId}}", "name":"{{doc_name}}", "recipients":{{recipients}}, "tokens":{{tokens}} }
• Gotcha: PandaDoc expects specific key names. Test with one sample record and inspect the raw PandaDoc API response in Make.

6. Module: Parse the PandaDoc response

• Extract document_id and document_url from the response. If response contains errors, route to the Error handler.

7. Module: Airtable, Update Record

• Update the original Airtable record: set PandaDocId = document_id, PandaDocUrl = document_url, DocStatus = Sent, ReadyToSend = unchecked, LastSentAt = now.
• Gotcha: Use the record ID from the Watch Records module. Do not rely on match by fields to avoid updating the wrong row.

8. Module: Slack notification and logging

• Post a Slack message to your team channel with the document_url, record id, and owner. Also create a record in an Airtable "Doc Log" table capturing payload snapshot, response status, and timestamps for traceability.

9. Error handling and retries

• Use Make's built-in error handlers on the PandaDoc call. Configure retry for 5xx or network errors with exponential backoff. For 4xx errors (bad request, invalid token), route to the Doc Errors table and alert a human.
• Implement idempotency: before creating a document, check PandaDocId is empty. If a race condition is possible, add a small Update Record step that sets a Processing flag using Airtable's record update with a filter for Processing = false; if update fails because Processing was set already, skip the run.

10. Monitoring and scaling

• Add a scheduled scenario that polls PandaDoc for recent document statuses and writes Signed/Viewed back to Airtable so your base stays authoritative.
• If you process many docs, add a sleep module between PandaDoc calls or implement batching to respect PandaDoc rate limits.

Real-World Business Scenario

A UK SaaS consultancy used this exact pattern to generate tailored Statements of Work. They kept every commercial field in Airtable, ticked ReadyToSend when a proposal passed legal review, and Make.com created a PandaDoc for the client. The process cut proposal assembly time from 90 minutes per deal to under 4 minutes, removed copy errors, and gave sales a clickable link in Airtable immediately. They also reduced duplicate sends by storing PandaDocId and using an idempotent Processing flag.

Common Variations

• Multiple signers, CCs, or role-based recipients: build the recipients array from linked Airtable records and map roles dynamically.
• Template per product line: store TemplateId on the Airtable record and use it in the Create Document call to pick the right template.
• Generate a PDF copy and upload to Google Drive: after PandaDoc creation and signing, add HTTP > GET to download the PDF and upload to Google Drive for archival.

Final notes and next steps

You now have a production-ready pattern: trigger from an Airtable view, assemble a PandaDoc payload in Make.com, create the document, write back the document id and URL, and handle errors with logging and alerts. If you would rather have Olmec Dynamics build and operate this workflow for you, see our services and examples on our website. For a direct conversation about implementing this exact pattern for your templates and Airtable schema, visit Olmec Dynamics to see how we help clients automate document generation.