How to Automate New Hire Onboarding in Make.com™: Step-by-Step Guide

Manual onboarding coordination is one of the highest-volume, lowest-value tasks HR teams carry. SHRM research identifies onboarding as a primary driver of early attrition — and Gartner data consistently shows that structured, consistent onboarding directly accelerates time-to-productivity. The gap between what organizations intend to deliver and what new hires actually experience exists almost entirely because the process depends on human memory and manual hand-offs. This guide solves that. It walks through how to build a complete new hire onboarding automation in Make.com™ — from trigger to 90-day follow-up — so the experience is consistent, personalized, and self-executing. This satellite drills into the implementation layer of the broader Make.com™ for HR: automating recruiting and people ops strategy.

Before You Start

Attempting to automate a process that isn’t documented first produces automated chaos. Complete these prerequisites before opening Make.com™.

• Document every onboarding touchpoint. List every action that currently happens — or should happen — from offer acceptance through Day 90. Include who initiates it, what data it needs, what system it touches, and when relative to the start date it occurs.
• Audit your data sources. Identify which system will serve as the trigger and confirm that it captures these fields cleanly: full name, personal email, work email (or provisioning instructions), start date, department, role title, manager name and email, location, and employment type. Missing or inconsistent fields at the source break everything downstream.
• Confirm system API access. Make.com™ connects to most HR, IT, and communication systems natively. Verify that your ATS, HRIS, email platform, document-signing tool, and identity-management system have active Make.com™ integrations or exposed webhooks. Loop in IT for identity-provider permissions before build day.
• Estimate time and permissions. A foundational scenario takes one to two focused days to build and test. Plan for an additional half-day to configure error handling and run end-to-end verification. You’ll need admin access to Make.com™ and sufficient API permissions on each connected system.
• Create a test employee record. Before building, create a dummy hire record in your ATS or HRIS with realistic but fictitious data. You’ll use this to fire the trigger and validate every downstream step without affecting live employee data.

Step 1 — Map Your Onboarding Touchpoints into Logical Phases

Translate your documented touchpoints into three distinct phases: Pre-Day-1, Day-1 through Week-1, and the 30-60-90 cadence. This structure becomes the skeleton of your Make.com™ scenario.

Pre-Day-1 includes everything the new hire needs to complete before arriving — e-signature on offer letter and tax forms, benefits enrollment invitation, IT provisioning request, badge or access-card creation, and a welcome email from HR or their manager. These steps are time-sensitive and invisible to HR once automated, but their failure is the most visible to the new hire.

Day-1 through Week-1 includes system-access confirmation, team Slack or communication channel invitations, first-day agenda delivery, equipment confirmation, and any role-specific orientation scheduling.

30-60-90 cadence includes scheduled check-in survey triggers, training enrollment notifications (see how to automate training enrollment once onboarding is stable), manager feedback prompts, and milestone acknowledgment messages.

Document each touchpoint with: the action, the recipient, the data fields required, the system it executes in, and the timing relative to start date. This table is your build spec.

Step 2 — Set Up Your Trigger in Make.com™

Every automation has one starting point. For onboarding, that starting point is the moment an employee record officially transitions to “hired.” Log into Make.com™, create a new scenario, and add your trigger module.

Option A — Webhook trigger: If your ATS or HRIS supports outbound webhooks, this is the fastest and most reliable option. Configure the webhook in your source system to fire on offer-accepted or employee-created status. In Make.com™, add a Webhooks module set to “Custom webhook,” copy the generated URL into your ATS, and fire a test payload. Map the incoming fields immediately — Make.com™ will detect the data structure from the test payload and surface all available fields for mapping in subsequent modules.

Option B — Scheduled polling: If your ATS doesn’t support webhooks, use Make.com™’s native app module for your ATS (if available) or a Google Sheets / Airtable module that your ATS exports to. Set the module to poll on a schedule — every 15 minutes is a reasonable interval for onboarding — and filter for records where status equals your hire-confirmed value.

Option C — Form trigger: For smaller organizations without a formal ATS, a Google Form or Typeform submission from an HR coordinator can serve as the trigger. This is less automated at the front end but fully automated from that point forward.

Once the trigger fires cleanly and you can see all required data fields populated in the Make.com™ execution log, proceed to Step 3.

Step 3 — Build the Pre-Day-1 Provisioning Block

Add modules in sequence after the trigger to handle every pre-Day-1 action. Build this block completely before adding Day-1 or later-stage modules — it is the highest-risk phase and needs to be validated independently.

Welcome email: Add an email module (Gmail, Outlook 365, or your HRIS email function) addressed to the new hire’s personal email. Use dynamic field mapping to insert their name, start date, manager name, office location or remote-access instructions, and a first-day agenda. This email should read personal — not templated — because every field is populated from live data. Asana’s Anatomy of Work research identifies unclear communication as one of the top drivers of new employee confusion in the first week; a detailed, personalized welcome email directly addresses this.

Document and e-signature request: Add a module for your document-signing platform. Pass in the new hire’s name, personal email, and any role-specific document set. Set the module to create and send the signature envelope automatically. The new hire receives a signing request within minutes of offer acceptance — no HR coordinator action required.

IT provisioning notification: Add a module that sends a structured message to your IT team’s communication channel or creates a ticket in your helpdesk system. Include start date, role, department, required equipment spec, and any software licenses needed. IT receives every new hire request in a consistent, complete format — eliminating the back-and-forth that delays account and equipment readiness.

HRIS record creation or update: If your trigger comes from an ATS rather than your HRIS, add a module that creates or updates the employee record in your HRIS with the trigger data. This step is where the category of error that cost David — an HR manager in mid-market manufacturing — $27,000 occurs: an ATS-to-HRIS transcription mistake turned a $103K offer into a $130K payroll record. Automating this transfer eliminates that risk entirely. For more on this vulnerability, see the broader guide to eliminating payroll data errors with automation.

Benefits enrollment invitation: Add a module that sends the benefits enrollment link and deadline to the new hire’s personal email, triggered automatically based on a date relative to start date. If your benefits platform has a Make.com™ integration, trigger enrollment initiation directly.

Step 4 — Add Routers for Role-Based or Department-Based Branching

Not every new hire follows the same path. An engineering hire needs different system access than a sales hire. A remote hire needs different logistics than an on-site hire. Make.com™ routers handle this cleanly without requiring separate scenarios.

After the core provisioning modules, add a Router module. Configure each branch with a filter condition — for example, “Department equals Engineering” or “Location equals Remote.” Inside each branch, add the modules specific to that path: additional Slack channel invitations for the engineering team, a VPN setup guide for remote hires, a physical security badge request for on-site hires, or role-specific tool provisioning.

One scenario, one trigger, unlimited branching. This is the structure that makes a Make.com™ onboarding automation scalable across the entire organization without duplication or maintenance overhead across separate workflows. The benefits of low-code automation for HR departments include exactly this kind of conditional logic that would require custom code in any other context.

Step 5 — Schedule Day-1 and Week-1 Modules

Make.com™ does not natively delay a module by a number of days within a single scenario execution. To trigger actions on specific dates relative to start date, use one of these approaches:

Approach A — Scheduled trigger on a separate scenario: The initial onboarding scenario writes the new hire’s start date and ID to a data store or a Google Sheet. A second scenario runs on a daily schedule, reads records from that store, and fires Day-1 modules for any employee whose start date equals today. This is the most reliable approach for date-relative scheduling.

Approach B — Sleep module for short delays: For delays of hours rather than days (for example, sending a first-day-agenda reminder three hours before start time), Make.com™’s Sleep module can pause a scenario execution. Do not use this for multi-day delays — it consumes scenario run time unnecessarily.

Day-1 modules to include: a morning-of reminder to the hiring manager with the new hire’s schedule and any pending tasks; a team notification in your communication platform announcing the new hire with their role, a brief bio field pulled from the trigger data, and their team channel; and a direct message to the new hire with their first-day access credentials once IT confirms provisioning is complete.

Step 6 — Build the 30-60-90 Cadence Using Scheduled Scenarios

Using the same date-based scheduling approach from Step 5, extend the onboarding automation into the first three months. McKinsey Global Institute research finds that onboarding effectiveness correlates directly with sustained role clarity in the first 90 days — a cadence of structured check-ins delivers this at scale.

Day 30: Send a check-in survey to the new hire (your survey platform’s Make.com™ module or a simple Google Form link) and a parallel prompt to the manager asking for a brief performance note. Route survey responses into a shared HR tracking sheet automatically.

Day 60: Trigger training enrollment for any required second-phase learning modules. Send the manager a 60-day milestone prompt with a structured feedback template link. Flag any incomplete onboarding tasks (unsigned documents, missing profile data) in your HRIS for HR follow-up.

Day 90: Send a formal 90-day check-in survey. Trigger the initial performance review scheduling workflow if your organization conducts 90-day reviews. Archive the onboarding record in your data store and mark the scenario cycle as complete.

Harvard Business Review research indicates that organizations with structured onboarding programs see significantly higher new hire retention in the first year. Automating the cadence ensures the structure actually happens — not just when HR has bandwidth for it.

Step 7 — Add Error Handling and Alert Modules

A scenario without error handling is a liability. When a module fails — an API call times out, a required field is null, a document-signing request bounces — Make.com™ marks the execution as failed and stops. Without deliberate error handling, the failure is silent. The new hire’s account doesn’t get provisioned, the e-signature request never sends, and HR doesn’t know until the employee’s first day reveals the gap.

On every critical module — HRIS record creation, e-signature dispatch, IT provisioning notification — right-click the module in Make.com™ and add an error-handler route. Configure the error route to send an alert: a Slack message to the HR operations channel, an email to the scenario owner, or a ticket in your project management tool. Include the error type, the module name, and the employee record that triggered the failure.

Also add a data-validation router immediately after the trigger module. Check that all required fields — name, email, start date, department, manager — are non-null. If any required field is missing, route to an alert module rather than letting a malformed record flow through the entire onboarding chain. This single addition prevents the majority of real-world onboarding automation failures.

Step 8 — Test End-to-End with Your Dummy Record

Testing is not optional. Before setting any scenario to active with a live trigger, run your dummy hire record through the complete flow.

1. Fire the trigger with your test record. In Make.com™, use “Run once” mode to execute the scenario against the dummy payload.
2. Check the execution log for each module. Confirm every module shows a green status. Review the output of each module — the actual data sent to each system — not just the status indicator.
3. Verify in each downstream system. Log into your email platform and confirm the welcome email was sent and populated correctly. Check your document-signing platform for the created envelope. Check your IT helpdesk for the provisioning ticket. Check your HRIS for the created or updated employee record.
4. Test each router branch. Fire the trigger with a dummy record for each department or role variation. Confirm the correct branch activates and the branch-specific modules execute.
5. Simulate a failure. Temporarily break one module (for example, enter an invalid API key) and confirm the error handler fires and delivers an alert. Restore the module before go-live.
6. Test date-based scheduling. Manually set your test record’s start date to today and confirm the daily-schedule scenario picks it up and fires Day-1 modules correctly.

Only after every module passes inspection should you activate the scenario and switch from test mode to live operation.

How to Know It Worked

A functioning onboarding automation has three observable signals within the first 30 days of live operation:

• Zero manual coordination for standard hires. HR should not need to manually trigger, remind, or follow up on any provisioning step for a new hire who entered the system correctly. If coordinators are still sending individual emails or chasing IT tickets, the automation has gaps.
• 100% document completion before start date. Your document-signing platform’s completion rate for pre-Day-1 documents should reach near-100% because requests are sent immediately and automatically. Track this rate per cohort in a shared report that Make.com™ populates automatically from the signing platform’s status data.
• Reduced onboarding-related HR support tickets. New hire questions about access, accounts, or missing documents should drop materially. Deloitte human capital research consistently identifies “unclear processes” as the top new hire complaint — automation resolves this at the source.

The benchmark from a well-structured automation is that HR time spent on onboarding coordination drops by at least 60% within 60 days of go-live. The hours recovered return to strategic work — a dynamic that mirrors what Sarah, an HR director in regional healthcare, experienced when she reclaimed six hours per week after automating her interview scheduling coordination.

Common Mistakes to Avoid

Building before mapping. The most common failure is opening Make.com™ before completing the touchpoint map. The result is an incomplete scenario that handles some onboarding steps but not others — creating a worse experience than full manual coordination because expectations are set but delivery is inconsistent.

Ignoring data quality at the source. Garbage in, garbage out. If the ATS doesn’t capture manager email as a reliable field, every module that needs manager email will fail or populate incorrectly. Fix the source before building the scenario.

No error handling. Silent failures are the primary reason HR teams conclude that “automation doesn’t work.” Every critical module needs an error-handler route. This is non-negotiable.

Over-automating the human moments. The 30-60-90 check-ins should be triggered automatically, but the responses require human attention. Don’t route survey feedback into a system where it sits unread. Make.com™ can surface the responses in a shared dashboard or send a digest to the HR team — but someone must own the follow-through.

Building one monolithic scenario. A single scenario that handles every onboarding action from Day 0 through Day 90 becomes fragile and difficult to maintain. Break it into a trigger scenario, a provisioning scenario, and a cadence scenario. Each is smaller, testable, and replaceable independently. The same modular thinking applies to offboarding automation, which mirrors this same scenario structure in reverse.

For a view of what this looks like at scale, the 95% reduction in manual HR data entry case study shows how structured automation across HR processes compounds when the foundational workflows are built correctly. And if you’re thinking beyond onboarding to a broader self-service infrastructure, self-service portals that extend the onboarding experience are the logical next layer once this scenario is stable.

Onboarding automation is one node in a larger HR automation strategy. The the full HR automation blueprint covers how to sequence automation investments across the entire people-ops lifecycle — and where onboarding fits in the priority stack.