Resume Bot

The Business Problem

A great job posting can bury your HR team under a mountain of resumes. Manually screening each CV, extracting key information, and transferring it to your system is slow, repetitive, and prone to human error. Your best candidates might accept another offer while you're still sorting through the pile.

Our AI Solution

We built a seamless, automated pipeline to handle the entire screening process. For new applicants, our Collector Tool lets them upload their CV, which our AI instantly reads to pre-fill your company's application form. For existing piles of resumes, our Extraction Engine can process dozens or hundreds of files at once, extracting all critical information and organizing it neatly into a Google Sheet for instant, side-by-side candidate comparison.

Your Tangible Outcome

• Reduce Time-to-Hire by 50%: Eliminate manual data entry and focus your team's time on interviewing top talent, not administrative work.
• Screen 100 Resumes in Minutes: Instantly identify the most qualified candidates based on your specific criteria.
• Improve the Applicant Experience: Offer a modern, simple, and efficient application process that impresses potential hires from day one.

The Problem Up Close

"We posted one job. We got 780 resumes. We had two recruiters."

That sentence framed the entire project. The client — a recruitment partner supporting fast-scaling companies — wasn't struggling to attract candidates. They were struggling to process them.

Three operational issues surfaced:

Manual Resume Screening Is Slow

Each CV had to be opened, interpreted, and transferred into an internal system. The work wasn't conceptually difficult, but it was time-consuming and repetitive.

Human Error Is Inevitable

Inconsistent formatting, missed skills, and simple transcription errors became more common as volume increased.

Time-to-Hire Was Slipping

While administrative processing was happening, qualified candidates were progressing elsewhere. The recruiters weren't spending most of their time evaluating talent. They were moving data between systems.

Constraints & Context

This was not a greenfield product with unlimited time. We worked within:

• A short implementation timeline
• Cost-efficient AI processing at high volume
• Support for inconsistent CV formats (PDF, DOCX, image scans)
• Mandatory Google Sheets compatibility (existing workflow)
• Secure handling of candidate data
• Scalability from 10 resumes to 500+ per batch

The system also needed to feel simple from the user's perspective. Complexity was acceptable in the backend — not in the experience.

The Solution

The result was a structured workflow with two main components.

The Collector Tool (For New Applicants)

When a candidate uploads their CV:

• The system reads the document
• Extracts structured data
• Generates a pre-filled application form

This reduces repetitive typing and shortens application time. In observed scenarios, completion time dropped from roughly 15 minutes to around 5 minutes for typical applicants.

The Extraction Engine (For Existing Resume Piles)

For recruiters handling existing backlogs:

• Dozens or hundreds of resumes can be uploaded at once
• Files are processed in parallel
• Key information (skills, experience, education, contact details) is extracted
• Output is organized into a structured Google Sheet
• Candidates can be reviewed side-by-side

This converts unstructured document piles into sortable, filterable data.

See It in Action — Live Product Demonstration

Architecture Overview

High-Level System Design

Core Components

Layer	Components
Frontend	Resume upload via n8n Form Trigger, Google Forms with prefilled fields (38 fields, 9 pages), Status/error pages via n8n Form nodes
Backend	File ingestion, LlamaCloud upload, LlamaIndex extraction, Redis caching, Prefilled URL generation, Sheets logging
AI Services	LlamaIndex extraction (GPT-4, BALANCED mode, PAGE chunking), Entry ID Map Builder for schema-to-form mapping, Fuzzy matching for completion tracking
Infrastructure	n8n (orchestration), LlamaCloud (file storage), Redis (24h cache), Google Sheets (database), Webhook-based async processing, Per-node error handling

The system was designed to be resilient to messy inputs and high variability in document structure.

Key Engineering Decisions

1. Structured Extraction Over Keyword Matching

Keyword scanning would have been cheaper and faster to implement. However, context mattered — "5 years managing teams" and "assisted a manager" should not be treated equally.

"Keyword matching created more noise than clarity. Contextual parsing improved signal quality."

Tradeoff: Higher per-resume AI processing cost.
Benefit: More reliable candidate data.

2. Parallel Processing for Speed

Batch uploads are processed simultaneously rather than sequentially. ~100 resumes processed in minutes.

Tradeoff: Required queue management and load balancing.
Benefit: Significant reduction in waiting time.

3. Google Sheets Instead of a Custom Dashboard

We considered building a dedicated interface. Instead, we integrated directly with Google Sheets — the tool recruiters were already using daily.

"Introducing a new system creates friction. Improving the current one increases adoption."

Tradeoff: Less visual control over the interface.
Benefit: Immediate usability and minimal onboarding.

4. Data Privacy by Design

Given the sensitivity of candidate information, we implemented:

• Temporary file storage
• Controlled system access
• Secure API communication

Results

(Metrics based on pilot implementation and modeled projections)

Metric	Result
Time-to-Hire Reduction	50% — Administrative overhead eliminated
Bulk Screening Speed	100 resumes in under 5 minutes
Manual Data Entry Reduction	70% — Recruiters shifted to evaluation
Candidate Experience	Shorter application time, reduced repetitive data entry

Scenario	Time (Blank Form)	Time (Prefilled)
Minimum (entry-level)	4–8 minutes	3–4 minutes
Typical (mid-career)	10–19 minutes	4–7 minutes
Full (senior applicant)	12–22 minutes	4–8 minutes

Recruiter feedback: "We finally feel ahead of the pipeline instead of buried by it."

Visuals

Candidate Upload Experience

The applicant uploads their resume through a simple form. Our AI reads the document and pre-fills the application — turning a 15-minute process into a 5-minute review.

Resume Extraction → Structured Output

Multiple resume formats are parsed, structured, and organized into a Google Sheet for instant side-by-side comparison.

Lessons Learned

Several patterns became clear during development:

• Resume data is highly inconsistent. Systems must tolerate variability in formatting, structure, and content quality.
• Volume fluctuates significantly. Scaling cannot be optional — the system must handle 10 or 500 resumes equally well.
• Workflow integration matters more than interface novelty. Building on tools people already use drives adoption faster than a flashy new dashboard.
• Speed improvements are noticeable immediately. When something that took hours takes minutes, stakeholders notice.
• AI outputs require validation layers. Trust is built by letting users verify and correct, not by assuming perfection.

What This Proves We Can Build

• End-to-end AI product pipelines
• High-volume document processing systems
• Scalable backend infrastructure
• Workflow-integrated automation
• AI systems designed for operational reliability

Applicable for recruitment agencies, RPO firms, growing businesses, enterprises modernizing HR, and investors evaluating engineering maturity.

Tech Stack

Component	What It Does
n8n	Orchestrates everything — scheduling, flow control, error handling
GPT-4 / LlamaIndex	Powers structured extraction from resumes
LlamaCloud	File storage and extraction API
Redis	24-hour caching layer for processed data
Google Sheets	Structured output, logging, and candidate comparison
Google Forms	Pre-filled application forms (38 fields, 9 pages)

Ready to Stop Sorting and Start Hiring?

If your team is processing large volumes of resumes and spending significant time on manual data entry, this approach may be relevant.

We're open to discussing similar implementations.