JobDavis, AI-powered job search copilot and resume matching engine

Project Overview

JobDavis is a job-search copilot that scores how well a resume matches a specific job description. The product targets job seekers who want to understand, before they apply, what an applicant tracking system is likely to see. We built the parsing pipeline, the matching logic, and the web product that wraps both.

Client Background

JobDavis operates in HR tech. The team wanted to give job seekers visibility into the filters that quietly reject most resumes. Recruiters have keyword filters and ranking tools. Candidates have guesswork. The brief was to close that gap with a product that feels honest, not gamed.

The Problem

Job seekers upload resumes blind. Automated filters score those resumes in seconds against keywords the candidate cannot see. A strong applicant gets cut because of phrasing, not capability. Recruiters get drowned in volume and rely on those same filters. Both sides lose signal.

The team needed a tool that:

• Reads a resume the way a parser reads it, not the way a human reads it.
• Compares that parsed view against a real job description.
• Tells the candidate, in plain language, what is missing.

Challenges

• Resume layouts vary wildly. Two-column PDFs, tables, images, exported Word files. A generic parser breaks on all of them.
• Job descriptions are noisy. They mix hard requirements, nice-to-haves, and boilerplate.
• A match score has to feel credible. A number with no reasoning attached is easy to dismiss.
• Pure LLM extraction is expensive at scale and harder to debug when a field is wrong.
• Users expect a fast result. A multi-second wait on every upload is a churn risk.

Our Approach

We split the work into two layers. A custom NLP parsing pipeline handles structured extraction from resumes and job descriptions. The LLM handles the parts that benefit from language understanding: synonym mapping, summarizing requirements, and explaining gaps in human terms.

We picked this split for three reasons. The parser is cheap and consistent. The LLM is flexible where rules fail. And the combination gives us a result we can audit, not just a black-box score.

What We Built

User Experience

• A single upload step for the resume.
• A paste field for the job description.
• A scored result view with the match percentage, matched signals, and missing keywords.
• Plain language feedback the user can act on without reading a manual.

Parsing Pipeline

• A custom NLP parser built specifically for resume structure.
• Field extraction for roles, dates, skills, education, and free-text experience.
• Format handling for the common resume layouts users actually upload.

Matching and Scoring

• Combined semantic and keyword comparison between parsed CV and parsed JD.
• A match score the user can act on, not just admire.
• Missing-keyword detection that highlights what the JD asks for and the CV does not show.

Feedback Loop

• Clear callouts for gaps, so the candidate knows what to add or rephrase.
• Output framed as suggestions, not a rewrite, to keep the candidate's voice.

Technical Architecture

The product is a Next.js front end backed by a Python service. The Python service runs the parsing pipeline and orchestrates calls to the OpenAI API for the language-heavy steps. Supabase stores user data and results.

The parser runs first and produces a structured view of the resume and the job description. The scoring layer compares those structured views. The LLM is used for the steps where rules are brittle, such as recognizing that "client-facing" and "stakeholder management" point at the same skill.

Key Decisions

• Custom NLP parser instead of LLM-only extraction. We chose this for cost, speed, and debuggability. We gave up some of the flexibility a pure LLM gives on unusual layouts.
• Combined semantic and keyword scoring. We chose this because keyword-only feels like the filters candidates are trying to beat, and semantic-only is hard to defend when a user asks why a score is what it is. We gave up a single simple number for a slightly more complex result view.
• Supabase as the data layer. We chose this for speed of build and clean auth out of the box. We gave up some flexibility we would get from rolling our own backend.
• Surface missing keywords, not rewritten resumes. We chose this to keep the candidate's voice and avoid generic AI-sounding output. We gave up the easier marketing story of a one-click rewrite.

Results

• Job seekers can see how their resume reads against a specific role before they apply.
• The match-rate signal holds across diverse resume formats and industries, with an average accuracy of 85% as reported by the team.
• Feedback is concrete enough to act on: which keywords are missing, which sections are weak.
• The split between parser and LLM keeps response times usable and costs predictable.

Project Highlights

• Custom NLP parsing pipeline built specifically for resume structure.
• 85% average match-rate accuracy between CVs and job descriptions.
• Combined semantic and keyword scoring for results the user can act on.
• Missing-keyword highlighting that targets the gap, not the whole resume.
• Clean split between deterministic parsing and LLM-driven language steps.

Screens and User Flows

The core flow is short by design: upload, paste, score, act. The user uploads a resume, pastes a target job description, and gets a scored result with the missing signals called out.

Future Growth Opportunities

• A recruiter-side view that ranks inbound resumes against a JD using the same engine.
• Bulk JD ingestion from job boards, so a candidate can score one CV against many roles at once.
• Longitudinal tracking, so a user can see how edits to their resume change the score for a target role.
• Industry-specific scoring profiles, tuned for fields where the language differs sharply from generic corporate roles.
• An API for career coaches and bootcamps to plug the scoring into their own workflows.