How to Automate NDA Generation with PandaDoc and Make: A Step-by-Step HR Guide

Manual NDA generation is not a minor inconvenience — it’s a compounding tax on every hire, contractor engagement, and partnership you close. When a recruiter drafts, routes, chases, and files NDAs by hand, they lose hours that should go toward candidates. When a document lands with wrong data because someone copy-pasted from the wrong record, the legal exposure is real. This guide shows you how to eliminate both problems using PandaDoc’s document engine and Make™ as the automation layer — and how that build connects to your complete HR document automation strategy.

Follow the steps below in sequence. Each step is a discrete action. Do not skip the verification section at the end.

Before You Start: Prerequisites, Tools, and Time

Confirm these prerequisites before opening a single module. Building without them creates rework.

• PandaDoc account: Business tier or above is required for API access and conditional content blocks.
• Make™ account: Any paid tier supports the modules used here. Free tier has scenario run limits that will create gaps in a production workflow.
• System of record access: You need API credentials or export access for whichever system will trigger the workflow — ATS, HRIS, Google Sheets, Airtable, or a web form tool.
• PandaDoc API key: Generated in PandaDoc → Settings → Integrations → API. Keep it in a secure credential store, not hardcoded in your scenario.
• Approved NDA template: Legal must sign off on the template before you automate its distribution. Automation amplifies whatever is in the template — including errors.
• Time estimate: A foundational single-signer scenario takes a few hours to build and test. Multi-signer routing with reminder cadences and HRIS write-back adds additional time. Map the scope with an OpsMap™ session before committing to a build timeline.
• Risk note: Test every scenario with sandbox documents and test recipient email addresses. Never run an untested scenario against live candidates or partners.

Step 1 — Build and Lock Your PandaDoc NDA Template

The template is the foundation. A template with unclear variable fields or legally unvetted conditional clauses will create problems that no automation can fix. Get this right before touching Make™.

Open PandaDoc and create a new template from scratch or import your existing approved NDA as a base. Then:

1. Identify every field that changes per signer: Recipient name, recipient title, company name, effective date, governing law jurisdiction, and signer type (candidate, contractor, partner) are the most common variables.
2. Convert those fields to PandaDoc variables: Wrap each variable in double curly braces — {{recipient_name}}, {{company_name}}, {{effective_date}}. These are the field names Make™ will populate at document creation time.
3. Add conditional content blocks for signer type: If your NDA must serve candidates, contractors, and partners, use PandaDoc’s conditional content feature to show the mutual NDA clause only when {{signer_type}} equals “partner” and the one-way clause when it equals “candidate” or “contractor.” One template, multiple document variants — no manual clause swapping.
4. Set up signature fields and date fields: Assign at least one recipient signature role and one date field. If your NDA requires a countersignature from an internal approver, add a second signer role now.
5. Lock the template after legal approval: PandaDoc allows template locking so senders cannot edit approved content. Enable this to preserve legal integrity across all automated sends.

Document your variable names in a shared reference — you will need the exact names when building your Make™ scenario in Step 4.

Step 2 — Identify and Configure Your Trigger Source

Every automated NDA starts with a trigger — an event in an upstream system that tells Make™ “a new NDA is needed right now.” Choose the trigger that matches your existing workflow, not the one that sounds most sophisticated.

Common trigger options:

• ATS stage change: Candidate moves to “Offer” or “Pre-Hire” stage → Make™ detects the change via webhook or polling and initiates the NDA sequence. This is the cleanest trigger for recruiting NDAs because it fires at the right moment in the hiring pipeline.
• Google Sheets / Airtable row added: An ops coordinator adds a row for a new contractor or partner engagement → Make™ watches the sheet for new rows and fires. Low-friction starting point for teams without ATS API access.
• Web form submission: A partner or contractor submits an intake form → Make™ receives the form data via webhook and routes it into the NDA sequence. Useful for inbound partner onboarding.
• HRIS event: A new hire record is created in your HRIS → Make™ detects it via API and triggers an NDA alongside other onboarding documents. Aligns NDA delivery with the broader onboarding event stream covered in our guide to PandaDoc and Make onboarding automation.

Whatever trigger you choose, confirm that it reliably fires at the correct moment and that the payload it sends includes every variable your PandaDoc template requires. Missing payload fields at the trigger level are the primary cause of blank-field documents.

Step 3 — Map Your Data Fields Before Building the Scenario

Data mapping is where most automation builds fail or slow to a crawl. Do this on paper or in a spreadsheet before opening Make™.

Create a two-column table:

Every template variable must map to a source. If a field has no source, decide now whether it is a static value (hardcode it in Make™) or a field that must come from the trigger payload (update your trigger source to include it). Attempting to resolve mapping gaps inside the scenario builder is slow and error-prone. Resolve them here.

This discipline is core to eliminating manual data entry in HR workflows — the mapping table makes the data flow explicit before a single module is configured.

Step 4 — Build the Make™ Scenario

Open Make™ and create a new scenario. The core sequence has five modules. Build them in order.

Module 1: Trigger

Add the trigger module matching your source from Step 2. If using a webhook, copy the webhook URL into your trigger system. If polling an ATS or spreadsheet, set the polling interval — every 15 minutes is a reasonable default for recruiting workflows. Run the trigger once to capture a sample payload and confirm all required fields are present in the output.

Module 2: Data Validation Filter

Add a Filter module immediately after the trigger. Set conditions that must be true before the scenario continues:

• Recipient email is not empty
• Recipient email matches a valid email format (Make™’s built-in email validation or a regex filter)
• Recipient name is not empty

If any condition fails, the scenario stops before a document is created. Connect a separate error-handler route that posts a Slack message or adds a row to a “Review Required” spreadsheet with the failed record’s details. A failed record that surfaces for human review is a feature — it means your validation caught a bad record before it became a bad document.

Module 3: PandaDoc — Create Document from Template

Add the PandaDoc “Create Document from Template” module. Connect your PandaDoc API key. Select your approved NDA template. Map each template variable to the corresponding field from your data map in Step 3 — use Make™’s data mapping panel to reference the trigger payload fields directly. Set the document name dynamically: NDA — {{recipient_name}} — {{effective_date}} makes every document identifiable without opening it. Set the recipient’s name, email, and signing role to match the first signer. If a countersignature is required, add the second recipient here.

Module 4: PandaDoc — Send Document

Add the PandaDoc “Send Document” module immediately after document creation. Pass the document ID output from Module 3 as the input. This fires the signing email to the recipient. Configure the email subject and body in PandaDoc’s template settings rather than in Make™ so legal or HR can update messaging without touching the scenario.

Module 5: Notification and Logging

Add a final module that records the send event. Options include:

• Add a row to a Google Sheet log with recipient name, email, document ID, and send timestamp
• Post a Slack message to a recruiting channel: “NDA sent to [Name] — [timestamp]”
• Update the ATS record with a “NDA Sent” status tag if your ATS supports write-back

Save the scenario. Do not activate it yet.

Step 5 — Add Automated Reminder Cadence

An NDA sitting unsigned in an inbox for 48 hours is a stalled pipeline, not a pending signature. Build the reminder logic as a separate Make™ scenario that runs on a schedule.

1. Create a new scenario with a Schedule trigger — set to run every 24 hours.
2. Add a PandaDoc “List Documents” or “Get Document” module that retrieves documents in “sent” status older than your threshold (48 hours is a defensible default for recruiting NDAs).
3. Add an Iterator module to loop through each overdue document.
4. Add an email or Slack module that sends a reminder to the original recipient. Keep the message brief and action-oriented: a link back to the document, a deadline, and a contact for questions.
5. Add a filter that caps reminders at two per document — a third reminder at 96 hours should route to the recruiter for a personal follow-up rather than another automated message.

This reminder architecture is one of the highest-ROI steps in the entire build. Manual follow-up on unsigned documents is inconsistent and time-intensive — automating it removes a recurring task from the recruiter’s queue without reducing the effectiveness of the follow-up. The same logic applies to real-time document tracking across all HR document types.

Step 6 — Automate Signed-Copy Filing and HRIS Update

When the NDA reaches “completed” status in PandaDoc, two things must happen automatically: the signed document must be filed in a retrievable location, and the candidate or contractor record must be updated. Manual filing after the fact defeats the compliance purpose of the automation.

1. Create a third Make™ scenario triggered by a PandaDoc webhook — specifically the document_state_changed event with status = “completed.”
2. Add a PandaDoc “Download Document” module to retrieve the signed PDF.
3. Add an upload module for your document storage system — Google Drive, SharePoint, or your HRIS document vault. Use a dynamic folder path that organizes by employee name or hire date: /HR/NDAs/2025/{{recipient_name}}.
4. If your HRIS supports API write-back, add a module that updates the candidate or employee record with NDA completion status and the document URL. This is the same HRIS integration principle covered in our guide to integrating payroll and document automation.
5. Add a final notification to the recruiter or HR coordinator confirming that the NDA is signed and filed.

The result: from the moment a candidate enters the offer stage to the moment their signed NDA is in the document vault, no human touches the process. Parseur’s research on manual data entry costs puts the overhead of manual document handling at approximately $28,500 per employee per year when accounting for time, error correction, and compliance overhead — automation at this layer directly attacks that cost.

How to Know It Worked: Verification Checklist

Run these verification steps with test records before activating any scenario in production.

• ☐ Trigger fires correctly: Add a test record in your source system. Confirm the Make™ scenario run log shows a successful trigger with the expected payload.
• ☐ Validation filter blocks bad records: Submit a test record with a blank email. Confirm the scenario stops at the filter and routes to your error log — confirm no document was created in PandaDoc.
• ☐ Document fields populate correctly: Open the test document in PandaDoc. Confirm every variable field shows the correct value — no blank fields, no {{undefined}} placeholders, no date format mismatches.
• ☐ Conditional content renders correctly: If you built signer-type conditionals, test with a “partner” record and a “candidate” record. Confirm the correct clauses appear in each document.
• ☐ Signing email arrives and is actionable: Sign in as the test recipient. Confirm the email arrived, the subject line and body are correct, and the embedded signing link opens the correct document.
• ☐ Reminder scenario fires at threshold: Advance the test document’s sent timestamp manually or wait out the threshold. Confirm the reminder email arrives and contains a working document link.
• ☐ Signed-copy files in the correct folder: Complete the signature on the test document. Confirm the signed PDF appears in the correct storage folder within two minutes of completion.
• ☐ HRIS or ATS record updates: Confirm the candidate or contractor record reflects NDA completion status and document URL.
• ☐ Run log shows no errors: Review all three Make™ scenario run logs. No errors, no incomplete executions, no skipped bundles.

If any step fails verification, stop. Diagnose the failure in the Make™ run log, fix it, and re-run the affected test before moving to the next scenario in production. A scenario that passes nine of ten verification steps is not ready for production.

Common Mistakes and How to Avoid Them

Mistake 1: Skipping Legal Review of the Template

Automation distributes documents at scale. A legally problematic clause in an unreviewed template gets sent to every recipient before anyone notices. Lock the template only after qualified legal counsel has reviewed and approved it. The automation is not the legal layer — the template is.

Mistake 2: Hardcoding Your API Key in the Scenario

Make™ supports a dedicated credential store. Use it. A hardcoded API key in a scenario that gets shared or exported becomes a security exposure. Store credentials in Make™’s connection manager and reference the connection — never paste the key string directly into a module field.

Mistake 3: Building Multi-Signer Logic Without Testing Every Signer Path

If your NDA has a countersignature step, test the full path: recipient signs, countersigner receives notification, countersigner signs, document completes. Many builds test the recipient path but not the countersigner notification. The gap surfaces during a live signing event with a real candidate — not a good time to discover a broken module.

Mistake 4: No Error Handling on the Filing Module

Google Drive and SharePoint both have API rate limits and occasional transient failures. If the filing module fails silently, the signed document exists in PandaDoc but not in your document vault. Add an error handler on the filing module that retries on failure and alerts a human if the retry fails. Signed documents must be in the vault — this is not a best-effort operation.

Mistake 5: Treating the NDA Automation as Isolated

The NDA workflow uses the same Make™ and PandaDoc infrastructure that will handle automated offer letters, onboarding packets, and broader employee agreements. Build it with reuse in mind — modular scenarios, consistent naming conventions, and a shared credential connection — so the NDA build becomes the foundation for the next five document automations rather than a one-off.

Scaling Beyond the NDA: What Comes Next

The three-scenario architecture built here — trigger-and-create, reminder cadence, completion-and-file — is the reusable backbone of every HR document automation. Once the NDA flow is verified and running in production, the next priorities are:

• Offer letters: Trigger from ATS offer stage, populate compensation and start date fields, route for countersignature, file to HRIS. The architecture is identical to the NDA flow with added conditional logic for compensation type. See our guide to automated offer letters with PandaDoc and Make.
• Onboarding packet: Trigger from HRIS new hire record, generate a bundle of day-one documents, route each for signature in sequence. The reminder cadence scenario runs unchanged.
• Policy acknowledgments: Annual re-acknowledgment of handbook updates at scale — one Make™ scenario, one PandaDoc template with dynamic policy version variable, thousands of documents sent and tracked without manual intervention. The full architecture is covered in our employee handbook automation guide.

The compounding return on this infrastructure is the core argument for building it deliberately. Asana’s Anatomy of Work research finds that knowledge workers spend more than 60% of their time on coordination work — the routing, chasing, and filing that surrounds actual productive output. Each document workflow you automate removes a category of that coordination overhead permanently. McKinsey Global Institute research on automation potential in knowledge work consistently identifies document-handling tasks as among the highest-priority automation targets precisely because they are high-frequency, rule-based, and currently executed manually at significant time cost.

The NDA workflow is the entry point. Build it correctly, verify it thoroughly, and the case for automating every document in your HR stack becomes self-evident.

For the full strategic framework — including how NDA automation fits into a compliant, scalable document pipeline across the entire employee lifecycle — see our complete HR document automation strategy guide. For a broader view of how document automation reduces compliance exposure across all document types, see our resource on error-proofing HR documents through automation, and for a breakdown of financial returns, our analysis of measuring the ROI of HR document automation.