How to Automate Candidate Pre-Screening and Qualification with Make.com™ and Keap

Manual candidate triage is where hiring speed dies. A recruiter opens an inbox of 80 applications, reads each one for minimum criteria, copies data into a CRM, and decides who gets a follow-up — all before doing any actual recruiting work. The fix is a deterministic pre-screening workflow that runs the moment a candidate submits an application, scores their answers against your exact criteria, writes the result into Keap, and routes them into the right pipeline stage with no human in the loop. This guide shows you how to build that workflow step by step using Make.com™ and Keap.

This satellite is one component of the broader complete guide to recruiting automation with Make.com™ and Keap — read the pillar for the full pipeline architecture before drilling into this specific workflow.

Before You Start

Complete these prerequisites before touching any automation platform. Skipping them is the most common reason pre-screening workflows fail within two weeks of launch.

• Active Make.com™ account with a plan that supports webhooks and multiple scenario modules. The free tier is insufficient for production use.
• Keap account (formerly Infusionsoft) with API access enabled and sufficient custom field slots for your qualification data.
• Qualification criteria documented in writing. List every screening question, the field type (number, yes/no, text), and the exact pass/fail threshold. This document is the specification your scenario executes — without it, you are guessing.
• Application form ready to configure. Whether you use a Keap web form, a third-party form, or a custom HTML form, you need control over the form’s submission destination so you can point it at a Make.com™ webhook.
• Keap tags pre-created. Build your qualification tags (Qualified, Needs Review, Not Suited, plus any role-specific tags) in Keap before building the scenario. Referencing tags by ID in Make.com™ modules requires them to exist first.
• Time budget: Allow four to eight hours for a three-branch workflow with no external assessment integrations. More complex builds require proportionally more time.

Step 1 — Map Your Qualification Criteria and Keap Custom Fields

Before opening Make.com™, define exactly what “qualified” means for this role and where that data lives in Keap. This step is the specification your entire scenario executes.

Create a simple three-column table: Screening Question | Keap Custom Field Name | Pass Threshold. For example:

• Years of relevant experience → exp_years (Number field) → Pass if ≥ 3
• Required certification held → cert_required (Yes/No field) → Pass if Yes
• Available to start within 30 days → start_availability (Yes/No field) → Pass if Yes
• Salary expectation within band → salary_expectation (Number field) → Pass if ≤ [band maximum]

Then go into Keap and create every custom field on this list before touching Make.com™. Note the exact field name as Keap stores it — capitalization and spacing matter when Make.com™ maps values to fields via the API.

Define your three routing outcomes at this stage:

1. Qualified — All hard criteria met. Routes to interview scheduling.
2. Needs Review — Meets most criteria but one or more soft conditions warrant human review. Routes to recruiter queue.
3. Not Suited — Fails one or more hard criteria. Routes to rejection sequence or archive.

For precision on field mapping and tag architecture, see the guide on automating Keap tags and custom fields with Make.com™.

Step 2 — Build or Configure Your Application Form and Webhook

Your application form must collect every field defined in Step 1 and deliver the data to Make.com™ the instant the candidate submits. A webhook is the correct delivery mechanism — it fires in real time with no batch delay.

Create the Make.com™ Webhook URL

1. Open Make.com™ and create a new scenario.
2. Add a Webhooks → Custom Webhook module as the trigger.
3. Click Add to generate a unique webhook URL. Copy this URL.
4. Leave the scenario open — you will run a test submission to populate the data structure in the next step.

Configure Your Form

Point the form’s submission action to the Make.com™ webhook URL you just generated. The exact method depends on your form platform:

• Keap web form: Use a post-submission redirect or the Keap-to-Make.com™ Keap trigger (New Contact or Tag Applied) as an alternative entry point if the native form cannot post to an external URL.
• Third-party form (Typeform, Google Forms, JotForm): Use the form platform’s webhook or integration settings to post submission data to the Make.com™ webhook URL.
• Custom HTML form: Set action to the webhook URL and method to POST.

For the full technical walkthrough on webhook configuration, see setting up webhook triggers for instant Keap automation.

Step 3 — Parse the Incoming Webhook Data in Make.com™

With the webhook URL configured, submit a real test application using sample data that covers every field. Make.com™ captures this submission and maps the incoming JSON into a usable data bundle.

1. In Make.com™, click Run once on your scenario to put it in listening mode.
2. Submit your test form using sample candidate data — fill in values that correspond to a “Qualified” outcome so you can verify the happy path first.
3. Make.com™ captures the submission and displays the incoming data structure in the webhook module output panel.
4. Confirm every field from your Step 1 table appears in the data bundle with the correct value and data type. If a field is missing, check the form field name matches what the webhook is posting.
5. Save the scenario. The webhook data structure is now locked in — subsequent modules can reference these fields by name.

At this stage your scenario has one module (the webhook trigger) and nothing else. Resist the urge to add logic until the incoming data is clean and verified.

Step 4 — Deduplicate Contacts in Keap

Before creating or updating any Keap record, check whether the candidate already exists. Skipping this step creates duplicate contacts that corrupt qualification history and break downstream sequences.

1. Add a Keap → Search Contacts module after the webhook trigger.
2. Set the search filter to Email Address equals the email value from the webhook data bundle.
3. After the Search module, add a Router module with two paths:
   • Match found — Filter: Number of results > 0. Route to an Update Contact module.
   • No match — Filter: Number of results = 0. Route to a Create Contact module.
4. Both paths converge into the qualification router in Step 5. The Update path uses the existing contact ID from the search result; the Create path uses the new contact ID returned by the Create module.

This deduplication step is the single most common thing missing from pre-screening workflows that come to us for troubleshooting. Build it in from the start.

Step 5 — Build the Router and Qualification Branches

The Router module is where your documented qualification logic becomes executable code. Each branch is a set of filter conditions that evaluate the candidate’s submitted data against your thresholds from Step 1.

1. After the deduplication paths converge, add a Router module.
2. Create Branch 1: Qualified
   • Add filters for all hard pass criteria: exp_years ≥ 3 AND cert_required = Yes AND start_availability = Yes
   • This branch executes only when all conditions are true simultaneously.
3. Create Branch 2: Needs Review
   • Add filters for the partial-match scenario: candidate meets experience and certification thresholds but fails a soft criterion (e.g., start date is 31–60 days out).
   • The filter should explicitly exclude full-Qualified cases to prevent candidates from matching both branches.
4. Create Branch 3: Not Suited
   • Use a fallback filter: Otherwise (Make.com™ executes this branch when no prior branch matched).
   • This catches any candidate who fails one or more hard criteria.

For deep guidance on filter construction and conditional logic patterns, see mastering conditional logic in Make.com™ for Keap campaigns.

Step 6 — Write Qualification Outcomes Back to Keap

Each router branch must write two things to Keap: the qualification tag and any relevant custom field updates. Tags are the authoritative stage record — every downstream Keap automation reacts to tags, not to Make.com™ calls.

In the Qualified Branch:

• Add a Keap → Apply Tags module. Apply the Qualified tag and the role-specific tag (e.g., Role - Senior Developer).
• Add a Keap → Update Contact module. Write the qualification score or notes to the appropriate custom field.
• Update the pipeline stage field to Qualified - Pending Interview.

In the Needs Review Branch:

• Apply the Needs Review tag.
• Update a review_notes custom field with the specific criterion that triggered the review flag (use Make.com™ text aggregation to build this string from the conditional data).
• Optionally assign to a specific Keap user (recruiter) using the Owner field.

In the Not Suited Branch:

• Apply the Not Suited tag.
• Write the disqualifying criterion to a custom field for reporting purposes.
• Do NOT delete the contact record — archive it with a tag so the data is available for future requisitions or for reporting on disqualification reasons.

Step 7 — Activate Downstream Keap Automations

The Make.com™ scenario’s job ends when the tag is written. From here, Keap’s native automation engine takes over. Build three sequences in Keap — one per qualification outcome.

Qualified Sequence

• Trigger: Qualified tag applied
• Action 1: Send confirmation email acknowledging the application and setting expectation for next steps
• Action 2: Wait 30 minutes, then trigger interview scheduling (see automating interview scheduling after candidates clear pre-screening)
• Action 3: Add contact to the role-specific pipeline view

Needs Review Sequence

• Trigger: Needs Review tag applied
• Action 1: Send internal task to assigned recruiter with the candidate’s review notes
• Action 2: Send candidate an acknowledgment email (no decision communicated)
• Action 3: Set a follow-up reminder for the recruiter in 24 hours

Not Suited Sequence

• Trigger: Not Suited tag applied
• Action 1: Wait 24 hours (prevents instant-rejection experience)
• Action 2: Send a professional, role-specific rejection email
• Action 3: Remove the contact from active pipeline views and apply an Archived tag

SHRM data indicates that a poor candidate experience during the screening process damages employer brand — an automated, timely rejection is measurably better for reputation than a manual process where candidates receive no response for weeks.

For building the full nurture architecture, see building automated recruitment pipelines with Keap and Make.com™.

Step 8 — Test Every Branch and Verify Results

Never deploy a qualification workflow without testing every branch path with synthetic data. A scenario that routes “Qualified” candidates correctly but silently drops “Not Suited” candidates into a broken branch means unqualified candidates receive no rejection — a real operational and brand risk.

Testing Protocol

1. Create three synthetic candidate profiles — one per expected outcome. Use fictional names and email addresses on a domain you control.
2. Submit each test application through your live form. Use data values specifically calibrated to hit the target branch for each profile.
3. In Make.com™, confirm the execution log shows the correct branch was activated for each submission.
4. In Keap, open each test contact record and verify:
   • The correct qualification tag is applied
   • Custom fields are populated with the correct values
   • The pipeline stage is updated correctly
   • The appropriate Keap sequence has started (check the sequence status on the contact record)
5. Verify that the correct email was sent (or queued) for each test contact.
6. Delete test contacts from Keap after verification.

If any branch fails, check the Make.com™ execution log for the specific module that errored. The most common failures are: filter logic that is too broad (multiple branches match the same candidate), Keap API authentication errors, or field name mismatches between the webhook data and the Keap Update Contact module mapping.

For systematic troubleshooting, see fixing common Make.com™ Keap integration errors.

Step 9 — Monitor, Measure, and Refine

Deployment is not the finish line. The qualification thresholds you set on day one are hypotheses — real candidate data will reveal whether they are calibrated correctly.

Metrics to Track Weekly

• Pre-screen-to-interview conversion rate: What percentage of applicants clear pre-screening and reach an interview? If this number is above 80%, your thresholds are too loose. Below 10%, they may be too strict for the candidate pool.
• Weekly recruiter triage hours: Track time spent on manual application review before and after deployment. APQC benchmarks show significant variance in time-to-fill across organizations — your baseline establishes the ROI case.
• Time from submission to qualification tag applied: This should be under five minutes for any webhook-triggered scenario. Delays indicate API rate limiting or scenario execution queuing.
• Make.com™ incomplete runs: Review the execution log daily for the first two weeks. Any incomplete run represents a candidate who was not processed — a direct operational risk.

UC Irvine research on task interruption found that context-switching between manual review tasks compounds the time cost significantly. Every application your scenario processes without recruiter involvement is time returned to higher-value work.

Parseur’s Manual Data Entry Report documents a per-employee annual cost of manual data processing at $28,500 — pre-screening automation directly attacks this cost by eliminating the manual data transcription step from application to CRM record.

For building the measurement infrastructure, see measuring Keap and Make.com™ metrics to prove automation ROI.

How to Know It Worked

Your pre-screening workflow is performing correctly when all of the following are true:

• Every application form submission appears in the Make.com™ execution log within 60 seconds of submission
• Zero applications require manual routing by a recruiter — every record in Keap has a qualification tag applied by the scenario
• Recruiters report spending time only on Qualified and Needs Review candidates — the Not Suited queue is handled entirely by automated sequences
• The Make.com™ execution log shows zero incomplete runs after the first week of live operation
• The Keap sequence status on every processed contact shows a sequence is active or completed — no contact is tag-applied but sequence-orphaned

Common Mistakes and How to Avoid Them

Mistake 1: Building the scenario before documenting criteria

The scenario expresses your qualification logic. If the logic isn’t written down and agreed on before you open Make.com™, you will rebuild the Router branches multiple times as stakeholders change their minds. Lock the spec first.

Mistake 2: Omitting the deduplication step

Duplicate Keap contacts are the most common post-launch complaint. The Search Contacts → Router → Create/Update pattern costs twenty minutes to build and saves hours of cleanup. Always include it.

Mistake 3: Using Make.com™ to trigger Keap sequences directly via API

Keap sequence IDs change when sequences are rebuilt. If Make.com™ calls a sequence by ID, a rebuilt sequence silently breaks the workflow. Use tags as the handoff point — tags are stable identifiers that survive sequence edits.

Mistake 4: Testing only the Qualified branch

Most teams test the happy path and go live. Untested branches fail silently in production. Test all three outcomes with synthetic data before deployment.

Mistake 5: Setting thresholds without real candidate data

Initial thresholds are hypotheses. Review the pre-screen-to-interview conversion rate after the first 50 real applications and adjust thresholds accordingly. A workflow that routes 95% of applicants to “Not Suited” is not filtering — it is blocking.

Next Steps

With a working pre-screening and qualification workflow in place, the next layer of the recruiting automation stack is interview scheduling for qualified candidates and candidate experience personalization for the nurture sequences. Both build directly on the tag architecture you established here.

Return to the complete guide to recruiting automation with Make.com™ and Keap to map the full pipeline and identify which workflow to build next.