Candidate screening and interview preparation automation

Recruiting teams spend enormous amounts of time on repetitive work: screening CVs, extracting key information, scheduling interview prep sessions. A hiring manager might spend two hours reviewing ten applications, another hour preparing interview questions, and another hour sending candidates materials they need to study. Multiply that across a busy hiring season and you're looking at days of wasted effort on tasks that follow the same pattern every single time.

The good news is that this workflow is almost entirely automatable. You can build a system that pulls structured candidate data from PDFs, generates personalised interview preparation materials, and schedules everything into your calendar without human intervention. The only moment someone needs to touch the system is when they want to review the final recommendations before making a hiring decision.

This post walks you through building exactly that: a candidate screening and interview preparation pipeline that takes a CV as input and delivers a fully prepared interview brief as output. We'll use three tools that are genuinely good at their jobs, wire them together with an orchestration platform, and show you how to run this with virtually no manual handoff.

The Automated Workflow

The workflow operates in three distinct phases: CV parsing and candidate profiling, interview question generation, and brief compilation. Here's how the pieces fit together.

Phase 1:

Extract Candidate Data from CV

Your first step is to parse the PDF CV and pull out structured information. Chat with PDF by Copilotus is purpose-built for this kind of document analysis. Instead of squinting at text, you send it the PDF and ask for JSON output with specific fields.

The orchestration tool (Zapier, n8n, or Make) receives a trigger—typically a file upload to Google Drive, Dropbox, or an email with an attachment. It then calls the Chat with PDF API to analyse the document.

Here's what a typical request looks like using n8n's HTTP node:

Copy
POST https://api.copilotus.app/v1/chat-with-pdf
Authorization: Bearer YOUR_API_KEY
Content-Type: application/json

{
  "file_url": "https://storage.example.com/cv-john-smith.pdf",
  "prompt": "Extract the following information from this CV and return it as JSON: full_name, job_titles (array), years_of_experience (number), technical_skills (array), soft_skills (array), education (array with school, degree, year), previous_companies (array). Be precise and extract only what is explicitly stated."
}

The API returns structured JSON back to your orchestration tool:

Copy{
  "full_name": "John Smith",
  "job_titles": ["Senior Software Engineer", "Software Engineer"],
  "years_of_experience": 6,
  "technical_skills": ["Python", "JavaScript", "AWS", "PostgreSQL", "Docker"],
  "soft_skills": ["Team leadership", "Project management", "Communication"],
  "education": [
    {
      "school": "University of Manchester",
      "degree": "BSc Computer Science",
      "year": 2018
    }
  ],
  "previous_companies": ["TechCorp Ltd", "StartupXYZ", "DevShop"]
}

Store this JSON in a variable within your orchestration tool. You'll pass it through the remaining steps.

Phase 2:

Generate Tailored Interview Questions

With structured candidate data in hand, you now use Cogram to generate interview questions that are specific to this candidate's background and experience. Cogram excels at understanding context and producing outputs that feel human, not templated.

Create an HTTP request to Cogram's API endpoint. The prompt should include the candidate data you extracted:

Copy
POST https://api.cogram.com/v1/generate
Authorization: Bearer YOUR_COGRAM_API_KEY
Content-Type: application/json

{
  "model": "cogram-pro",
  "messages": [
    {
      "role": "system",
      "content": "You are an experienced recruiting consultant. Generate 8 targeted interview questions based on a candidate's CV. Each question should probe their specific experience, not generic competencies. Return the output as a JSON array."
    },
    {
      "role": "user",
      "content": "Generate interview questions for: Name: John Smith, Experience: 6 years as a software engineer, Technical skills: Python, JavaScript, AWS, PostgreSQL, Docker. Previous roles at: TechCorp Ltd (enterprise software), StartupXYZ (fast-paced environment), DevShop (freelance). We are hiring for a backend engineering role focused on API development and system design. Focus questions on their experience with scalability, their approach to system design decisions, and their experience moving from startup to enterprise environments."
    }
  ],
  "temperature": 0.7,
  "max_tokens": 1200
}

Cogram returns structured output:

Copy{
  "questions": [
    {
      "question": "You've worked in both startup and enterprise environments. Walk me through a technical decision you made at StartupXYZ that you would have handled differently at TechCorp.",
      "intent": "Assess adaptability and understanding of context-dependent engineering",
      "follow_up_prompt": "What was the trade-off you were willing to accept?"
    },
    {
      "question": "Tell me about a time you designed an API that needed to scale from hundreds to millions of requests. What was the bottleneck and how did you address it?",
      "intent": "Assess practical knowledge of scalability and system design",
      "follow_up_prompt": "Which metrics did you monitor to validate the improvement?"
    }
  ]
}

Your orchestration tool stores this array in another variable. You're building up a complete interview brief as you move through each stage.

Phase 3:

Compile and Schedule Using HyperBound AI

HyperBound AI specialises in scheduling and calendar integration. In this phase, you create the interview brief document and schedule both the interview itself and a prep session with the candidate.

First, compile everything into a formatted interview brief. In n8n or Make, you can use a template string node to construct a professional document. Something like:

Copy
Interview Brief for {{full_name}}

CANDIDATE SUMMARY
Name: {{full_name}}
Years of Experience: {{years_of_experience}}
Previous Roles: {{previous_companies.join(", ")}}
Technical Skills: {{technical_skills.join(", ")}}

INTERVIEW QUESTIONS
{{#each questions}}
Q{{@index}}: {{this.question}}
Intent: {{this.intent}}
Follow-up: {{this.follow_up_prompt}}
{{/each}}

PREPARATION MATERIALS
- Review candidate's GitHub profile
- Prepare system design whiteboard questions
- Have database schema discussion ready

Save this as a text or PDF file (you can use a Make/n8n PDF generation module).

Now integrate HyperBound AI to schedule the actual interview. HyperBound API handles calendar availability across multiple calendars:

Copy
POST https://api.hyperbound.ai/v2/schedule-interview
Authorization: Bearer YOUR_HYPERBOUND_KEY
Content-Type: application/json

{
  "candidate_email": "john.smith@email.com",
  "candidate_name": "John Smith",
  "interviewer_emails": ["hiring.manager@company.com", "tech.lead@company.com"],
  "duration_minutes": 60,
  "date_range": {
    "start": "2024-01-15",
    "end": "2024-01-22"
  },
  "timezone": "Europe/London",
  "title": "Backend Engineer Technical Interview",
  "description": "Technical interview for Backend Engineer position. See attached brief.",
  "attachments": [
    {
      "file_path": "interview_brief_john_smith.pdf",
      "mime_type": "application/pdf"
    }
  ],
  "prep_session": {
    "enabled": true,
    "days_before_interview": 2,
    "duration_minutes": 30,
    "title": "Interview Prep Session: Backend Engineer Role",
    "description": "This session covers what to expect, the technical areas we'll discuss, and your opportunity to ask questions."
  }
}

HyperBound returns confirmation with scheduled times:

Copy{
  "success": true,
  "interview_scheduled": {
    "event_id": "evt_abc123",
    "scheduled_time": "2024-01-18T14:00:00Z",
    "attendees": ["john.smith@email.com", "hiring.manager@company.com", "tech.lead@company.com"],
    "calendar_invitation_sent": true
  },
  "prep_session_scheduled": {
    "event_id": "evt_def456",
    "scheduled_time": "2024-01-16T10:30:00Z",
    "attendees": ["john.smith@email.com"],
    "calendar_invitation_sent": true
  }
}

At this point, the candidate has received two calendar invitations and the interview brief is attached. Your hiring team has the brief ready in advance. The workflow is complete.

Choosing Your Orchestration Platform

For this particular workflow, here's how the three main options stack up:

n8n: Best choice for most teams. Self-hosted option available, good API support for all three tools, visual workflow editor makes it easy to debug data flow. You can see exactly what's being passed between steps. Free tier available if you host it yourself.

Zapier: Simplest setup if you want zero infrastructure. Built-in integrations for many of these tools, pre-made templates might exist. Monthly costs add up if you're running this daily, but for lower volume hiring it's reasonable. Less customisation on prompt engineering.

Make (Integromat): Middle ground between n8n and Zapier. Good visual editor, decent API coverage, reliable. Pricing is reasonable. Good choice if you prefer not to self-host but want more control than Zapier.

Claude Code: Less conventional but worth noting. If you're already deep in Claude's ecosystem, Claude Code can orchestrate API calls directly. Write a Python script that handles the entire workflow, save it as a Claude project, and trigger it via scheduled API call or webhook. This works surprisingly well for straightforward workflows but lacks the visual debugging and error handling features of dedicated orchestration tools.

For most teams, start with n8n. The learning curve is gentler, costs are lower, and you have full visibility into what's happening at each step.

The Manual Alternative

If you prefer to handle parts of this workflow manually, that's viable too. Many teams use this hybrid approach:

• Manually upload CV to Chat with PDF and extract key points (5 minutes per candidate)
• Use Cogram to generate interview questions (1 minute, just paste the candidate summary)
• Let HyperBound handle scheduling (takes 2 minutes)

This cuts your manual work by roughly 60-70% compared to doing it all by hand. If your hiring volume is low (fewer than five candidates per week), the manual hybrid approach might be more cost-effective than paying for orchestration tool minutes.

However, the moment you're hiring actively, automation pays for itself. Once the workflow is set up, processing fifty candidates takes the same amount of system time as processing five.

Pro Tips

Error handling and validation: Set up a notification step before the final HyperBound scheduling call. If the candidate's email is missing or invalid, or if no scheduling windows are available, send a Slack or email alert to your hiring team rather than letting the workflow silently fail. In n8n, add a "If" node that checks whether all required fields are populated.

Rate limits and throttling: HyperBound AI has a standard rate limit of 100 requests per minute. If you're processing batches of candidates, don't send all requests simultaneously. Add a 2-3 second delay between candidates in your orchestration tool using a "Wait" node.

Cost optimisation: Cogram's Pro model costs more than the standard model but produces better interview questions. For junior positions, the standard model is fine. For senior hires, the Pro model is worth the extra cost given how much time a better interview saves. Set a rule in your workflow: if years_of_experience >= 5, use cogram-pro; otherwise use standard.

Reusability and templating: Build your Cogram prompt as a separate reusable template rather than embedding it in the workflow. This way, if you want to adjust how questions are generated, you change one template instead of reconfiguring the entire workflow. Store the template in a config file or as a Make/n8n global variable.

Testing before going live: Always test the entire workflow with a sample CV before deploying it. Create a test candidate profile, run it through all three stages, and verify the interview brief looks correct and the calendar invitations go to the right people. Catch integration issues now, not when you're screening real candidates.

Cost Breakdown

If you're using Zapier instead of n8n, add approximately £20-50/month depending on task volume. Make pricing is similar to n8n Cloud.

At this cost level, you break even if you're saving 2-3 hours per week in manual screening work. Most hiring teams doing active recruiting save far more than that.