Automate Airtable to PandaDoc proposals in Make.com, require Slack approval, send for signature, then write PandaDoc IDs back to Airtable reliably.

Introduction

If you generate proposals from Airtable today, you probably have the same messy routine we see in real teams. Someone exports the Airtable fields, pastes them into a PandaDoc template run, double-checks totals, then sends it for signature. After that, you still have to update Airtable with a document link so everyone knows which proposal version was approved.

That process is slow, and it breaks in quiet ways, like duplicate documents after re-tries, totals not matching the line-item data, or missing fields that fail late. This guide walks you through an advanced Airtable to PandaDoc proposals integration XPA in Make.com that includes Slack approvals, proper payload mapping, and write-back to Airtable with an audit log.

By the end, you will know exactly how to trigger from Airtable, validate inputs, route approval in Slack, create the PandaDoc proposal, send for signature, and record PandaDoc document IDs back into Airtable.

What You'll Need

Airtable: a base with an Opportunities (or Orders) table and an optional linked line items table. You need fields to drive state and store outputs.
PandaDoc: a proposal template built with tokens/fields you can map from Airtable.
Slack: permission for Make.com (bot token) to post messages and for you to approve/reject.
Make.com: access to Airtable, PandaDoc, and Slack modules, plus the ability to run an advanced scenario.
Google Sheets (recommended): a log sheet for retries, outcomes, and errors.

Prerequisites and permissions:

In Make.com, you must connect Airtable, PandaDoc, and Slack accounts.
In Airtable, your automation user needs permission to read the trigger view and update the status and output fields.
In PandaDoc, your template must allow API/template-driven creation and sending for signature (based on your PandaDoc plan).

If you want the bigger picture for Cross-Platform Automation (XPA), start with Cross-Platform Automation (XPA).

How It Works (The Logic)

Your automation is one pipeline with guardrails:

Trigger: Make.com watches an Airtable view or status field, for example Ready for Proposal.
Action (validation): Make.com checks required Airtable fields and required line items.
Action (approval gate): Make.com posts to Slack and waits for an approve or reject decision.
Action (document generation): On approval, Make.com builds the payload and creates the PandaDoc document, then sends it for signature.
Action (write-back + audit): Make.com updates the Airtable record with PandaDoc Document ID and URL, sets the new status, and appends an audit row to Google Sheets.

Step-by-Step Setup

Step 1: Model Airtable for idempotency (so re-runs do not duplicate proposals)

In Airtable, create these fields on the main table (example: Opportunities):

Approval Status (single select): Ready for Proposal, Pending Slack Approval, Approved, Sent for Signature, Signed, Error
PandaDoc Document ID (text): blank initially
PandaDoc Document URL (text or URL)
Template Key (text): identifies which PandaDoc template to use
Last Error (long text)
Last Run Timestamp (datetime)

If you have line items, create a linked table (example: Opportunity Line Items) with quantity, unit price, description, and link back to the opportunity.

Idempotency rule you enforce in Make:

Before creating a PandaDoc document, check PandaDoc Document ID. If it exists, skip create and either update or route to a “already processed” path.

Step 2: Ensure your PandaDoc template can accept mapped fields

In PandaDoc, build the proposal template using consistent tokens for:

Client details (name, email, address)
Opportunity details (proposal number, dates, totals)
Line items (structured section that can be populated from a payload)

Tip from production builds: keep the data model stable. If you change Airtable field names or token naming, you will break mappings during the next template update.

Step 3: Build the Make.com scenario skeleton

In Make.com:

Create a new scenario.
Add an Airtable trigger that starts when a record is in Ready for Proposal.
Add a filter immediately after the trigger:
- Approval Status equals Ready for Proposal
- PandaDoc Document ID is empty (or route when not empty)

Gotcha: if you filter only on “any change,” you will re-run for edits that are not meant to generate a new document.

Step 4: Add required field validation (before Slack and PandaDoc)

Add a validation step:

Check for required fields like customer email, customer name, template key, proposal dates, and at least one line item.

In Make, implement this as:

Retrieve or reference the trigger record fields.
Add logic to detect missing values.
Route missing-field failures to an error branch.

On failure branch:

Update Airtable Approval Status to Error
Write Last Error
Append a row to Google Sheets audit log (include Airtable Record ID and timestamp)

This is what makes the XPA debuggable, not just “it runs.”

Step 5: Post an approval request in Slack and wait for response

Add Slack modules for approval routing:

Post a message to your chosen channel (proposal approvals channel).
Include key details in the message so the reviewer can decide quickly:
- Opportunity name
- Total amount
- Template key
- Link or reference to the Airtable record
Capture the approval outcome.

Implementation pattern in Make:

Create two branches:
- Approved branch
- Rejected branch

On Approved:

Update Airtable Approval Status to Pending Send

On Rejected:

Update Airtable Approval Status back to Ready for Proposal or Pending Changes
Write a reason into Last Error or a dedicated Rejection Reason field
Log the decision into the audit sheet

Step 6: Fetch line items and build the PandaDoc payload

If your line items live in a linked Airtable table:

Add a step to fetch all line items for the opportunity record.
Transform them into the structure your PandaDoc template expects.

In Make, you will usually do this with:

mapping transformations for simple fields
a data transformation step when you need to build an array of rows

Gotcha: do not pass raw rich text into tokens. Convert to plain strings, and ensure numeric values are numbers, not formatted strings, so totals match.

Step 7: Create the PandaDoc document from the template

Add the PandaDoc module to create the document:

Choose the PandaDoc template based on Airtable Template Key.
Map Airtable fields to PandaDoc tokens.
Use the line items array payload for the proposal items section.

Capture:

PandaDoc Document ID
PandaDoc Document URL

Also, write these immediately to Airtable on success:

PandaDoc Document ID
PandaDoc Document URL
update Approval Status to Sent for Signature

PandaDoc document creation via Make is covered in the integration docs: PandaDoc in Make.com and PandaDoc Make.com help.

Step 8: Send for signature

Right after create:

Call the PandaDoc send for signature step.
Ensure the recipient contact fields (from Airtable) are mapped correctly.

Do not merge send into Slack approval posting. Create first, send second, write-back third. That separation reduces partial failures.

Step 9: Append an audit log row to Google Sheets

Add a Google Sheets step to append an audit row for every processed attempt (success and failure paths if possible).

Recommended columns:

Airtable Record ID
Opportunity name
Run timestamp
Approval outcome (approved/rejected/error)
Template key
PandaDoc Document ID
PandaDoc URL
Error message (blank on success)

If signatures take time, you can also add a second scenario later to sync Signed status back into Airtable.

Step 10: Add retry rules and an error handler path

Configure Make scenario settings:

turn on retries for transient errors (timeouts, rate limits)
set a safe retry count so you do not spam PandaDoc

Add a top-level error handler branch:

Update Airtable Approval Status to Error
Write Last Error
Notify Slack only with a short alert, full details in the audit sheet

Real-World Business Scenario

A UK B2B services firm used this exact pattern for monthly retainer proposals. Their sales team updated opportunities in Airtable, including line items for hours, rates, and start dates.

Before the XPA, the proposals took manual copy-paste and version tracking. After the Airtable to PandaDoc proposals automation was deployed:

each “Ready for Proposal” record triggered Slack approval
the reviewer checked the pricing in Slack and approved
Make.com generated the PandaDoc proposal from the template, then sent for signature
Airtable now stored the PandaDoc Document ID and URL automatically, so the team always knew what was signed

The biggest win was operational trust. When something failed, the audit log explained why and which record was affected.

Common Variations

Multiple templates by product type: keep Template Key in Airtable, branch to different PandaDoc templates based on deal category.
Approval only above a threshold: if total amount is under (for example) £5,000, skip Slack and generate directly.
Two-scenario design for signature status: Scenario 1 creates and sends, Scenario 2 polls or receives updates from PandaDoc to mark records as Signed in Airtable.

Your Airtable to PandaDoc proposals XPA, working the way it should

You built a production-style Airtable to PandaDoc proposals Cross-Platform Automation (XPA) in Make.com with a Slack approval gate, strict validation, idempotent write-back, and an audit trail in Google Sheets. That combination is what keeps document workflows reliable when people retry, fields change, and signatures take time.

If you want this kind of end-to-end XPA implemented for your stack, Olmec Dynamics builds these workflows for teams that need document automation to be traceable and maintainable. You can explore more at Olmec Dynamics and Cross-Platform Automation (XPA).

How to Automate Airtable to PandaDoc Proposals Using Make.com and Slack