How to Build No-Code HR Workflows with Make and PandaDoc: Step-by-Step Guide

HR document workflows eat 25–30% of every HR team’s available hours, according to McKinsey Global Institute research on knowledge worker time allocation. That is not a productivity problem — it is a process architecture problem. The fix is not working faster; it is removing the manual steps entirely. This guide shows you exactly how to build that automation spine using Make™ as the orchestration layer and PandaDoc as the document engine. For the broader strategy behind this approach, start with our HR document automation strategy guide.

Before You Start: Prerequisites, Tools, and Risks

Before opening Make™ or PandaDoc, confirm you have these four prerequisites in place. Skipping this step is the primary reason implementations stall at testing.

• Active accounts: Make™ (Core plan or higher for multi-step scenarios) and PandaDoc (Business plan or higher for API access and template tokens).
• Source system access: API credentials or a native Make™ connector for your ATS, HRIS, or intake form tool. You need read access to the fields that will populate your document templates.
• Field mapping table: A spreadsheet that maps every source field name (e.g., candidate_first_name in your ATS) to its corresponding PandaDoc token name (e.g., {{FirstName}}). This document is your build blueprint.
• A completed PandaDoc template: At minimum one document template with all token placeholders already defined. Do not start building Make™ scenarios against a template that is still being edited.

Time estimate: First workflow configuration and testing, two to four hours for a user with no prior Make™ experience. Complex conditional branches add time.

Risk to manage: Missing or misformatted field values are the primary failure mode. A blank required field will generate a document with visible gaps or halt the scenario entirely. Build a validation gate before every PandaDoc document-creation step.

Step 1 — Define the Trigger Event That Starts the Workflow

Every Make™ scenario begins with a trigger — the specific event in a connected system that tells the automation to start. Choose the wrong trigger and your workflow fires at the wrong time or not at all.

For HR document workflows, the most reliable triggers are:

• ATS status change: A candidate moves to “Offer Extended” or “Hired.” This is the most common trigger for offer letters and employment contracts.
• Form submission: An employee submits an intake form (e.g., Typeform, JotForm, or a native HRIS form). Use this for policy acknowledgments, onboarding questionnaires, and change-of-status requests.
• Webhook: A custom HTTP POST from any system that does not have a native Make™ connector. If your HRIS fires a webhook on status changes, connect it here.
• Schedule trigger: A date-based scenario for recurring documents — annual policy re-acknowledgment, performance review cycles, benefits renewal.

In Make™, open a new scenario, click the trigger module, search for your source application, and select the specific event type. Authenticate the connection using your API credentials or OAuth. Run a test trigger using a real or dummy record to confirm Make™ is receiving the expected data payload. Verify that every field you need for document population is present in the test output before moving to Step 2.

Common mistake: Using a webhook trigger without first documenting the exact JSON payload structure your source system sends. Map the payload fields before building downstream modules.

Step 2 — Validate and Transform the Incoming Data

Raw data from your source system is rarely in the exact format PandaDoc requires. Step 2 is a quality gate: validate that required fields exist and transform values into the correct format before they reach the document engine.

Add a Filter or Router module immediately after your trigger:

• Filter: Set a condition that only allows the scenario to continue if required fields (first name, last name, job title, start date, compensation) are all non-empty. If any field is missing, route the record to an error-handling branch that sends an alert to the HR team’s email or Slack channel.
• Router: Use this to branch the workflow based on employment type (salaried vs. hourly), location (state-specific compliance language), or role level (executive agreements vs. standard contracts). Each branch will point to a different PandaDoc template.

After the filter, add a Set Variable or Tools > Set Multiple Variables module to format values precisely:

• Format dates as MM/DD/YYYY or whatever your PandaDoc template expects.
• Capitalize names properly using Make™’s built-in string functions.
• Convert numeric compensation values to currency-formatted strings if needed.

This step is where most automation failures are prevented. Parseur’s research on manual data handling finds that data quality errors compound downstream — a single malformed field can cascade through every document generated in a batch run. Catching it here is non-negotiable.

For a deeper treatment of eliminating data errors at the source, see our guide on eliminating manual data entry in HR.

Step 3 — Generate the PandaDoc Document from a Template

With validated, formatted data in hand, you are ready to create the document. This is where the automation does its core work: merging live data into a structured template to produce a complete, professional HR document in seconds.

In Make™, add a PandaDoc > Create Document from Template module. Configure it as follows:

1. Select the template: Choose the PandaDoc template you prepared in the prerequisites step. If you set up a Router in Step 2, each branch will have its own Create Document module pointing to the appropriate template.
2. Map the tokens: For each token field in the template (e.g., {{FirstName}}, {{StartDate}}, {{AnnualSalary}}), map the corresponding variable from your Step 2 output. This is where your field-mapping spreadsheet pays off — you are executing a lookup, not guessing.
3. Set recipient details: Add the employee’s email address, name, and signing role. If the document requires a co-signer (manager, legal, finance), add that recipient and their role here.
4. Set document status: Choose “Draft” if you need an approval step before sending (Step 4 applies). Choose “Sent” if the document should go directly to the recipient after generation.
5. Set folder and naming convention: Define a consistent file name (e.g., OfferLetter_[LastName]_[StartDate]) and the PandaDoc folder where the document should be stored.

Run a test execution. Open the generated document in PandaDoc and verify every token resolved correctly, formatting is intact, and the correct recipient is listed. Do not proceed to Step 4 until the test document is indistinguishable from one you would have created manually.

For a focused walkthrough of the offer letter use case specifically, see our automated offer letter workflow guide.

Step 4 — Route for Approval Before Sending (When Required)

Not every HR document should go directly to an employee the moment it is generated. Compensation-sensitive documents, executive agreements, and any document with negotiated terms need a human review gate before the employee sees them.

Build the approval step between document creation and document sending:

1. Notification module: After the PandaDoc Create Document module completes, add an email or Slack notification to the designated approver. Include the PandaDoc document URL from the previous module’s output so the approver can review the draft directly in PandaDoc.
2. Wait/Webhook module: Add a Make™ webhook or a scheduled polling scenario that waits for the approver to take action. In PandaDoc, the approver can approve the document with a single click, which fires a webhook back to Make™.
3. Conditional branch: If approved, proceed to the send step. If rejected or flagged for revision, route to a notification that alerts the HR coordinator to correct the document.

This approval gate is the compliance layer of your workflow. Gartner research on HR technology governance consistently flags inadequate approval controls as a primary source of document compliance failures. Building the gate here — in the automation, not in someone’s memory — makes compliance structural rather than aspirational. This connects directly to our framework for automated document compliance.

Step 5 — Trigger Downstream Actions on Signature Completion

Document signing is not the end of the workflow — it is the starting gun for everything that comes next. When an employee signs their offer letter or onboarding agreement, that event should automatically initiate the downstream HR operational steps without any manual follow-up.

In Make™, create a second scenario (or extend the first using a webhook) triggered by the PandaDoc > Watch Document Status module, set to fire when a document reaches “Completed” status.

From that trigger, build the downstream action chain:

• HRIS record update: Mark the employee record as “Documentation Complete” or update the hire status in your HRIS.
• IT provisioning notification: Send an automated request to your IT helpdesk to create accounts and provision equipment, triggered the moment HR paperwork is signed — not when someone remembers to email IT.
• Onboarding task creation: Create a new project or task list in your project management tool with the employee’s name, start date, and manager pre-populated.
• Benefits enrollment trigger: Send the employee an automated email with benefits enrollment instructions and deadlines, timestamped from the signing date.
• Document archival: Push the completed, signed PDF to a designated folder in your cloud storage system, named according to your document retention policy convention.

Asana’s Anatomy of Work research finds that knowledge workers spend over 60% of their time on work coordination — status updates, follow-ups, and handoff communications — rather than skilled work itself. This downstream automation eliminates that coordination overhead entirely for every new hire that flows through the pipeline.

For the complete onboarding automation picture, see the PandaDoc and Make onboarding blueprint. For integrating your hiring systems end to end, see our guide on integrating your ATS with PandaDoc and Make.

How to Know It Worked: Verification Checklist

Run this verification sequence after your first live execution before allowing the workflow to process real employee records at volume.

• Document accuracy: Open the generated PandaDoc document. Confirm every token resolved to the correct value. Check for blank fields, formatting errors, and incorrect date formats.
• Recipient delivery: Confirm the signing email arrived in the correct employee inbox, not a spam folder, and that the signing link is functional.
• Approval routing: If applicable, confirm the approver received their notification and that the approval action correctly unblocked the send step.
• Completion trigger: Sign the test document yourself using a test email address. Confirm that the downstream actions (HRIS update, IT notification, task creation) all fired within the expected time window.
• Audit trail: In PandaDoc, open the document and review the activity log. Confirm timestamps, signer identity, and IP address are all captured.
• Error branch: Deliberately send a record with a missing required field. Confirm the error-handling branch fires and the alert reaches the designated HR contact.

If all six checks pass, the workflow is production-ready.

Common Mistakes and How to Avoid Them

These are the failure patterns we see most often when HR teams build this workflow for the first time.

Token name mismatches

The field name in your source system and the token name in your PandaDoc template must be explicitly mapped in Make™. They do not auto-connect. Build your field-mapping table before you open Make™ and execute it mechanically in the mapping step — do not rely on memory or intuition.

Skipping the validation gate

Running PandaDoc document creation directly off the trigger module, without a filter that checks for required fields, guarantees you will eventually generate a document with a blank compensation field or a missing name. That document will either go unsigned or, worse, get signed before anyone notices the error. For a comprehensive look at the compliance risks of document errors, see our guide on error-proofing HR documents.

Building one monolithic scenario

A single scenario that tries to handle triggers, validation, document creation, approval, sending, and all downstream actions becomes fragile and difficult to debug. Break the workflow into two or three linked scenarios: one for document generation through send, one for signature completion and downstream actions. Smaller scenarios are faster to troubleshoot and easier to update as your processes evolve.

Using a live template still in draft

If your PandaDoc template is still being revised when you connect it to Make™, every template change creates a risk of breaking token mappings. Lock the template before you build the scenario. Create a new template version for revisions and update the Make™ module to point to the new version after testing.

No error alerting

A scenario that fails silently is worse than no automation at all, because you lose the document without knowing it. Every workflow must have an error-handling path that notifies a human when a scenario fails. In Make™, use the error handler module or set up an email alert for any scenario that reaches an error state.

What Comes Next

This five-step workflow is the automation spine. Once it is running reliably, you have the foundation to layer on additional capability: conditional content blocks in PandaDoc that adapt document language by role or jurisdiction, AI-assisted data extraction for inbound documents, and multi-document onboarding packet generation from a single trigger event.

The ROI compounds as you extend the spine. A single workflow recovering 25–30% of an HR director’s week from document administration — as Deloitte’s human capital research and our own client work consistently confirm — creates the strategic capacity to focus on the judgment-intensive work that actually requires an HR professional. For a detailed breakdown of the financial return, see our analysis of HR document automation ROI.

The no-code approach described here is deliberately accessible. The tools exist. The integrations are pre-built. The only requirement is a willingness to map your process before you touch the software — and then follow the steps in order.