Olmec Dynamics
S
·6 min read

Shopify to PandaDoc: Automate Sales Proposals from Orders Using Make.com

Learn how to automate converting Shopify orders into PandaDoc proposals using Make.com. Get trigger steps, field mappings, idempotency, and signature routing.

Introduction

If you still generate sales proposals manually from Shopify orders, you know the pain points. You pull order details, copy them into a PandaDoc template, adjust line items, and chase signoffs. It works when volumes are low, but as orders scale, errors creep in and the process becomes a bottleneck. This guide shows you a practical end-to-end Make.com pattern that converts new Shopify orders into PandaDoc proposals, maps data precisely, guards against duplicates, and routes for signatures automatically. By the end you’ll know the exact modules, field mappings, and failure paths to run this in production.

This is a genuine Cross-Platform Automation (XPA) styled workflow. Shopify triggers feed PandaDoc templates, Make.com handles orchestration, and PandaDoc delivers the document for signature while an auditable log keeps everyone aligned. If you want to see variations of this approach, check our related patterns in this guide.

What You'll Need

  • A Shopify store with permissions to read orders and trigger webhooks or events
  • A PandaDoc account with a template ready for merge fields that match your data model
  • A Make.com account with connected Shopify, PandaDoc, and a logging destination (Google Sheets or Notion)
  • An auditable log path (Google Sheets or Notion) to store document IDs, statuses, and timestamps
  • Optional: a Notion or Google Sheets log for a historical trail; we’ll use Google Sheets in this example for simplicity

Note: PandaDoc templates require proper merge field keys and recipient roles. If you plan signature routing, define recipient roles in PandaDoc and map them exactly in Make.com.

How It Works (The Logic)

Trigger: A new Shopify order is created. Action: Make.com formats the order data, creates a PandaDoc document from a template, and writes the PandaDoc document ID back to an auditable log. If you want customers to sign automatically, you can route the document for e-signature as part of the same flow. Finally, post a lightweight Slack notification or update a Notion page to confirm that the proposal exists and is in flight.

Key design goals: idempotency (only create once per order), deterministic field mappings, and a clean rollback path if something goes wrong.

Step-by-Step Setup

  1. Create a dedicated PandaDoc template
  • Ensure you have merge fields that line up with your Shopify payload, such as client_name, client_email, order_number, order_total, currency, and a line_items table if you need itemized pricing.
  • Define recipient roles in the template (for signing if needed) and note exact field keys to map in Make.com.
  1. Prepare the Shopify trigger in Make.com
  • Create a Scenario and add the Shopify trigger for a new order (or orders/paid if you want to trigger on revenue events).
  • Connect to your store and confirm permission to read orders.
  • Ensure you capture key fields: order_id, order_number, created_at, customer_name, customer_email, total_price, currency, and a link to the order.
  1. Add a transformer to normalize data
  • Use a Tools or Formatter step to standardize dates to ISO 8601, currency formatting, and line-item summaries.
  • Build a single payload object for downstream mapping with fields like: order_id, order_number, customer_name, customer_email, total_price, currency, line_items_summary.
  1. Create PandaDoc document from template

  • Add a PandaDoc action: Create Document from Template.

  • Map fields from the normalized payload into PandaDoc merge fields. Example mappings:

    • client_name → CustomerName field in PandaDoc
    • customer_email → Recipient email
    • order_number → an OrderNumber field or as part of the document name
    • total_price and currency → Amount fields
    • line_items_summary → a merge field or a dynamic table in PandaDoc

  • If you want automatic sending, chain a Send Document step after creating the document and map recipients from the payload.

  1. Capture PandaDoc outputs
  • Save returned document ID and document URL to variables for later log writes and audit trails.
  1. Write an audit row
  • Add an action to write a row in Google Sheets (or Notion) with: order_id, order_number, customer_name, PandaDoc_document_id, document_url, status, timestamp.
  • This becomes your source of truth for the lifecycle of the proposal.
  1. Update Shopify or the log with status
  • If you maintain a separate Shopify field indicating a proposal state, update it. If not, rely on the Google Sheet/Notion log for status visibility.
  1. Slack or Notion notification (optional but recommended)
  • Post a concise message to a channel like #sales-proposals with the order number and a link to the PandaDoc document. Example: New proposal created for Order #{{order_number}}. View: {{document_url}}
  1. Add a robust error path
  • If the PandaDoc create or send step fails, route to an error branch:
    • Write an error row to the log
    • Post to a dedicated Slack channel for ops
    • Optionally throttle retries with exponential backoff
  1. Test and validate
  • Create a test Shopify order and verify:
    • The PandaDoc document is created with correct field mappings
    • The document URL is captured in the log
    • The log shows a single row for the order (no duplicates on retry)
    • The Slack notification (if enabled) shows the right details
  1. Move to production
  • Once verified, turn on the scenario with a sane run frequency (depending on your order volume) and monitor the first 24 hours for anomalies.

Real-World Business Scenario

A mid-market retailer used this pattern to convert every new Shopify order into a PandaDoc proposal automatically. The sales rep received a PandaDoc draft link, and the customer received a checkout-ready proposal within minutes of order placement. The audit log replaced manual clipboard-based reporting, and the team reported a 40–60% faster proposal cycle for standard orders and a clear path for escalations on high-value deals.

To see how similar patterns are implemented, check our guidance on generating PDFs from Google Docs and PandaDoc here and our Airtable to PandaDoc contracts pattern here.

Common Variations

  • Add a pricing table by passing a line_items array to PandaDoc and rendering a dynamic pricing section in the template.
  • Route high-value orders to a separate approvals channel or require a manual signature gate before sending.
  • Extend with a customer email follow-up that includes a copy of the final PandaDoc link and a timestamp.

What this means for your ops

You now have a scalable, auditable path from Shopify orders to PandaDoc proposals via Make.com. It reduces manual data entry, decreases the time from order to proposal, and provides a reliable log for governance and analytics. If you want this exact pattern tailored to your Shopify store, PandaDoc templates, and signature requirements, Olmec Dynamics builds these automations for real businesses. Learn more at Olmec Dynamics.

For related patterns and deeper dives, see our Shopify to Google Sheets and Slack integration guide here.