Olmec Dynamics
H
·7 min read

How to Generate and Send Contracts from Airtable to PandaDoc Using Make.com and Notion

Automatically create PandaDoc contracts from Airtable rows using Make.com, choose templates conditionally, map recipients, and log records in Notion for auditability.

Introduction

You keep contracts in Airtable but someone still copies rows, opens a template, types values, and then sends the document for signature. That manual work causes mistakes, missed fields, and no reliable audit trail. You want a predictable, auditable flow where each Airtable row becomes a prefilled PandaDoc, sent to the right recipients, and tracked in Notion.

This guide shows an advanced Make.com scenario that: watches an Airtable view, chooses the correct PandaDoc template based on record data, prefills merge fields and tables, creates the PandaDoc document, triggers the signature flow, stores files and raw data in Google Drive, and writes a complete record to Notion. By the end you will have a deterministic, idempotent production pattern ready for scale.

What you'll know by the end: how to map Airtable fields to PandaDoc merge fields, how to pass recipients correctly, how to select templates conditionally, and how to log and prevent duplicate sends.

What You'll Need

  • Airtable account and base with a dedicated table and a saved view for "Ready to send" rows.
  • Make.com account with connections to Airtable, HTTP (or PandaDoc app), Notion, Google Drive, and OpenAI (optional, for template selection logic). Make.com paid plan recommended for error handlers and webhooks.
  • PandaDoc account with API access and templates pre-created. Ensure the API key has access to the templates you will use. PandaDoc templates must define recipient roles and merge fields.
  • Notion workspace with a database to log each send. Integration token must allow create and update on that database.
  • Google Drive folder for archival of source row JSON and generated PDF if you want a permanent file copy.
  • Optional: OpenAI API key if you want to classify which template to use when rules are fuzzy.

Prerequisites and limits: PandaDoc requires merge field names to match exactly. Use RFC 3339 dates for PandaDoc date fields. PandaDoc template roles must match the recipient role you send in the API payload. If you plan high volume, confirm PandaDoc rate limits and Make.com operation quotas.

How It Works (The Logic)

Trigger: Airtable record enters the "Ready to send" view. Make.com reads the record, validates data, and decides which PandaDoc template to use (rule-based or OpenAI-assisted). Then it builds the PandaDoc payload: template_uuid, fields map, recipients array, metadata. It calls PandaDoc to create the document, optionally sends it immediately, stores returned IDs and PDFs in Drive, and writes a Notion record with links and status.

Simplified flow: Airtable (watch records) → Validate & choose template → Build fields + recipients → PandaDoc create document (from template) → PandaDoc send (if auto-send enabled) → Save artifacts to Drive → Notion log and update Airtable status.

Step-by-Step Setup

  1. Prepare Airtable and the saved view
  • Create a view filtered to rows ready for document generation, for example where send_status = "ready" and template_choice is set or blank.
  • Ensure each row contains all required fields for your templates: client_name, client_email, billing_address, effective_date, items (if you need a pricing table), order_ref.
  • Add a unique internal field like automation_key, either the Airtable record ID or a generated UUID.

Gotcha: keep the saved view stable. Changing visible fields can break your mapping.

  1. Add a Make.com scenario and Airtable trigger
  • Module: Airtable "Watch Records" (or "Watch Records in View"). Point to your base, table, and the saved view.
  • Set the trigger to return the full record object, including attachments and long text.
  1. Validate and normalise the record
  • Module: Tools "Set variables" or a small Code module. Build a normalized payload object with trimmed strings, ISO dates, numeric amounts as numbers, and an items array if you will populate PandaDoc pricing tables.
  • Validate emails with a simple regex. If validation fails, set status = manual_review and write back to Airtable.

Gotcha: failing early prevents malformed PandaDoc requests.

  1. Choose the PandaDoc template (rule-based or OpenAI)
  • Rule-based: use a Router or a simple Set variable mapping. Example: if contract_type = "SOW" use TEMPLATE_UUID_SOW. If total_value > 50000 use a different template.
  • OpenAI-assisted: if template selection is ambiguous, call OpenAI with a short prompt that returns a single token: the template key. Keep temperature at 0 and return only the template slug. This helps when you decide templates by unstructured notes.

Note: OpenAI is optional but useful for fuzzy rules.

  1. Build the PandaDoc payload

Field mapping examples:

  • fields.ClientName.value → payload.client_name
  • fields.EffectiveDate.value → formatted ISO date (RFC 3339)
  • For checkboxes or dropdowns pass boolean or exact option string.

Recipients array example: [ { "email": "{{client_email}}", "first_name": "{{client_first}}", "last_name": "{{client_last}}", "role": "Client" }, { "email": "{{sales_email}}", "first_name": "{{sales_first}}", "role": "Requester" } ]

Gotcha: role values must match roles defined in the PandaDoc template. If the template expects a role called "Signer 1" use exactly that string.

  1. Create the document and optionally send it
  • Call the PandaDoc create document endpoint. If you set the recipients and fields correctly, PandaDoc returns a document ID and a view_url or download_url depending on response options.
  • Immediately after create, if you want to auto-send, call PandaDoc's Send endpoint or include send = true if the API supports it in your account. Else, leave it as a draft and notify the sales rep for approval.
  1. Save artifacts to Google Drive
  • Save the raw request JSON and the PandaDoc response JSON to Drive in a folder named by automation_key.
  • If PandaDoc returns a PDF download link, fetch the PDF and store it as a file in Drive for long-term archiving.

Why: keeping raw inputs and outputs makes audits simple.

  1. Log and update Notion
  • Create or update a Notion database record with properties: automation_key, airtable_record_id, panda_doc_id, template_uuid, status (sent/draft/manual_review), panda_doc_link, drive_folder_link, created_at, sent_at, and any error notes.
  • Use the Notion module to create the page and set rich-text fields for direct links.
  1. Update Airtable status and add error branches
  • On success update the Airtable record: set send_status = sent, panda_doc_id = <id>, sent_at = <timestamp>.
  • On any API error, write send_status = error with error_message and route to a manual review queue. Use Make.com's error handler so the scenario does not silently retry and double-send.
  1. Test thoroughly and deploy
  • Use test rows with dummy emails and the PandaDoc test environment when available. Verify merge fields, recipient roles, date formats, and any pricing table rows.
  • Test idempotency by re-triggering with the same record. The scenario should first check if panda_doc_id exists and skip creation if present, or handle it according to your business rule.

Real-World Business Scenario

A professional services firm used this flow to automate statement-of-work delivery. Sales marked a row in Airtable as "Ready to send." The scenario selected the SOW template when service_type = implementation, populated client details and a pricing table from the line items array, created and sent the PandaDoc to the client and CC'd finance, archived the signed PDF to Drive, and created a Notion record for contract tracking. This removed 15 minutes of manual document prep per SOW and produced a searchable contract log.

Common Variations

  • Use PandaDoc merge tables for variable line items. Build the table payload from Airtable linked records and map into the pricing_tables or content_placeholders structure when calling the API.
  • Add a manager approval step: create the PandaDoc as a draft, post a Slack message to the approver with a link to the draft, and only send after approver clicks a button that triggers another webhook.
  • Replace OpenAI with deterministic business rules when compliance requires fully auditable decision logic.

A few final notes

This pattern gives you automated, auditable contract generation that keeps templates authoritative and recipients correct. For implementation help or to have Olmec Dynamics build and maintain this pattern across Airtable, Make.com, PandaDoc, and Notion, you can learn more about what we do at https://olmecdynamics.com. If you want a related pattern for PDF generation from Google Docs and PandaDoc signature flows, see our guide on generating PDFs and sending via PandaDoc. For advanced triage and classification tied to Notion and PandaDoc, see our contract triage pattern using OpenAI and Slack.