The 10 Make.com modules that power HR AI automation are: HTTP, OpenAI, Webhook, Router, Iterator, Aggregator, Data Store, JSON, Text Parser, and Error Handler. Master these in order of foundational importance and every HR workflow you build becomes faster, more reliable, and easier to scale.

Most HR automation projects fail at the architecture stage. Teams wire AI directly to raw data, skip the orchestration layer entirely, and end up with unpredictable outputs, broken handoffs, and frustrated recruiters who return to spreadsheets. The fix is knowing which modules do which job — and in what order they matter.

Before diving in, the broader strategic context lives in our guide to AI-powered recruitment and HR workflow transformation. For teams evaluating whether to build these workflows themselves or bring in a partner, the DIY vs. Make partner decision guide covers that tradeoff directly. And if you’re brand new to Make.com’s building blocks, start with this plain-English explanation of what a Make scenario actually is.

According to McKinsey Global Institute, generative AI can automate up to 70% of employee time spent on data collection and processing. But that value is only captured when the workflow architecture is sound. These 10 modules are how you build it.

1. HTTP Module — The Universal API Connector

The HTTP module is the single most important module in any advanced HR automation stack because it removes every integration ceiling. When a native Make.com™ connector does not exist for your HRIS, ATS, or AI service, the HTTP module fills the gap by sending GET, POST, PUT, or DELETE requests to any REST endpoint.

• Custom AI endpoints: Send employee survey text to a sentiment analysis API hosted on a cloud platform and receive a structured score back — all within the same scenario.
• Legacy system integration: Pull employee records from an older HRIS that lacks a native connector and push them into a modern onboarding platform.
• Webhook delivery: Fire outbound webhook payloads to custom-built internal HR tools that consume structured JSON.
• Authentication flexibility: Supports Bearer tokens, Basic Auth, OAuth headers, and custom header configurations so no enterprise system is off-limits.
• Error handling pairing: Combine with Make.com’s error handler routes to catch failed API calls and trigger retry logic or escalation notifications automatically.

For teams looking to build HTTP modules without writing API code from scratch, see how to feed API documentation into Claude to generate Make HTTP modules instantly.

Bottom line: If you master one module, make it this one. Every other module on this list becomes more powerful when you can connect it to anything.

2. OpenAI Module — Generative Intelligence at the Right Moment

The OpenAI module gives Make.com™ scenarios direct access to GPT-class language models without any API setup beyond an OpenAI key. For HR, its value is real — but only when deployed at genuine judgment points, not as a default processor for every data record.

• Resume scoring prompts: Pass structured resume text extracted in an earlier step and return a ranked assessment against job requirements.
• Personalized outreach drafting: Feed candidate name, role, and sourcing notes into a prompt and generate a first-draft email that a recruiter reviews before sending.
• Interview question generation: Dynamically build role-specific interview guides from job description text, ensuring consistency across hiring managers.
• Sentiment classification: Process open-ended exit survey responses and tag each with a sentiment category for downstream aggregation.
• Document summarization: Condense lengthy performance review narratives or meeting transcripts into structured bullet summaries.

For a complete workflow architecture using the OpenAI module in candidate screening, see the guide to AI-powered candidate screening step by step. Teams wondering where AI genuinely helps versus where it creates noise will find the breakdown in 5 automation tasks AI handles well — and 5 it still gets wrong directly useful.

Bottom line: Powerful and overused. Reserve this module for tasks that require language generation or nuanced classification. A filter handles binary logic faster and at lower cost.

3. Webhook Module — The Event-Driven Trigger

Real-time candidate and employee experiences require event-driven architecture. The Webhook module provides an instant trigger URL that fires a Make.com™ scenario the moment an external system sends data — no polling, no delay.

• ATS application events: Trigger a screening and outreach sequence the instant a candidate submits an application, not during the next scheduled batch run.
• Form submissions: Fire onboarding workflows the moment a new hire completes a welcome form.
• HRIS status changes: React to employee status updates — promotion, department transfer, termination — in real time for downstream communications and access provisioning.
• Custom payload parsing: The module auto-detects JSON structure on first run, making downstream data mapping straightforward.

Bottom line: The fastest way to move from batch-oriented HR automation to real-time workflows. Pair with the Router module for conditional branching on incoming event types.

4. Router Module — Conditional Branching Without Code

The Router module is the primary tool for keeping HR workflows deterministic. It splits a single scenario into multiple branches, each with its own filter conditions, so records are processed by the right logic rather than funneled into a one-size-fits-all sequence.

• Role-based routing: Direct engineering candidates to a technical screening path, sales candidates to a portfolio review path, and operations candidates to a competency review — all from a single incoming webhook.
• Location compliance routing: Ensure candidates in regulated jurisdictions receive compliant messaging and documentation flows automatically.
• Screening score branching: Route high-scoring candidates to an interview scheduling sequence and lower-scoring candidates to a nurture or decline path without human triage.
• Status-based logic: Differentiate workflow behavior based on ATS pipeline stage so each step fires only when appropriate.

Bottom line: Every HR scenario with more than one outcome needs a Router. This is what keeps AI from being asked to make decisions that rules can make better and cheaper.

5. Iterator Module — Process Arrays at Scale

HR operations involve bulk data constantly — batches of resumes, lists of candidates, arrays of survey responses, sets of onboarding documents. The Iterator module takes an array and processes each item individually through the rest of the scenario, enabling true bulk automation without manual loops.

• Bulk resume processing: Pull an array of 200 new applications from an ATS and run each one through an AI scoring prompt individually, then aggregate the results.
• Survey response analysis: Take a week’s worth of exit interview responses and pass each through a sentiment classifier before rolling up to a dashboard summary.
• Onboarding document dispatch: Loop through a new hire’s required document list and trigger a personalized send action for each one sequentially.
• Benefits enrollment processing: Iterate through an employee benefits selection array and post each elected benefit to the carrier API separately.

Bottom line: Without the Iterator, bulk HR operations require manual batching or workarounds. With it, one scenario handles hundreds of records in a single run.

6. Aggregator Module — Consolidate Before You Act

The Aggregator module is the Iterator’s necessary partner. After processing individual records in a loop, the Aggregator collects all outputs back into a single bundle — a structured array, a concatenated text block, or a numeric summary — ready for the next step.

• Candidate shortlist assembly: After iterating through 50 AI-scored resumes, aggregate the top-scored candidates into a single array for recruiter review.
• Survey summary compilation: Collect all sentiment-tagged survey responses into one structured object for a weekly HR analytics report.
• Document package assembly: Bundle all generated onboarding documents into a single payload for delivery to a document management system.
• Numeric rollups: Sum time-to-hire metrics across a hiring cohort and pass the aggregate to a reporting dashboard in a single API call.

Bottom line: The Iterator and Aggregator are always a pair. One breaks arrays apart; the other puts processed results back together.

7. Data Store Module — Persistent State Without a Database

The Data Store module gives Make.com™ scenarios a lightweight, built-in key-value store that persists between runs. For HR automation, this solves the deduplication and state-management problems that break otherwise well-built workflows.

• Deduplication: Check whether a candidate has already been processed before triggering a new outreach sequence — prevents double-contacts that damage candidate experience.
• Application state tracking: Record where each candidate sits in a custom workflow stage so subsequent scenario runs know what has already happened.
• Rate limit management: Track API call counts across scenario runs to stay within third-party service limits without building a separate tracking system.
• Cross-scenario memory: Share lookup data — approved job titles, compensation bands, location compliance flags — across multiple related scenarios without duplicating logic.

Bottom line: Any HR scenario that runs on a schedule or processes recurring records needs a Data Store check. It is the simplest form of workflow memory available.

8. JSON Module — Structure the Data Before It Moves

Most HR systems speak JSON, and the JSON module handles the parsing and construction work that makes clean data handoffs possible. It converts raw JSON strings into Make.com™-compatible data structures and builds properly formatted payloads for outbound API calls.

• HRIS payload construction: Build a precisely structured JSON object to post a new employee record to an HRIS API without format errors.
• AI response parsing: Take a complex JSON response from an OpenAI API call and extract only the fields needed for the next workflow step.
• ATS integration formatting: Transform internal candidate data into the exact schema required by an ATS API before posting a stage update.
• Nested data handling: Flatten or restructure nested JSON objects from webhook payloads so downstream modules can map fields without errors.

Bottom line: JSON errors are the most common cause of silent workflow failures. The JSON module catches formatting problems before they reach downstream systems.

9. Text Parser Module — Extract Structure From Unstructured Input

HR data arrives in messy, unstructured formats: resume PDFs converted to plain text, email bodies, form free-text fields, and exported reports with inconsistent formatting. The Text Parser module applies regex patterns and text manipulation functions to extract clean, structured data from that raw input before it reaches the OpenAI module or any downstream API.

• Resume field extraction: Pull candidate name, email, phone, and years of experience from unstructured resume text using pattern matching before passing to a scorer.
• Email parsing: Extract specific data points from inbound HR email bodies — start dates, requested leave periods, position titles — and map them to workflow variables.
• Report field isolation: Strip formatting characters and extract specific columns from exported HRIS reports before passing data to an aggregation step.
• Date standardization: Normalize inconsistent date formats from multiple source systems into a single standard before writing to a Data Store or posting to an API.

For teams building these pre-processing layers, the post on automating processes with no native Make module shows how text parsing fits into broader custom workflow design.

Bottom line: The Text Parser is the preparation layer that makes the OpenAI module more accurate and less expensive. Clean input produces better AI output.

10. Error Handler Module — Production Stability for HR Workflows

Every HR workflow that runs in production will eventually encounter a failed API call, a malformed data record, or an external service timeout. The Error Handler module intercepts those failures and routes them to defined recovery logic rather than letting a single bad record halt an entire scenario run.

• Retry logic: Automatically retry a failed HRIS API call up to three times before escalating — handles transient network errors without human intervention.
• Fallback routing: When an AI scoring call fails, route the affected candidate record to a human review queue rather than dropping it silently.
• Failure notifications: Send an immediate Slack or email alert to the HR ops team when a critical workflow step fails, with the error context included.
• Partial failure handling: Allow 199 of 200 records in a batch to complete successfully even when one record throws an error, rather than rolling back the entire run.

For detailed implementation guidance, the post on setting up routed error handling in Make with AI assistance covers the build pattern end to end. The case study on how an AI-built error handler cut technician research time from 20 minutes to a glance shows what proper error handling looks like in production.

Bottom line: No HR automation scenario is production-ready without an error handler. This module is the difference between a demo and a system you can actually trust.

How These 10 Modules Work Together in a Real HR Workflow

These modules are not used in isolation. A production HR AI workflow integrates all 10 in a defined sequence. Here is how that looks in a candidate screening automation:

1. Webhook fires when a new application is submitted in the ATS.
2. Router branches the scenario based on role type and location.
3. HTTP pulls the full candidate record from the ATS API.
4. Text Parser extracts structured fields from the resume text.
5. JSON formats the extracted data for the AI prompt.
6. Data Store checks whether this candidate has already been processed.
7. OpenAI scores the candidate against the job requirements.
8. Iterator processes any array of supporting documents or assessments.
9. Aggregator assembles the full candidate profile with score.
10. Error Handler catches any step failure and routes to recovery logic.

This is the architecture that separates workflows that break from workflows that scale. For teams ready to audit their current automation before rebuilding, the OpsMap™ audit process is the right starting point. For a broader look at the operational framework these modules fit into, see what OpsMesh™ is and how it structures every engagement.

What Should You Build First?

Start with the HTTP module and the Error Handler. Every other capability builds on the ability to connect to external systems cleanly and recover from failures gracefully. The OpenAI module is the last piece to add — not the first. Teams that lead with AI and skip the architecture layer consistently rebuild the same broken workflows two or three times before arriving at this order the hard way.

For non-technical HR teams looking to start building without developer support, the post on how a non-technical HR team started building their own automations with Make and AI covers the realistic starting point. The guide on 10 automations that are now easy to build with Make and AI without a developer shows what is achievable without a technical background.

Frequently Asked Questions

Do you need all 10 modules for every HR automation?

No. A simple onboarding trigger workflow needs the Webhook, Router, HTTP, and Error Handler modules. The Iterator, Aggregator, and Data Store become essential when you move to bulk processing or recurring runs. The JSON and Text Parser modules are required whenever you handle unstructured data or build custom API payloads. Start with the four foundational modules and add the others as workflow complexity grows.

Is the OpenAI module the most important one for HR AI automation?

No. The HTTP module is more foundational because it connects Make.com to every system in your HR stack. The OpenAI module is valuable at specific decision points — resume scoring, outreach drafting, sentiment classification — but it is not a replacement for structured routing and data management. Most HR workflows that fail do so because of poor architecture, not insufficient AI.

What is the difference between the Iterator and the Aggregator?

The Iterator breaks an array of records apart and processes each one individually through subsequent workflow steps. The Aggregator collects the results of those individual processing steps back into a single structured output. They work as a pair: Iterator splits, Aggregator rejoins. Any bulk HR processing workflow — resume batches, survey responses, benefits elections — requires both.

How does the Data Store module prevent duplicate outreach to candidates?

Before the scenario triggers any outreach action, it checks the Data Store for a record matching the candidate’s unique identifier. If a record exists, the scenario routes to a skip branch. If no record exists, it proceeds with outreach and writes the identifier to the Data Store so future runs recognize this candidate as already contacted. This check adds one module and prevents the candidate experience damage that duplicate outreach causes.

Can Make.com handle enterprise-scale HR automation with these modules?

Yes. The HTTP module connects to any enterprise HRIS or ATS via REST API. The Iterator and Aggregator handle bulk record processing at scale. The Error Handler provides the production stability enterprise workflows require. Organizations running hundreds of hiring workflows simultaneously use this exact module stack. The limiting factor is workflow architecture quality, not Make.com’s capacity.

Additional Reading

• What Is a Make Scenario? The Plain-English Guide for Zapier Users
• How to Feed API Docs Into Claude to Build Make HTTP Modules Without Native Connectors
• How to Set Up Routed Error Handling in Make With AI Assistance
• How an AI-Built Error Handler Reduced Technician Research Time From 20 Minutes to a Glance
• How We Used Make and Claude to Automate a Process That Had No Native Module
• How a Non-Technical HR Team Started Building Their Own Automations With Make + AI
• 10 Automations That Are Finally Easy to Build With Make + AI — No Developer Needed
• How to Run an OpsMap Audit Before Automating Anything
• What Is OpsMesh? The Framework That Structures Every 4Spot Engagement
• 5 Automation Tasks AI Handles Well — and 5 It Still Gets Wrong
• DIY Automation vs. Hiring a Make Partner in 2026: When to Do Each
• AI-Powered Candidate Screening: Your Step-by-Step Guide to Faster Hiring
• How Sarah Compressed a 45-Minute Onboarding Process to Under 4 Minutes
• 6 Ways the Make MCP Changes Automation Work for HR Teams
• What Is Automation-First? Why You Should Automate Before You Add AI