How to Automatically Create PandaDoc Drafts from Airtable and Route Approvals in Slack Using Make.com

Introduction

When contract requests still arrive in Airtable and someone has to open the row, pick the right template, fill the fields, send the PandaDoc, and chase approval in Slack, the work looks simple but eats time. The real pain is not the document itself, it is the back-and-forth between ops, sales, and legal when the wrong version gets sent or a draft goes out before sign-off.

This is a good place for Cross-Platform Automation (XPA), because the workflow spans multiple systems, but the decision logic stays simple: one Airtable record should produce one PandaDoc draft, one approval message, and one audit trail.

By the end of this guide, you will know how to build an Airtable to PandaDoc XPA in Make.com that creates a draft document, routes it to Slack for approval, and stores the run in Notion without duplicates.

What You'll Need

• Airtable base with a table for contract requests
• PandaDoc account with API access and prebuilt templates
• Make.com account with Airtable, HTTP, Slack, Notion, and Google Drive connections
• Slack workspace with a channel for approvals
• Notion database for audit logging
• Google Drive folder for raw JSON and exported PDFs
• PandaDoc template roles already defined, because recipient roles must match the template exactly
• A Make.com plan that supports webhooks, error handlers, and enough operations for production use

PandaDoc API access and template work generally require a paid PandaDoc plan. If you want this to run reliably at volume, do not try to squeeze it into a toy setup.

How It Works (The Logic)

When a record enters an Airtable view like Ready for contract draft, Make.com reads the row, validates the required fields, checks whether that Airtable record has already been processed, and then calls PandaDoc to create a draft from the correct template.

After the draft is created, Make.com posts an approval message to Slack with the draft link and key fields. Once a human approves, a second path updates PandaDoc to send the document or marks the record as approved in Notion.

Trigger: Airtable view change → validate data → dedupe by record ID → create PandaDoc draft → save artifact to Drive → post Slack approval message → log to Notion.

Step-by-Step Setup

1. Prepare the Airtable table and approval view

Create a dedicated view in Airtable, for example Ready for draft, and filter it so only rows ready to process appear there. Add fields like:

• request_id
• client_name
• client_email
• contract_type
• template_key
• status
• approved_by
• approved_at
• pandadoc_document_id
• pandadoc_url

Keep the view stable. If you move fields around later, you can break your mapping in Make.com.

2. Set up a Notion audit database first

Before you build the scenario, create a Notion database with properties for:

• Airtable record ID
• request_id
• template_key
• PandaDoc document ID
• approval status
• Slack message timestamp
• Drive file link
• created_at
• last_error

This gives you a single place to check whether a contract was already drafted.

3. Start the Make.com scenario with Airtable Watch Records

Add the Airtable module Watch Records and point it at the table plus the Ready for draft view.

Map the fields you need into scenario variables right away:

• Airtable record ID
• client name
• client email
• template key
• contract type
• effective date
• total value

Gotcha: if your Airtable view returns empty optional fields, treat them as blank strings or nulls before building the PandaDoc payload.

4. Add a dedupe check before anything else

Use either Notion search or an Airtable lookup table to see whether this record has already been processed.

The cleanest approach is to search by the Airtable record ID or request_id. If a matching run exists with status draft_created or sent, stop the scenario.

That one check saves you from duplicate PandaDoc drafts when Airtable re-triggers the same row.

5. Choose the PandaDoc template with a simple rule set

Use a Router in Make.com or a lookup table to map template_key to the correct PandaDoc template UUID.

For example:

• msa → Master Services Agreement template UUID
• sow → Statement of Work template UUID
• nda → NDA template UUID

If your process has more than three templates, keep the mapping in Airtable or Google Sheets so you can change it without editing the scenario.

6. Create the PandaDoc draft with HTTP

Use Make.com HTTP > Make a request and call PandaDoc's create document endpoint.

Use:

• Method: POST
• URL: PandaDoc create document endpoint
• Headers: Authorization: API-Key YOUR_KEY and Content-Type: application/json

Build the payload with:

• name: something like {{contract_type}} - {{client_name}} - {{request_id}}
• template_uuid: the selected template UUID
• recipients: one object per role defined in the PandaDoc template
• fields: your merge field values

Field mapping example:

• CompanyName → Airtable client name
• ClientEmail → Airtable client email
• EffectiveDate → formatted Airtable date
• DealValue → Airtable total value

Important: the recipient role must match the role name in PandaDoc exactly. If your template says Client, do not send buyer.

7. Save the raw payload and response to Google Drive

Add a Google Drive step to store two files for every run:

• Raw request JSON
• PandaDoc response JSON

If PandaDoc returns a downloadable PDF or document preview link, store that too. This gives you a clean debug trail when somebody asks, “What exactly got sent?”

8. Post the approval request to Slack

Add Slack > Post a Message to your approval channel.

Include:

• Client name
• Contract type
• Template used
• PandaDoc draft link
• Airtable record link
• Who should approve next

A compact message is enough:

New draft ready for approval: Acme Ltd, MSA, request #A-1842. Open draft: {{pandadoc_url}}. Review record: {{airtable_url}}.

If you want cleaner approvals, add Slack buttons with a second webhook that routes the decision back into Make.com.

9. Update Notion with the draft status

After the PandaDoc create call succeeds, write a record to Notion with:

• draft_created
• PandaDoc document ID
• template UUID
• Slack message timestamp
• Drive links
• approval owner

That makes Notion your audit layer, while Airtable stays the working queue.

10. Build the approval branch

Create a second route for approved drafts.

When approval is received, update the Notion record and, if your process requires it, call PandaDoc to move from draft to sent. If you do not want full-send automation, leave PandaDoc in draft and let a human send it manually after review.

That is often the safer pattern for legal-heavy documents.

11. Add error handling and manual review routing

If PandaDoc rejects the payload, or a required field is missing, route the run to a failure branch.

In the failure branch:

• Mark the Notion record as manual_review
• Write the error message into Notion
• Post a Slack alert to the ops channel
• Keep the Airtable row in needs_fix status

Do not silently retry document creation if the error is a bad recipient role or a missing merge field. That is how duplicate drafts get created.

Real-World Business Scenario

A professional services firm uses this exact pattern for SOW approvals. Sales drops a signed scope request into Airtable, Make.com creates a PandaDoc draft from the right template, Slack routes it to legal for approval, and Notion stores the complete audit trail. The team cut document prep time by more than an hour per week and stopped sending the wrong template to the wrong client.

Common Variations

• Add a pricing table step before PandaDoc creation, pulling line items from Airtable linked records.
• Replace Slack approval with a ClickUp task if your operations team manages approvals in a project board.
• Add a PDF snapshot in Drive for archived drafts, using the same request data and template key for later review.

A cleaner approval flow for contract ops

This XPA keeps Airtable as the intake layer, PandaDoc as the document engine, Slack as the approval surface, and Notion as the audit record. That split works well when you need control without making the process fragile.

If you want this built properly, Olmec Dynamics sets up exactly these kinds of automations for businesses, including the edge cases that usually break on the second week. You can see how we work at Olmec Dynamics.

For a closely related pattern, see our guide on How to Generate and Send Contracts from Airtable to PandaDoc Using Make.com and Notion. If you need the PDF-first version before e-signature, this walkthrough on How to Generate a PDF from a Google Docs Template and Email It Using Make.com and PandaDoc is the next useful read.