The Problem
A recruitment firm processing thousands of applications per month across multiple industry verticals had a throughput problem. Candidate information arrived from dozens of sources — uploaded CVs, job board scrapes, LinkedIn profiles, referral emails, and application form submissions — each in a different format, structure, and level of completeness. Before a recruiter could work with a candidate record, someone had to read the source document and re-enter the relevant information into the ATS: name, contact details, work history, skills, certifications, education, salary expectations.
The volume of inbound documents had grown faster than the team, and the mismatch was creating delays that affected both client satisfaction and candidate experience. Every application required manual review before a recruiter could make a placement decision. The underlying issue was structural: the data locked inside each document was not machine-readable. Recruiters were doing extraction work that should have been automated — reading documents to pull out structured data before they could begin matching.
The Constraints
Source diversity required adaptive parsing. A CV from a senior engineer looks structurally different from one submitted by a recent graduate, which looks different from a profile exported from LinkedIn, which looks different from a job board application. Rule-based parsing that worked on one format would fail on others. The extraction model had to learn the semantic content rather than depend on consistent formatting.
Accuracy over speed. In recruitment, an extraction error is a missed placement or a qualified candidate screened out. The system needed to handle nuanced cases: abbreviated job titles, compound skills (e.g., “DevOps/SRE”), non-standard resume formats, and multi-page cover letters with embedded context. Incorrect data in candidate records — wrong phone numbers, misattributed experience, truncated skills lists — caused downstream failures in both the recruiter workflow and the candidate experience.
ATS integration without disruption. The firm’s workflow ran through an existing Applicant Tracking System. The output schema had to match the ATS field structure directly — a system that produced extracted data requiring further transformation before ATS import would not eliminate the manual step it was designed to replace.
Continuous improvement. Recruitment terminology evolves quickly — new technologies, new certifications, new job title conventions. The extraction model needed to improve over time as the team corrected edge cases, not remain static after deployment.
Our Approach
The system is built in two layers: document extraction and candidate ranking.
The extraction layer uses NLP and machine learning trained on thousands of real recruitment documents. At the document level, the system applies layout analysis to identify structural sections regardless of formatting variation — detecting work history, education, and skills sections from content patterns rather than positional rules. Named entity recognition extracts people, organizations, dates, and skills from within each section. A disambiguation layer resolves common ambiguities: companies listed in both work history and education, dates that appear in multiple contexts, skills that are also job titles.
Rather than applying rigid templates, the model learns contextual relationships between terms — understanding that “5 years at Series B startup” carries different signal than “5 years at enterprise” for specific role types. Entities extracted include: skills (including implicit skills from project descriptions), certifications, education, employment timeline, and role seniority signals.
The output normalization layer maps extracted entities to the ATS field schema — standardizing date formats, normalizing company name variants, resolving skill synonyms (e.g., “JS” → “JavaScript”), and flagging low-confidence extractions for human review rather than silently entering potentially incorrect data. Output is structured JSON written directly to the ATS via API.
The ranking layer applies a configurable scoring model against each job description. The model maps extracted candidate attributes to role requirements — weighting must-have skills, nice-to-have skills, and experience signals according to recruiter-defined parameters. Candidates receive a ranked score with supporting reasoning, enabling recruiters to review a ranked shortlist rather than a raw stack of applications.
A feedback loop captures recruiter overrides and placement outcomes, feeding retraining cycles that improve model accuracy over time.
The Outcome
- 90% reduction in time spent on initial screening per role — manual document review eliminated for the majority of common formats
- 95% extraction accuracy across document formats, including non-standard layouts and multi-format submissions
- 40% reduction in total processing time from application receipt to placement decision
- Data accuracy improved over manual entry — structured extraction with validation catches transcription-class errors
- Pipeline handles volume spikes (high-application-volume postings, bulk sourcing campaigns) without adding staff
- Structured, searchable candidate data enables competitive analysis and market intelligence across the talent pool
Team
Engagement: 4 months, 3 engineers (1 AI/ML, 1 backend, 1 integration).
Stack: Python, OpenAI API, LangChain, TensorFlow, FastAPI, PostgreSQL, Docker, AWS