Recruitment screening and interview preparation automation

Introduction

Recruitment teams spend an enormous amount of time on repetitive tasks. Screening CVs, identifying qualified candidates, preparing interview briefs, and compiling candidate summaries consume hours that could be spent on actual relationship-building and decision-making. The problem compounds when you're hiring for multiple roles; you might receive hundreds of applications, yet only have capacity to properly review a fraction of them.

The real friction point isn't the shortage of tools; it's the manual handoff between them. Your applicant tracking system doesn't talk to your document generator. Your interview prep software requires you to copy and paste candidate information. You end up maintaining multiple spreadsheets and documents because no single system captures the complete recruitment lifecycle. What if you could move a candidate through screening, interview preparation, and briefing generation entirely without touching a keyboard after the initial upload?

This workflow combines three focused tools with an orchestration layer to create an end-to-end recruitment pipeline. When a candidate applies, the system automatically screens their CV, generates interview questions tailored to their background, and produces a structured brief for the hiring manager. No manual data entry. No lost context between stages.

The Automated Workflow

Which Orchestration Tool to Use

For this particular workflow, n8n is the best choice. Zapier would work, but n8n's ability to handle complex JSON transformations and conditional logic without additional steps makes it faster to build and cheaper to run. Make (Integromat) is equally capable, but its interface makes the data transformation steps harder to follow. Claude Code offers the most flexibility if you're comfortable with Python, though it requires you to host it yourself.

This guide uses n8n, assuming you're self-hosting or using the cloud version. If you prefer Zapier, the logic translates directly; you'd just use their built-in transformers instead of n8n's expression language.

Setting Up the Trigger

The workflow begins when a CV lands somewhere accessible. For this example, we'll assume you're using an email inbox or a form submission. The simplest approach is a webhook that receives candidate data.

Copy
POST /webhook/new-candidate
Content-Type: application/json

{
  "candidate_name": "Alice Johnson",
  "candidate_email": "alice@example.com",
  "role": "Senior Software Engineer",
  "cv_text": "10 years experience in Python...",
  "job_description": "We're looking for a senior engineer..."
}

In n8n, create a Webhook node set to POST. Configure it to accept the fields above. If you're collecting CVs from email, use the Gmail node with a filter for a specific label (e.g., "New Applications"). If using a form, Typeform or similar tools can POST directly to your n8n webhook.

Step 1: CV Screening with Cogram

Cogram is primarily designed for meeting transcription and note-taking, but it has an API that lets you send document content for analysis. The Cogram API can extract key information and assess relevance.

First, you need a Cogram API key. Get one from your Cogram dashboard under Settings > API.

In your n8n workflow, add an HTTP Request node after the webhook trigger:

Copy
Node type: HTTP Request
Method: POST
URL: https://api.cogram.com/v1/analyse
Headers:
  Authorization: Bearer YOUR_COGRAM_API_KEY
  Content-Type: application/json

Body (JSON):
{
  "document": "{{ $json.cv_text }}",
  "prompt": "Extract the following from this CV: years of experience, key technical skills, previous companies, education, and any red flags (gaps, mismatches with role requirements). Output as structured JSON."
}

Cogram will return structured data. The response looks like this:

Copy{
  "years_experience": 10,
  "technical_skills": ["Python", "AWS", "Docker", "PostgreSQL"],
  "previous_companies": ["Google", "Amazon", "Stripe"],
  "education": "BSc Computer Science, MIT",
  "red_flags": [],
  "match_score": 0.87
}

Save this response in a variable. In n8n, the HTTP node automatically stores the response, so you can reference fields using {{ $json.years_experience }} in subsequent nodes.

Step 2: Decision Gate

Add a Switch node to evaluate the match score. If it's below 0.6, skip interview preparation and send a polite rejection email. If it's 0.6 or above, continue to interview prep.

Copy
Condition: {{ $json.match_score }} >= 0.6
True branch: Continue to interview prep
False branch: Send rejection email

For the rejection branch, use the Gmail or SMTP node:

Copy
Node type: Gmail
To: {{ $json.candidate_email }}
Subject: Application Update
Body: Thank you for applying to {{ $json.role }}. 
We appreciate your interest, but we've decided to move forward with other candidates at this time.

Step 3: Interview Question Generation with Hyperwrite

Hyperwrite is a writing assistant API that generates contextual content. Use it to create interview questions based on the candidate's background and the job description.

Get a Hyperwrite API key from your account settings.

Copy
Node type: HTTP Request
Method: POST
URL: https://api.hyperwrite.com/v1/generate
Headers:
  Authorization: Bearer YOUR_HYPERWRITE_API_KEY
  Content-Type: application/json

Body (JSON):
{
  "prompt": "Generate 8 technical interview questions for a {{ $json.role }} role. The candidate has {{ $json.years_experience }} years of experience and skills in {{ $json.technical_skills.join(', ') }}. Previous roles: {{ $json.previous_companies.join(', ') }}. Tailor questions to assess depth in their listed skills and identify gaps. Format as a numbered list.",
  "temperature": 0.7,
  "max_tokens": 1200
}

Hyperwrite returns:

Copy{
  "generated_text": "1. Walk us through your most complex Python project...\n2. How have you handled scaling challenges...",
  "tokens_used": 340
}

Store this in a variable; you'll use it in the next step.

Step 4: Candidate Brief Generation with Micro1-AI

Micro1-AI is designed for rapid content generation and summarisation. Use it to create a structured interview brief for the hiring manager.

Copy
Node type: HTTP Request
Method: POST
URL: https://api.micro1.ai/v1/generate
Headers:
  Authorization: Bearer YOUR_MICRO1_API_KEY
  Content-Type: application/json

Body (JSON):
{
  "task": "create_interview_brief",
  "candidate_name": "{{ $json.candidate_name }}",
  "role": "{{ $json.role }}",
  "years_experience": {{ $json.years_experience }},
  "skills": {{ $json.technical_skills }},
  "companies": {{ $json.previous_companies }},
  "cv_summary": "{{ $json.cv_text }}",
  "interview_questions": "{{ $node['Hyperwrite'].data.body.generated_text }}",
  "output_format": "markdown"
}

Micro1-AI generates a structured brief:

Copy**Role:** Senior Software Engineer

**Match Score:** 87%

**Background:** 10 years experience at Google, Amazon, Stripe. Strong Python and AWS expertise.

**Key Strengths:**
- Deep cloud infrastructure experience
- Proven track record at top-tier companies
- Relevant technical stack

**Areas to Explore:**
- Leadership and team collaboration
- Experience with our specific tech stack

**Suggested Questions:** [8 questions included above]

Step 5: Document Storage and Distribution

Now you have three pieces of output:

1. Screening summary (from Cogram)
2. Interview questions (from Hyperwrite)
3. Interview brief (from Micro1-AI)

Add a Google Drive or Dropbox node to save these documents. Alternatively, use the Gmail node to send them directly to the hiring manager.

Option A: Save to Google Drive

Copy
Node type: Google Drive
Operation: Create file
Name: {{ $json.candidate_name }} - Interview Brief.md
Folder ID: YOUR_FOLDER_ID
File content: {{ $node['Micro1-AI'].data.body.output }}

Option B: Email to hiring manager

Copy
Node type: Gmail
To: hiring.manager@company.com
Subject: Interview Brief - {{ $json.candidate_name }} ({{ $json.role }})
Body: {{ $node['Micro1-AI'].data.body.output }}
Attachments:
  - Interview questions from Hyperwrite
  - CV screening summary

Step 6: Update ATS or CRM

Finally, log the screening result back to your applicant tracking system. Most ATSs have webhooks or APIs. For example, if using Lever or Greenhouse:

Copy
Node type: HTTP Request
Method: PATCH
URL: https://api.lever.co/v1/candidates/{{ $json.candidate_id }}
Headers:
  Authorization: Bearer YOUR_LEVER_API_KEY
  Content-Type: application/json

Body (JSON):
{
  "tags": ["screened", "interview_scheduled"],
  "custom_fields": {
    "match_score": {{ $json.match_score }},
    "technical_skills_identified": "{{ $json.technical_skills.join(', ') }}"
  },
  "notes": "CV screening completed. Match score: {{ $json.match_score }}. Interview brief generated and sent to hiring manager."
}

Putting It Together in n8n

Your workflow should look like this:

1. Webhook trigger (receives candidate data)
2. HTTP node calling Cogram API (screen CV)
3. Switch node (evaluate match score)
4. Gmail node (send rejection if score < 0.6)
5. HTTP node calling Hyperwrite API (generate questions)
6. HTTP node calling Micro1-AI API (generate brief)
7. Google Drive node (save brief)
8. Gmail node (send to hiring manager)
9. HTTP node (update ATS)

Configure error handling on each API node; if Cogram fails, you want a notification rather than a silent failure. Use n8n's error handling nodes to catch exceptions and send Slack messages to your recruitment team.

The Manual Alternative

If orchestration feels like overkill, you can run this workflow semi-automatically. Save candidate CVs to a specific Google Drive folder. Run a scheduled Python script (or Make automation) once per day that reads new files, sends them through Cogram, Hyperwrite, and Micro1-AI, then saves the output. This reduces real-time responsiveness but cuts orchestration complexity and costs.

Alternatively, create a simple web form using Typeform or Google Forms that captures candidate data, then manually trigger the workflow from n8n's UI. This gives you a checkpoint to verify data quality before automation begins, though it reintroduces manual handoff.

Pro Tips

Rate Limiting and Cost Control

Hyperwrite and Micro1-AI charge per request. With high application volume, costs accumulate quickly. Add a delay node between API calls (n8n supports {{ $json.delay_seconds }}) to spread requests across the day. Set a monthly API budget in each tool's settings; most will notify you before overages. Consider batch processing: collect candidates for 2-3 hours, then run screening in bulk, rather than one at a time.

Error Handling and Retry Logic

API calls fail. Networks timeout. Add retry logic to every HTTP node: set retries to 3 with exponential backoff. For critical steps like Cogram screening, implement a fallback; if the API fails, send the CV to a human reviewer rather than silently rejecting the candidate. In n8n, use the "Continue on error" option and add a conditional branch that checks for null responses.

Data Privacy and Compliance

CVs contain sensitive personal information. GDPR compliance requires that you only retain CV data for as long as necessary. Set up automatic deletion: after 90 days (or your retention policy), run a workflow that removes CV text from your database and logs only the final decision. Don't store full CV text in n8n logs; use masks or summaries instead. Ensure your orchestration tool's servers are in compliant regions.

Testing and Iteration

Before deploying, run the workflow with test data. Create a fake candidate profile and watch each step execute. Check that API responses match expectations; sometimes fields are null or formatted differently than documentation suggests. Log outputs at each stage using n8n's debug nodes, so you can diagnose issues without running the full workflow repeatedly.

Extending the Workflow

Once screening and interview prep are automated, add reference checking. After an offer is accepted, send a webhook to HubSpot or your CRM to create a new contact. Build a feedback loop: if a candidate you screened highly doesn't perform well in the interview, adjust your Cogram prompt to catch similar weaknesses in future candidates. Track which interview questions yield the most useful responses and continuously refine Hyperwrite's prompt.

Cost Breakdown

For teams hiring 50+ candidates per month, this automation pays for itself by freeing hiring manager time alone, not accounting for better candidate experience and fewer rejected-in-error cases.