How to Automate Employee Agreements with PandaDoc and Make: A Step-by-Step Guide

Manual employee agreement workflows are a documented liability — not just a time sink. Incorrect compensation figures, missed signature steps, and version-control failures are the direct output of copy-paste HR document processes. This guide shows you how to eliminate that risk entirely by building an end-to-end automated agreement pipeline using PandaDoc and Make™. It is one focused implementation within the broader HR document automation strategy — get the full framework there, then come back here to execute this specific workflow.

When this process is running correctly, a new hire moving to “Hired” status in your ATS fires a Make™ scenario that pulls their data, populates the right agreement template in PandaDoc, routes it to the correct signers, and writes the completed document back to your HRIS — without a single HR hand touching it. Here is exactly how to build it.

Before You Start

Do not open Make™ or PandaDoc until you have completed every item on this list. Skipping prerequisites is the single largest cause of rework in automation builds.

  • Tools required: PandaDoc account (Business tier or above for API access and conditional fields), Make™ account, access to your ATS or HRIS with API credentials, document storage system (Google Drive, SharePoint, or equivalent), and your legal-approved agreement templates in Word or PDF format.
  • Data source confirmed: Identify the single system of record for employee data — the place where name, title, compensation, start date, department, and employment classification live. Your automation is only as accurate as this source.
  • Agreement variants inventoried: List every agreement type you need to automate (offer letters, NDAs, contractor agreements, promotion letters) and every employee classification that requires a different template variant. This determines your routing logic.
  • Legal review completed: All templates must be approved by counsel before being built into PandaDoc. Automation scales whatever is in the template — errors scale equally fast.
  • Time estimate: Plan three to five hours for a single-document, single-trigger workflow with one signer. Multi-variant builds with HRIS write-back take one to two days.
  • Risk to flag: If your trigger system (ATS or HRIS) has inconsistent data hygiene — missing fields, irregular status updates — fix the data quality issue before building. The automation will expose every gap immediately.

Step 1 — Audit and Prepare Your PandaDoc Templates

Your PandaDoc templates are the foundation. Every subsequent automation step depends on merge fields being correctly named, positioned, and validated here first.

Open PandaDoc and create a new template for each agreement variant you identified in the prerequisites. For each template:

  • Insert merge fields for every piece of employee-specific data: {{recipient.first_name}}, {{recipient.last_name}}, {{job_title}}, {{start_date}}, {{base_salary}}, {{department}}, {{manager_name}}. Use PandaDoc’s token naming convention exactly — these names must match the field labels you will map in Make™ later.
  • Add signature fields and assign them to named roles (e.g., “Employee,” “HR Director,” “Hiring Manager”). Role names must be consistent across all templates.
  • Enable conditional content blocks for clauses that apply only to specific employment types — exempt overtime language, non-compete applicability by state, or contractor-specific IP assignment terms. PandaDoc’s conditional content feature handles this at the template level without requiring separate templates for every variant.
  • Preview each template with sample data to verify that all merge fields render correctly and no placeholder text bleeds through.

Store all finalized templates in a dedicated PandaDoc folder labeled by agreement type. Name every template with a consistent convention (e.g., “OFFER-FULLTIME-v3,” “NDA-CONTRACTOR-v2”) so your Make™ scenario can reference the correct template ID programmatically. You can also automate offer letters specifically by following the same template preparation steps with offer-letter-specific fields.

Verification: Send a test document from each template manually using PandaDoc’s built-in send feature. Every merge field should populate correctly. Every signer role should receive the document. If anything is missing, fix it now — not after you have built the Make™ scenario.

Step 2 — Configure Your Data Trigger in Make™

The trigger determines when your agreement automation fires. Get this right and the rest of the workflow runs itself. Get it wrong and agreements either never send or send at the wrong time.

Log into Make™ and create a new scenario. Select your ATS or HRIS as the trigger application. The most reliable trigger types for agreement automation are:

  • Webhook trigger: Your ATS or HRIS pushes a POST request to Make™ the moment a defined event occurs (candidate status changes to “Hired,” employee record is updated with a new title). Webhooks are real-time and the most reliable option when your source system supports them.
  • Watch Records trigger: Make™ polls your data source on a schedule (every 5–15 minutes) and fires when it detects a new or updated record matching your filter criteria. Use this when webhooks are unavailable.
  • Form/Typeform/Google Forms trigger: For organizations without an ATS, a structured intake form captures employee data and fires the scenario on submission.

After selecting your trigger, map every data field you need for the PandaDoc merge fields: first name, last name, email, job title, department, start date, compensation, employment classification, manager name and email, and HR contact email. Run the trigger once manually to capture a live data bundle. Confirm every field is populated before moving to Step 3.

To connect your ATS directly to PandaDoc through Make™, follow the detailed integration steps in the guide on how to integrate your ATS with PandaDoc.

Verification: Your scenario’s trigger module should show a successfully captured data bundle with no empty required fields. If any field is blank, trace it back to the source system and resolve the data gap before proceeding.

Step 3 — Build the Conditional Router for Agreement Variants

Most organizations have more than one agreement type. A Router module in Make™ handles the logic that assigns the correct PandaDoc template to each employee without HR intervention.

After your trigger module, add a Router module to your Make™ scenario. Create one route for each employment classification or agreement variant:

  • Route 1 — Full-Time Employee: Filter condition: Employment Type equals “Full-Time.” This route points to your full-time offer letter or employment agreement template ID.
  • Route 2 — Part-Time Employee: Filter condition: Employment Type equals “Part-Time.” Routes to the part-time variant.
  • Route 3 — Independent Contractor: Filter condition: Employment Type equals “Contractor.” Routes to the contractor services agreement, which typically requires IP assignment and 1099 language.
  • Route 4 — Catch-All / Error Alert: A final route with no filter that fires when none of the above conditions match. This route sends an alert to your HR team via email or Slack: “Agreement automation could not classify employee [Name]. Manual review required.”

The catch-all route is not optional. Without it, unclassified employees silently fall through the automation and receive nothing — and no one on your team knows. This is one of the core principles covered in the guide to error-proofing your HR documents.

Verification: Use Make™’s scenario testing tool to run a record through each route. Confirm that full-time, part-time, and contractor records each land on the correct branch and that a deliberately malformed test record triggers the catch-all alert.

Step 4 — Create the PandaDoc Document and Route to Signers

This is the core document-generation step. Each route from Step 3 feeds into its own PandaDoc “Create Document from Template” module.

For each route, add a PandaDoc — Create Document from Template module and configure it as follows:

  • Template ID: Enter the PandaDoc template ID for this agreement variant. Find it in PandaDoc under the template settings panel.
  • Document Name: Use a dynamic naming formula combining employee name and date: {{first_name}} {{last_name}} — Employment Agreement — {{start_date}}. This makes the document instantly identifiable in your storage system.
  • Recipients: Map the employee’s name and email to the “Employee” signer role. Map the HR director’s name and email to the “HR Director” role. Map the hiring manager’s data to the “Hiring Manager” role if applicable. Set the signing order: Employee first, then HR Director.
  • Fields (Merge Data): Map every PandaDoc merge field to the corresponding data value from your trigger bundle. Every field you inserted in Step 1 must be mapped here. Unmapped fields will render as blank in the sent document.
  • Send Immediately: Set the document to send upon creation so PandaDoc dispatches the signing request the moment Make™ generates the document.

Run a full end-to-end test using a real or realistic test record. Check that the document arrives in the test recipient’s inbox, that all merge fields are populated correctly, and that the signing interface works. For NDA-specific agreements, the NDA generation automation guide covers additional fields and routing nuances specific to that document type.

Verification: The test recipient receives a correctly populated, properly addressed agreement with a functional e-signature interface. No merge fields are blank or show placeholder text.

Step 5 — Set Up the Signed-Document Webhook and HRIS Write-Back

Sending the agreement is not the end of the automation. The closed loop — writing the completed document back to your systems and triggering follow-on actions — is where the real operational gains appear.

In PandaDoc, navigate to your workspace settings and configure a webhook for the document_completed event. Copy the webhook URL and paste it into a new Make™ scenario (or extend your existing one with a second scenario dedicated to post-signature processing).

When the webhook fires after the final signature is collected, build the following sequence in Make™:

  1. Download the signed PDF: Use the PandaDoc — Download Document module to retrieve the completed document as a PDF file.
  2. Upload to document storage: Route the PDF to your designated storage location. Structure the file path dynamically: /HR/Agreements/[Year]/[Department]/[LastName_FirstName_AgreementType].pdf. This makes retrieval straightforward during audits.
  3. Update HRIS employee record: If your HRIS supports API writes, add a module to update the employee record with agreement completion status and a link to the stored document.
  4. Trigger follow-on tasks: Fire subsequent actions — notify IT to begin account provisioning, add the employee to payroll onboarding, send a welcome email sequence, or mark the onboarding task complete in your project management tool.
  5. Notify HR: Send a Slack or email notification to the HR team confirming that the agreement is signed and filed, so they have visibility without being required to take action.

This write-back step transforms the agreement workflow into the first step of a complete onboarding spine, which connects directly to the processes outlined in the full onboarding document blueprint.

Verification: Sign a test document end-to-end. Confirm the PDF lands in the correct storage folder, the HRIS record is updated, and the follow-on notifications fire. Check the Make™ execution log to confirm no modules errored out.

Step 6 — Activate Error Handling and Monitoring

A scenario without error handling is not production-ready. This step prevents silent failures from becoming compliance gaps.

Within Make™, add error handlers to every module that interacts with an external system:

  • Right-click each critical module (the trigger, the PandaDoc create step, the HRIS write-back) and select “Add error handler.” Choose the Resume or Rollback handler based on whether the downstream step is recoverable.
  • Add a Slack or email alert module inside each error handler. The alert should include: which module failed, the employee record that triggered the failure, the error message returned by Make™, and a direct link to the execution log.
  • Set up Make™ scenario monitoring — enable email notifications for consecutive failed executions (3 or more) so you catch systemic issues, not just one-off errors.
  • Schedule a weekly audit: review the Make™ execution history for any scenarios with error rates above 2%. A clean workflow should run at 99%+ success after initial calibration.

Asana research on knowledge worker time use consistently shows that teams spend a significant portion of their week tracking tasks that automation should handle automatically. Error alerts convert monitoring from a manual task into a passive alert system — HR only intervenes when something actually breaks.

Verification: Deliberately introduce a bad data value (invalid email format) in a test run and confirm the error handler fires, the Slack alert arrives, and the execution log shows the correct failure point.

How to Know It Worked

Run three to five live agreement cycles through the complete automation before declaring it production-ready. Use this checklist to confirm success:

  • ☐ Trigger fires within the expected time window (real-time for webhooks, within one polling interval for Watch triggers) every time the source event occurs.
  • ☐ Every merge field in the sent document is populated with accurate, current data — no blanks, no stale values.
  • ☐ The correct agreement variant is routed to each employee classification without HR making the selection.
  • ☐ All designated signers receive the document in the correct signing sequence.
  • ☐ The signed PDF is stored in the correct folder path with the correct filename.
  • ☐ The HRIS record reflects agreement completion status after signing.
  • ☐ Follow-on tasks (IT provisioning notification, payroll queue, welcome email) fire automatically upon signing.
  • ☐ Error handlers are confirmed to alert HR when a module fails.
  • ☐ HR team has not touched the agreement at any point in the cycle.

If all nine items check out across multiple test cycles, activate the scenario for live use and disable any manual agreement preparation steps that existed before.

Common Mistakes and Troubleshooting

Mistake 1: Mismatched merge field names

The most common error. PandaDoc expects field tokens like {{job_title}}; Make™ may label the same field “Job Title” or “position” depending on the source system. Map field names explicitly in your Make™ data mapping step. Never assume the labels will match automatically.

Mistake 2: No catch-all route in the Router

Employees whose classification doesn’t match any Router filter silently receive nothing. Always build a catch-all route that sends an HR alert. This is the pattern that prevented the kind of payroll data error that cost David’s organization $27,000 — wrong data in, wrong document out, expensive consequence downstream.

Mistake 3: Skipping the void-and-reissue path

If an employee’s data changes after the agreement is sent but before signing — salary adjusted, title corrected, start date shifted — the HR team needs a documented process to void the in-flight document and trigger a new one. Build that path into the scenario from day one. It is not an edge case; it happens in virtually every hiring cycle.

Mistake 4: Using outdated template versions

PandaDoc templates referenced by template ID in Make™ do not update automatically when you revise the template. After any template change, verify whether the template ID has changed. Some PandaDoc plan tiers create a new ID on major revision. Update the Make™ module accordingly and test immediately.

Mistake 5: No monitoring after launch

Automation is not set-and-forget. Source systems change APIs, field names get renamed, and trigger events get restructured in software updates. Schedule a monthly review of execution logs and a quarterly test of the full workflow end-to-end. Parseur research on manual data entry costs puts the price of undetected data errors at $28,500 per employee per year — catching a broken automation early is not optional.

What This Workflow Makes Possible Next

Once employee agreements run automatically, the same infrastructure supports every other repeatable HR document — policy acknowledgments, benefits confirmations, annual compensation review letters. The architecture you built here (trigger → router → PandaDoc → write-back) scales directly to those use cases without rebuilding from scratch.

Review the HR document automation ROI analysis to quantify the capacity you have freed, and see how the compliance risk reduction through document automation compounds over time as every agreement generated carries a clean, consistent audit trail. The agreement workflow you have just built is the automation spine — everything else connects to it.