How to Automate HR Without Writing Code: A Make.com™ Guide for Non-Technical Teams

HR professionals are not paid to copy data between systems, chase interview confirmations, or manually trigger onboarding checklists. Yet Asana’s Anatomy of Work research finds that knowledge workers spend roughly 60% of their time on coordination and communication tasks rather than the skilled work they were hired to do. For HR, that number skews even higher. The fix is not a new HRIS. It is an automation layer that connects your existing tools and eliminates the manual steps between them.

This guide covers exactly how to build that layer using Make.com™ — without writing a single line of code. It is the tactical companion to our 7 Make.com automations for HR and recruiting pillar, and to our beginner’s guide to HR automation with Make.com. Where those posts cover what to automate and why, this one covers how — step by step, decision by decision.

Before You Start: Prerequisites, Tools, and Realistic Time Estimates

Before opening Make.com™, confirm you have everything below. Starting without these produces rework.

  • A Make.com™ account. A free plan is sufficient for a first scenario. You will need a paid plan for high-volume or multi-system workflows.
  • Admin or API credentials for every system you plan to connect. This typically means your ATS, HRIS, email platform, and any communication tool (e.g., Slack). Collect these before your build session — chasing credentials mid-build kills momentum.
  • A written process map of the workflow you are automating. Not a flowchart. A plain-language list: what triggers the process, what happens next, where does the data live, who needs to be notified, and what are the exceptions. This document is your blueprint.
  • IT security sign-off. You do not need IT to build the workflow. You do need them to approve API access and confirm the data routing meets your organization’s security policies before go-live.
  • Time budget. A first scenario takes two to four hours. A multi-system onboarding chain takes one to three days including testing. Do not book this as a one-hour task.

Risk note: Automate data flows, not data decisions. Make.com™ should move and transform data based on rules you define. Eligibility determinations, compensation decisions, and anything with legal or compliance weight should remain in human hands or in your system of record — not in an automation scenario.

Step 1 — Map the Manual Process Before Touching Any Software

The most common reason HR automation projects fail is that teams skip this step. Open Make.com™ before you understand the process and you will build the wrong thing.

Take the workflow you have chosen — interview scheduling, for example — and write out every manual action in sequence. Use this format:

  1. What is the trigger? (A candidate moves to “Interview Scheduled” status in the ATS.)
  2. What happens next? (Recruiter manually sends calendar invite, manually sends confirmation email to candidate, manually notifies hiring manager via Slack.)
  3. Where does each piece of data live? (Candidate email in ATS. Hiring manager email in HRIS. Calendar in Google Workspace.)
  4. What are the exceptions? (Candidate is in a different time zone. Hiring manager has blocked calendar.)
  5. What does success look like? (Candidate receives confirmation within five minutes of status change. Hiring manager receives Slack notification within the same window.)

This map is the specification your Make.com™ scenario will implement. Do not skip it. Gartner research on low-code adoption consistently identifies poor requirements definition — not technical complexity — as the primary failure mode.

Step 2 — Create Your Make.com™ Account and Understand the Interface

If you already have an account, skip to Step 3. If not, go to Make.com and create one. The free plan supports up to 1,000 operations per month — sufficient for a pilot.

Once logged in, the three areas you will use most are:

  • Scenarios: Your automation workflows live here. Each scenario is a visual canvas of connected modules.
  • Connections: This is where you authenticate Make.com™ to your external apps (ATS, HRIS, Gmail, Slack, etc.). You connect each app once; all scenarios share the connection.
  • Data Stores: Simple internal databases you can use to hold reference data (e.g., a list of hiring managers and their Slack IDs) without connecting to an external system.

Spend 20 minutes exploring the interface before your first build. Click into an existing template scenario (Make.com provides hundreds) to see how modules connect. Familiarity with the canvas before you build reduces confusion significantly.

Step 3 — Set Up Your App Connections

In Make.com™, go to Connections and authenticate every system your scenario will touch. For a typical HR onboarding trigger, that means:

  1. Your ATS (the trigger source)
  2. Your HRIS (the destination for new employee records)
  3. Your email platform (for automated welcome messages)
  4. Your communication tool — Slack, Teams, or similar — for internal notifications
  5. Any document management system if you are routing new hire paperwork

Each connection uses OAuth or API key authentication. The platform walks you through this step-by-step for every major app. If your system is not listed as a native integration, Make.com™’s HTTP module can connect to any system with a REST API — you will need your IT team’s help to configure that specific module.

For guidance on data handling during connection setup, see our post on secure HR data automation best practices.

Step 4 — Build Your First Scenario, Starting With the Trigger

Every Make.com™ scenario starts with a trigger module — the event that wakes up the automation. Click Create a new scenario on the Scenarios page, then click the empty circle to add your first module.

Search for your ATS or the application where the triggering event originates. Select the appropriate trigger type:

  • Watch records — polls your app at a set interval (e.g., every 15 minutes) for new or updated records
  • Instant trigger / Webhook — fires in real time the moment the event occurs (preferred for time-sensitive HR notifications)

Configure the trigger by specifying what it is watching (e.g., “candidate status = Interview Scheduled”) and map the data fields you will need downstream (candidate name, email, phone, role, hiring manager ID).

Based on our testing: Instant triggers via webhooks are dramatically more reliable than polling for HR workflows where timing matters. If your ATS supports webhooks, use them. The 15-minute polling delay on watch triggers is long enough to make an interview confirmation feel late.

Step 5 — Add Action Modules for Each Downstream Step

With your trigger configured, click the + symbol to add the first action module. Each action module represents one task your automation performs in a connected app.

For the interview scheduling example, your module chain looks like this:

  1. Google Calendar — Create an Event: Map candidate name, interview date/time, and hiring manager email from the trigger data into the calendar event fields.
  2. Gmail (or your email platform) — Send an Email: Use Make.com™’s text formatting to compose a personalized confirmation email. Insert candidate name and interview details using the mapped fields from Step 1.
  3. Slack — Send a Message: Post a structured notification to the hiring manager’s DM or a designated recruiting channel. Include candidate name, role, and a direct link to the ATS record.

Between modules, you can insert:

  • Filters: Conditions that must be true for the next module to execute (e.g., only proceed if interview type = “On-site”)
  • Routers: Branch the workflow in multiple directions based on conditions (e.g., Route A for domestic candidates, Route B for international candidates)
  • Tools modules: Format dates, parse text, set variables, or perform math without connecting to an external app

For a deeper look at the specific modules that deliver the most HR value, see our guide to five Make.com modules that transform HR operations.

Step 6 — Add Error Handling Before You Test

This step is skipped by almost every first-time builder. Do not skip it.

Error handling tells Make.com™ what to do when a module fails — an API times out, a field is missing, an app is temporarily unavailable. Without error handling, a failed module silently stops the scenario. A candidate record never gets created. An onboarding email never goes out. No one knows until someone complains.

To add error handling in Make.com™:

  1. Right-click any module and select Add error handler.
  2. Choose the handler type: Resume (skip the error and continue), Ignore (stop gracefully), or Rollback (undo prior module actions if possible).
  3. Add a notification module at the end of your error route — typically an email or Slack message to your HR team alerting them to the failure with the record details included.

The goal: every failure should be visible, logged, and actionable within minutes. Silent failures in HR workflows have real consequences — see David’s payroll case in the “What We’ve Seen” block above for what an undetected error costs. For payroll-adjacent workflows specifically, our post on automating HR payroll data pre-processing covers error-proofing in detail.

Step 7 — Test With Real Data, Then Go Live

Make.com™ has a built-in test runner. Before activating your scenario, run it manually at least three times using real test records — not dummy data where possible. Real data exposes field-mapping gaps that test data masks.

Testing checklist:

  • Run the trigger manually and confirm the scenario executes end-to-end without errors.
  • Verify each downstream system received the correct data — open the calendar event, check the email landed in the candidate’s inbox, confirm the Slack message posted to the right channel.
  • Test at least one exception case: a missing field, an unusual character in a name, an out-of-hours scenario if timing logic is involved.
  • Review the execution log in Make.com™ (the history panel) to confirm all modules returned success status codes.
  • Have a colleague who was not involved in the build trigger a test case and observe whether the output matches their expectation — not yours.

Once testing passes, activate the scenario. Set the scheduling interval if you are using a polling trigger. Monitor the execution history daily for the first week to catch any edge cases that testing missed.

How to Know It Worked

Your scenario is working if all of the following are true within one week of go-live:

  • The manual steps your scenario replaced have been removed from the team’s workflow — not duplicated alongside the automation.
  • The execution history shows a consistent success rate above 95% with no silent failures.
  • The team members who previously performed the manual steps report they are no longer doing them.
  • Downstream stakeholders (candidates, hiring managers, IT for access provisioning) are receiving outputs at the correct timing without manual intervention.
  • You can identify the time reclaimed — in hours per week — and apply it to higher-value work. Sarah, an HR director at a regional healthcare organization, eliminated 12 hours of weekly interview scheduling admin with a single Make.com™ scheduling scenario, reclaiming six net hours per week after accounting for scenario maintenance.

If any of the above is not true, return to Step 4 and review your trigger configuration and module mapping.

Common Mistakes and How to Fix Them

Mistake 1 — Automating a broken process

Automation amplifies what is already there. If your manual onboarding process has three redundant approval steps that nobody uses, your automation will execute those three useless steps faster. Map and fix the process before you automate it. McKinsey research on process automation notes that organizations that automate broken processes realize a fraction of the expected efficiency gain.

Mistake 2 — Building everything in one scenario

Scenarios that try to handle every exception in a single chain become unmaintainable within weeks. Build modular scenarios — one for each logical workflow segment — and use Make.com™’s ability to call one scenario from another (via the HTTP module or built-in inter-scenario triggers) to chain them when needed. Smaller scenarios are easier to debug, update, and hand off.

Mistake 3 — Using polling triggers where webhooks are available

A 15-minute polling interval is acceptable for a nightly report. It is not acceptable for an interview confirmation email. Audit your trigger types and upgrade to instant webhooks for any HR workflow where timing directly affects the candidate or employee experience. UC Irvine research by Gloria Mark found that delays in expected communications create measurable productivity loss for the recipient — your candidates and hiring managers are not exempt.

Mistake 4 — No error handler, no alert

Covered above, but worth repeating: every production scenario needs an error handler that fires an alert. Set it up before go-live, not after the first silent failure.

Mistake 5 — Not removing the manual process after automating it

This is the most common mistake and the one that erodes ROI fastest. If the recruiter still manually sends a confirmation email “just to be safe” after the automation is live, you have not saved time — you have added a parallel process. The manual step must be formally removed from the workflow when the automation goes live. Communicate this clearly to the team and remove it from any SOPs or checklists.

What to Build Next

Once your first scenario is stable, expand systematically. The sequence that consistently delivers the fastest compounding ROI:

  1. Interview scheduling automation (your first build — highest frequency, immediate time savings)
  2. New hire onboarding trigger chain (ATS offer-accepted → HRIS profile → IT provisioning request → welcome email → onboarding checklist)
  3. Training and compliance reminder automation (date-based triggers from HRIS → email/Slack reminders → completion logging)
  4. Employee data sync (time-tracking to payroll pre-processing, eliminating the manual transcription step that cost David $27,000)
  5. Offboarding revocation chain (termination status in HRIS → IT deprovisioning request → benefits termination notification → exit survey trigger)

Each workflow builds on the connection infrastructure and pattern knowledge from the prior one. Teams that follow this sequence, rather than jumping to complex scenarios first, reach full operational automation in eight to twelve weeks rather than six to twelve months.

For the organizational and strategic layer — how to prioritize which automations to build, how to quantify their impact, and how to present the case to leadership — see our guide on how Make.com eliminates manual HR bottlenecks and our post on building the business case for HR automation. When you are ready to scale beyond individual workflows, the HR automation playbook for strategic leaders covers portfolio-level deployment.

The manual work is optional. The tools to eliminate it are available today, require no code, and return their investment within weeks. The only remaining variable is whether you build the first scenario this week or spend another quarter doing it by hand.