How to Build 9 Make.com™ Scenarios for Keap HR Automation: Step-by-Step

HR automation wins are decided in the handoffs — the moments between a candidate action and your team’s response. Every manual handoff is a delay, a potential error, and a drain on recruiter capacity. The nine Make.com™ scenarios in this guide eliminate those handoffs systematically, connecting Keap to your broader HR and recruiting stack without custom code.

This is the operational layer that the complete guide to integrating Make.com™ and Keap for recruiting automation describes at a strategic level. Here, you build it. Each scenario follows the same trigger-filter-action structure. Master it once, and all nine become repeatable.

Before You Start

Before activating any scenario, confirm these prerequisites are in place. Skipping them causes mid-build rework.

• Keap API credentials: Generate a dedicated API service account in Keap with scoped permissions. Do not use a personal user account — API key rotation becomes a production incident if tied to an employee login.
• Make.com™ account and Keap connection: Establish the Keap connection in Make.com™ and verify it with a test API call before building any scenario.
• Custom field inventory: Export your full list of Keap custom fields (name, field ID, type). You will map these repeatedly. Missing a field ID mid-build is the most common cause of abandoned scenarios.
• Tag taxonomy documented: Know which Keap tags correspond to which pipeline stages. Undocumented tags create filter logic ambiguity. See the guide on automating Keap tags and custom fields for recruiters for a structured approach.
• Error-handling template ready: Create a Google Sheet with columns for Scenario Name, Error Type, Contact ID, Timestamp, and Bundle Data. Every scenario below will reference this sheet in its error-handler route.
• Estimated time: 8–15 hours total across all nine builds. Budget per scenario: 45 minutes (simple) to 3 hours (multi-system).
• Risk: Testing against live production contacts can send unintended messages to real candidates. Create a dedicated test tag in Keap and a test contact record before running any scenario live.

Step 1 — Build the Candidate Onboarding Trigger Scenario

This scenario fires the moment a candidate accepts an offer and initiates every downstream onboarding action automatically.

Trigger: Webhook (Custom Webhook module in Make.com™). Your document-signing tool sends a POST request to this webhook when a document is marked “Completed.”

Filter: Check that the document type field equals “Offer Letter.” This prevents non-offer documents from firing onboarding logic.

Actions in sequence:

1. Keap — Update Contact: Set the candidate’s status field to “Hired” and apply the “New Hire” tag.
2. Keap — Apply Sequence: Enroll the contact in your pre-boarding email sequence (welcome email, first-day logistics, equipment request form).
3. Keap — Create Task: Assign an onboarding checklist task to the HR coordinator, due 3 business days out.
4. HTTP module or HRIS-specific module: POST the new employee profile to your HRIS. Map the Keap contact fields (name, email, start date, department) to the HRIS required fields.

Error handler: Add a route after each action module. On error, write the bundle to your error log sheet and send an email alert to the HR inbox.

For more depth on this workflow, see candidate onboarding automation with Make.com™ and Keap.

Step 2 — Build the Interview Scheduling Automation Scenario

This scenario eliminates the back-and-forth calendar coordination that consumes 6+ hours per week for a coordinator managing a moderate pipeline. Sarah, an HR Director at a regional healthcare organization, cut her team’s hiring timeline by 60% after automating this exact handoff.

Trigger: Keap — Watch Contacts (polling, every 15 minutes) or Keap webhook if your plan supports it. Filter for contacts where the pipeline stage tag changes to “Interview Stage 1.”

Filter: Confirm the contact has a valid email address and that the “Interview Scheduled” custom field is blank (prevents duplicate sends).

Actions in sequence:

1. Scheduling tool module: Generate a unique booking link scoped to the assigned interviewer’s calendar availability.
2. Keap — Send Email: Send the booking link to the candidate using a Keap email template. Personalize with first name and role title from Keap custom fields.
3. Webhook or scheduling tool trigger (separate scenario): When the candidate books, capture the datetime and write it back to Keap’s “Interview Date” custom field via Keap — Update Contact.
4. Calendar module: Add the event to the interviewer’s calendar with candidate name, role, and Keap contact link in the event description.

Reminders sub-scenario: Build a separate scheduled scenario that runs daily, filters for contacts with an Interview Date within the next 24 hours, and sends a reminder email and SMS via Keap. See the full walkthrough on setting up automated interview reminders with Keap and Make.com™.

Step 3 — Build the Application Acknowledgment Scenario

Candidates who receive no acknowledgment within 24 hours report significantly lower employer-brand sentiment. This scenario ensures zero candidates fall through without a response.

Trigger: Keap — Watch New Contacts, filtered by the tag applied when a new application form is submitted (e.g., “New Applicant 2026”).

Filter: Exclude contacts already in a downstream pipeline stage — this prevents re-sending acknowledgments to returning candidates who re-submitted.

Actions:

1. Keap — Send Email: Immediate acknowledgment email from the recruiter’s name, confirming receipt and setting timeline expectations.
2. Keap — Update Contact: Set “Application Received Date” custom field to today’s date (use Make.com™’s built-in date functions).
3. Keap — Apply Tag: Add “Ack Sent” tag to prevent re-triggering.

This scenario typically completes in under 30 seconds from application submission. The Microsoft Work Trend Index confirms that responsiveness in early candidate communication correlates with higher offer acceptance rates.

Step 4 — Build the Candidate Status Update Notification Scenario

Candidates left without status updates disengage and accept competing offers. This scenario pushes status changes from Keap to candidates the moment a recruiter moves a contact between pipeline stages.

Trigger: Keap — Watch Contacts, polling for changes in the pipeline stage custom field every 15 minutes.

Router: Use Make.com™’s Router module to branch by stage value:

• Branch A — “Under Review”: Send a “Your application is being reviewed” email.
• Branch B — “Phone Screen Scheduled”: Send phone screen prep materials.
• Branch C — “Not Moving Forward”: Send a respectful decline email and apply a “Declined” tag. SHRM research identifies timely decline communication as a key driver of positive candidate experience even for rejected applicants.
• Branch D — “Offer Extended”: Trigger the offer letter workflow (connect to Scenario 1’s webhook downstream).

Error handler: Log any unmatched stage values to the error sheet — these reveal undocumented tags in your Keap taxonomy that need cleanup.

Step 5 — Build the Offer Letter Generation Scenario

Manual offer letter creation is one of the highest-error-rate tasks in recruiting. Parseur’s Manual Data Entry Report finds that manual data entry carries an error rate that compounds downstream — a single transposition error in compensation data can propagate through HRIS, payroll, and benefits systems. David, an HR manager at a mid-market manufacturing firm, experienced exactly this: a transcription error turned a $103K offer into a $130K payroll entry, costing $27K and the employee’s tenure.

Trigger: Keap — Watch Contacts, filtered for the “Offer Approved” tag applied after a hiring manager approval task is marked complete.

Actions:

1. Document generation module: Pull candidate name, role, compensation, start date, and manager name from Keap custom fields. Merge into your offer letter template to generate a populated PDF.
2. Document signing module: Send the generated PDF to the candidate’s email for e-signature.
3. Keap — Update Contact: Set “Offer Sent Date” custom field. Apply “Offer Out” tag.
4. Keap — Create Task: Notify the recruiter that the offer has been sent, with a follow-up due date 48 hours out.

Step 6 — Build the Contact Sync and Data Integrity Scenario

Every other scenario in this guide depends on clean, consistent data in Keap. This scenario runs on a schedule to reconcile Keap contact records against your ATS or HRIS and flag discrepancies before they break downstream automations.

Trigger: Schedule module — run every night at 2:00 AM local time.

Actions:

1. ATS/HRIS module or HTTP GET: Retrieve all active candidate records modified in the last 24 hours.
2. Iterator + Keap — Search Contacts: For each ATS record, find the matching Keap contact by email.
3. Make.com™ built-in tools — Compare fields: Check that the pipeline stage, custom field values, and tag set match between systems.
4. Keap — Update Contact (conditional): If a discrepancy is found, write the ATS value to the Keap field and log the correction to the error sheet.

For the full strategy on eliminating manual data entry through contact sync, see syncing Keap contacts with Make.com™ to eliminate manual data entry. For webhook-based real-time sync, see building real-time Keap automation with webhooks and Make.com™.

Step 7 — Build the New Employee System Access Provisioning Scenario

IT provisioning delays on day one are one of the most common new-hire frustration points. This scenario fires from the same “Hired” tag applied in Scenario 1 and runs provisioning in parallel with the HR onboarding sequence.

Trigger: Keap — Watch Contacts, filtered for the “New Hire” tag (the same tag applied in Scenario 1). Use a 1-hour delay module if you want provisioning requests to queue after the HR sequence initiates.

Actions:

1. Email module: Send a structured provisioning request to the IT inbox, including employee name, role, start date, department, and required system access list (pulled from a Keap custom field populated during the offer approval workflow).
2. Project management module (optional): Create a provisioning task in your project tool assigned to the IT lead, with subtasks for each system.
3. Keap — Create Task: Log an HR follow-up task for day 2, to confirm system access with the new hire.

Step 8 — Build the Performance Review Scheduling Scenario

Performance review cycles fail operationally when reminders are manual. Managers miss deadlines, employees are blindsided, and HR scrambles. This scenario automates the entire scheduling reminder chain from a single date field in Keap.

Trigger: Schedule module — run daily at 7:00 AM.

Filter: Find all Keap contacts tagged “Active Employee” where the “Next Review Date” custom field is exactly 30 days, 14 days, or 7 days from today (use Make.com™ date math functions to calculate each window).

Router by window:

• 30 days out: Keap — Send Email to manager: review prep instructions and self-assessment link.
• 14 days out: Keap — Send Email to employee: self-assessment reminder and deadline.
• 7 days out: Keap — Send Email to both: final reminder with logistics. Keap — Create Task assigned to HR coordinator to confirm scheduling.

Gartner research on HR process efficiency identifies review cycle completion rates as a direct function of structured reminder cadences — organizations with automated reminder sequences complete more performance reviews on time.

Step 9 — Build the Recruitment Reporting and Analytics Scenario

Automation without measurement is blind. This scenario compiles daily recruitment pipeline metrics from Keap and writes them to a structured reporting sheet, giving leadership a live view without any manual data pulling. Harvard Business Review research on people analytics demonstrates that teams with real-time pipeline visibility make faster, better-calibrated hiring decisions.

Trigger: Schedule module — run every weekday at 6:00 AM.

Actions:

1. Keap — Search Contacts (multiple calls): Run separate searches for each pipeline stage tag. Capture the count of contacts in each stage.
2. Make.com™ Aggregator module: Compile counts into a single data bundle.
3. Google Sheets — Add Row: Write one row to your reporting sheet with today’s date, stage-by-stage counts, total active pipeline, and offers outstanding.
4. Email module (optional, weekly): On Mondays, send a formatted summary table to the recruiting team and hiring manager distribution list.

For a deeper build on custom reporting dashboards, see the guide on measuring Keap and Make.com™ metrics to prove automation ROI.

How to Know It Worked

Run each scenario in “Run once” mode against your test contact before activating on a schedule or live webhook. For each scenario, confirm:

• Scenario 1 (Onboarding): Test contact’s Keap status updates to “Hired,” the pre-boarding sequence enrolls, the HRIS receives the new employee record, and the IT provisioning task is created — all within 60 seconds of the webhook firing.
• Scenario 2 (Interview Scheduling): The test contact receives a scheduling email with a valid booking link. After booking, the Interview Date field in Keap updates and the calendar event appears on the interviewer’s calendar.
• Scenarios 3–5 (Communication): The correct email variant sends for the correct trigger condition. No duplicate emails fire when the scenario runs a second time against the same contact.
• Scenario 6 (Data Sync): Introduce a deliberate field mismatch in the test contact between Keap and your ATS, run the scenario, and confirm Keap updates and the correction appears in the error log.
• Scenarios 7–8 (Provisioning, Reviews): The correct task and email generate for the correct date window. Run the date-math filter against a contact with a manually set “Next Review Date” 30, 14, and 7 days out to confirm all three branches fire correctly.
• Scenario 9 (Reporting): A new row appears in the Google Sheet with accurate stage counts matching a manual count you do independently on the same day.

Common Mistakes and Troubleshooting

For a full diagnostic guide, see fixing common Make.com™ Keap integration errors. The most frequent issues in these nine specific builds:

• Stale field mappings: After any Keap custom field rename or addition, refresh the module schema in Make.com™ before running. Stale mappings pass blank values silently — you will not get an error, you will get empty Keap fields.
• Polling latency for time-sensitive workflows: Scenarios 3 and 4 use polling triggers. If sub-5-minute response time matters (it does for application acknowledgments), switch to a Keap webhook trigger. See the webhook guide linked above.
• Router branch order matters: Make.com™ evaluates Router branches top to bottom and stops at the first match. If a contact qualifies for multiple branches, only the first branch fires. Order branches from most-specific to least-specific conditions.
• Duplicate sends on re-run: Every communication scenario must apply a “Sent” tag after the email fires and include a filter at the top that skips contacts already carrying that tag. This is the most common production error in communication automation.
• API rate limits: Keap’s API has rate limits. Scenario 9 running multiple Search Contacts calls simultaneously can hit limits during high-volume periods. Add a Sleep module between search calls to throttle the request rate.

The nine scenarios above are the operational foundation of a Keap-powered HR automation stack. Build them in the order presented — data integrity and trigger infrastructure first, communication sequences second, reporting third. Each scenario you activate compounds the value of the others. For the complete strategic framework — including where AI earns a role after the automation layer is running — return to the complete guide to integrating Make.com™ and Keap for recruiting automation.