How to Build an LLM-Based Resume Analyzer

Today, most hiring processes don't begin with a human. They start with an Applicant Tracking System (ATS). Every resume gets scanned, compared against the job description, and ranked automatically. Only a small number ever make it to a recruiter’s desk.

While this system may seem efficient, it is fundamentally flawed. Traditional ATS systems work more like rigid keyword-matching machines. They often miss strong candidates with nuanced profiles, while pushing forward weaker ones who simply optimize for the right keywords. As a result, companies lose out on top talent before a human ever gets involved.

Modern hiring needs more than speed and scale. It needs a human-like understanding of context, intent, and real candidate capabilities, not just matching words on a page.

‍

💡💡 We built the LLM Based Resume Processing tool for you! Fully Open Source, Check it out here

‍

📻📻 And the video here:

‍

What are ATS Systems?

An Applicant Tracking System (ATS) stores, organizes, and manages job applications, acting as the first layer of candidate filtering. It streamlines the shortlisting process by performing the following key steps:

ATS Resume Parsing

The ATS breaks the resume into structured fields like name, contact info, work history, job titles, education, and skills. The goal is to convert the resume's content into a standardized, analyzable data format.

Keyword Matching

This is the most crucial step: matching the information against the job description.
The system scans for specific keywords like job titles (e.g., “Backend Developer”), technical skills (e.g., “React,” “AWS”), certifications, and educational qualifications. It looks for exact word-to-word matches between what's on the resume and what's in the provided job post or criteria.

ATS Scoring and Ranking

Once keyword matching is done, the ATS ranks resumes based on how well they align with the job description. Resumes with more keyword matches, relevant experience, and qualifications rank higher. Some systems even display a match score (e.g., "85% match"), with higher scores pushing resumes up the rankings.

Challenges of using ATS systems

ATS systems do help recruitment by handling scale and automating processes, but their flaws often outweigh the benefits, sometimes even hindering the hiring process. Here are the biggest issues with relying on them.

Parsing failures and rigid profiling

Conventional ATS systems rely heavily on structured parsing, which can break when resumes use non-standard formats like complex templates or multi-column layouts. This often leads to important details like job titles, skills, or education being misclassified or lost.

‍

These systems also expect traditional, linear career paths. Freelancers, startup founders, or candidates with career gaps or short-term roles are often ranked lower, simply because their experience doesn’t fit neatly into the rigid structure.

‍

A major flaw is the over-reliance on exact keyword matching. If a job description mentions "JavaScript" but a resume lists "JS," the system often fails to make the connection. It struggles with synonyms, abbreviations, and variations.

Candidates gaming the system

The overreliance on keyword prioritization has led candidates to optimize their resumes to trick the system. Many overload their "Skills" section with job description keywords, or hide entire blocks of text from the job post in white text to fool the parser.

Some candidates use variations of job titles, even if they don’t hold those exact roles. For example, a "Software Engineer" might list "Developer" or "Programmer" to cover more job posts.

This keyword stuffing inflates ATS scores but doesn’t reflect actual skills. As a result, time is wasted on resumes that look perfect to the system but fail to deliver upon closer inspection. The core issue is that ATS can’t tell the difference between genuine expertise and keyword repetition.

Lack of contextual understanding

ATS operate at a surface level, missing context, depth, and transferability. A candidate who managed a complex project but did not use exact buzzwords, may get overlooked. Career shifts, cross-functional skills, and project-based achievements often remain invisible. They also fail to assess qualities like initiative, ownership, or real-world impact.

Without reasoning abilities, ATS misses the nuances that predict job performance. For instance, they can’t infer that managing a "cloud migration project" implies experience with AWS/Azure, or that building a "Restful API in Node" suggests proficiency with JavaScript.

Language Models (LLMs) analyze resumes in a way that mirrors human understanding. They grasp the relationships between a candidate's achievements, skills, and experience, going beyond surface-level keyword matches.

By understanding context and intent, LLMs can recognize a candidate’s true potential. This leads to fairer, accurate, and more reliable candidate assessments.

How to build an LLM based Resume analyser

Instead of relying on keyword matching like traditional ATS systems, a smarter system can be built using a combination of LLMs. These models don’t just scan for terms, they understand context, connect achievements, and assess the depth of a candidate’s experience, much like a human would. Any general-purpose LLM can be paired with a reasoning-focused model to make this possible. In this case, GPT-4.1 works alongside o4-mini. Together, they deliver a far more accurate and meaningful evaluation of candidate potential.

‍

Lets break it down

‍

Job Description Analysis

The process starts with the recruiter providing the job description for the position. This job

description is then given to an LLM, in this case ‘gpt-4.1’, to analyse and break it down into three structured parts:

Must-Have Requirements

These are ‘non-negotiable’ skills, qualifications, or experiences that a candidate must meet to be considered for the role.
Example: 3+ years of backend development experience in Java.

Good-to-Have Requirements

These are additional skills or experiences that are ‘nice to have’ and can strengthen a candidate's profile but are not mandatory.
Example: Familiarity with AWS or Kubernetes.

Additional Screening Criteria

These are specific conditions or constraints that can filter candidates based on eligibility, availability, or work policies.
Example: Only candidates available for immediate joining; no remote work option.

The following prompt was used with gpt-41 for achieving the desired output.






You are an experienced technical recruiter and job posting analyst. Your task is to extract a structured summary of candidate requirements from the job description These will be used to evaluate resumes later.


Instructions:

Extract all Must-Have Requirements:




-Technical Skills: Essential technical skills

-Experience: Minimum years and type of relevant experience

-Qualifications: Mandatory degrees or certifications

-Core Responsibilities: Key duties that are non-negotiable







-Extract all Good-to-Have Requirements:




-Additional Skills: Preferred technical skills

-Extra Qualifications: Bonus education or certifications

-Bonus Experience: Extra experience that could add value






Extract any Additional Screening Criteria:




-Filtering statements that affect eligibility

-Work policy conditions

-Availability constraints

-Discriminatory or biased phrasing

-Anything else that significantly affects who should or shouldn't apply

‍

This core prompt, along with telling the model to output in the shown below JSON schema creates our prompt.

The output is returned in JSON format with four sections: original_job_description, must_have_requirements, good_to_have_requirements, and additional_screening_criteria. Each section contains structured arrays extracted from the job description.

‍

‍

The JSON output is structured, making it easier to process in the next steps. It helps the second LLM model better understand the job description compared to the original text format.

‍

The whole process is split into two parts to make the most of each model’s strengths. GPT-4.1 focuses on the job description, breaking it down to clearly understand what the role needs. Then, o4-mini evaluates the candidate, using its reasoning to assess the fit and explain why.

Resume Analysis

This stage uses ‘o4-mini’, a reasoning model that excels at step-by-step thinking, making it ideal for multi-stage evaluation tasks. The LLM takes the output from the job description analyzer and the candidate's resumes as input, and assesses each candidate's fit against the job description.

To achieve this, a single prompt is broken into three distinct parts: quantitative evaluation, qualitative assessment, and final recommendation. This modular breakdown serves two purposes.

First, it aligns with how reasoning models work best, one step at a time, ensuring more accurate and consistent results. Second, it gives us greater control. If evaluation criteria change, each section can be updated independently without reworking the entire system. This structure keeps the logic clean, flexible, and easy to evolve as hiring needs grow.

Quantitative Check

The first step is a quantitative evaluation of the candidate’s resume. This focuses on the non-negotiable, hard requirements of the job. For example, if the role needs 3+ years of Python and the candidate has only worked with Java, they miss a core requirement. This ensures we filter out mismatches early. It’s a strict check, not based on potential, but on clear criteria that must be met. This also allows the system to later focus on deeper insights and harder-to-measure qualities, such as softer skills.

‍

Below is the prompt we use for Step 1.



You are a recruiter evaluating a candidate's resume against a given job description (JD). Based on the JD, evaluate whether the candidate meets the necessary requirements.


Step 1: Quantitative Check

Perform a Boolean (true/false) check for each requirement based on the candidate's resume:



-For each skill listed in must_have_requirements and good_to_have_requirements, determine if the candidate possesses it. Return true or false for each.

-For each core_responsibility, determine if the candidate has demonstrated it in their past work. Return true or false.

-For each additional_screening_criteria, return a boolean value indicating whether the candidate meets the condition (e.g., full-time, onsite position, work authorization, etc.).

‍

Remember the JSON output from the Job Description Analyzer? In this step, o4-mini analyzes the candidate’s resume and checks each requirement from that output, providing a simple boolean (true/false) response for each one.

‍

It looks something like this:

This example shows the boolean evaluation for must_have_requirements. Similar true/false responses are also generated for good_to_have_requirements and additional_screening_criteria.

‍

Qualitative Check

The next step is the qualitative analysis of the candidate’s resume. This is where human-like understanding and holistic evaluation come in. We’re testing the candidate's inferred skills, the real-world impact of their projects, their level of ownership and initiative, and how transferable their experience is to the role. Here, we are reading between the lines to understand soft skills, the practical impact of their work, and to extract abilities that aren’t just explicitly mentioned but can be inferred from their experience.

This is where the real magic of the LLM happens, because it mirrors human evaluation, helping us judge the true potential and fit of a candidate.

This is the part of the prompt that achieves the qualitative analysis in Step 2




Step 2: Qualitative Assessment

Now, switch to a recruiter-style qualitative assessment. Use your intuition like a human — go beyond what's explicitly stated. Read between the lines, infer intent, and use contextual clues from the resume and the JD to judge fit. Reference the results from Step 1 as part of your reasoning.


Assess the following:



-Inferred Skills: What skills can you infer from the candidate's projects or roles?

-Project Gravity: Were the projects academic or real-world, high-impact, production-ready, etc.?

-Ownership and Initiative: Did the candidate lead the work? Show initiative? Or just follow directions?

-Transferability to Role: How well would their experience transfer to this particular role? Will they onboard quickly?

-Bonus Experience & Extra Qualifications: If the JD lists any bonus criteria (e.g., fintech, B2B SaaS), consider that a positive signal even if not part of Step 1.

-Recruiter Style Summary: Provide a recruiter style summary of the full profile of the candidate, consider the results of both the quantitative and qualitative assessment.

‍

Here, the result is again a JSON object, which includes the inferred skills from the candidate’s projects, the project gravity (assessing the quality, difficulty, and real-world impact of their work), the level of ownership and leadership initiative shown, and a direct evaluation of transferability that is, how well the candidate’s skills and experience fit the requirements of the role

This kind of human-like qualitative assessment is impossible with a traditional ATS system. Our method goes beyond basic keyword matching by considering all the important factors that truly affect a candidate’s quality. An ATS would never be able to assess project gravity, real-world impact, or skill transferability.

It would treat a Python project on a simple IRIS dataset the same as a complex Django backend system, giving them equal weight even though the difficulty and relevance are completely different. By automating these deeper qualitative checks, our system delivers much higher-quality results.

Final Recommendation

This is the third and final step, where we consider both qualitative and quantitative factors to give a clear recommendation on whether the candidate should move forward. The output is a simple "Yes" or "No" based on a well-rounded evaluation.

Along with the final recommendation, it also provides the factors and reasoning behind the decision. The following prompt is used for Step 3

‍




## Step 3: Final Recommendation 

After both steps, make a final call. Output "Yes" or "No" and summarize your reasoning concisely.

‍

Here’s an example of the expected JSON output for this step:

Traditional ATS vs LinkedIn vs LLM-based Resume Analyser

To truly understand the difference, we ran a simple test. We supplied the same resume and job description to a traditional ATS checker, LinkedIn's new AI feature for recruiters, and the proposed LLM-based Resume Analyzer.

The goal is to compare how each system interprets the resume, what kind of evaluation it provides, and how accurate or useful the results are for real hiring decisions.

Given below is the job description we posted on LinkedIn for a Machine Learning Intern role at Mercity. The resume shown was one of the top candidates we received.

‍

Traditional ATS system

Let's first try the traditional ATS system and see how it evaluates the candidate

The system focuses only on matching exact keywords from the job description, while completely ignoring the candidate’s actual achievements, internships, projects, and certifications. In this case, the candidate clearly mentioned "deep learning with CNN," yet the ATS marked them as not meeting the "deep learning techniques" keyword, a minor wording difference leading to a major evaluation failure.

Such rigid matching is counterproductive. Strong candidates are scored low simply because they didn’t optimize for exact keywords. This kind of outdated evaluation hurts both the recruiters and the applicants

‍

The new LinkedIn AI feature for job postings does a slightly better job

‍

This system does the basic job of parsing resumes and identifying criteria that are met. It can even go a step further by recognizing skills that aren’t explicitly worded the same way, such as mapping academic internships to the ability to read AI papers. However, it doesn't go beyond that. It's essentially a smarter version of keyword matching, sufficient for rejecting clear mismatches, but far from what’s needed for true selection decisions.

This is useful for shortlisting resumes but doesn't offer any real evaluation. Recruiters still have to dive deeper into the resume to fully understand the candidate. Simply put, it’s more of a filtering tool than a true recruiting assistant.

LLM based Resume Analyser

The LLM based Resume Analyser, goes leaps and bounds above these simplistic evaluation methods.

The system first evaluates the must-have skills (technical skills and core responsibilities), the good-to-have skills, and the screening criteria, providing a detailed analysis of which ones are met and which ones are not. This gives a quantitative view of how well the candidate aligns with the hard requirements of the job.

‍

Next, the qualitative assessment begins. It evaluates the difficulty of the candidate's projects, their leadership and ownership, and assesses overall fit based on these factors. Each of these three qualitative aspects is rated as high, medium, or low. Following this, a short summary of the candidate's profile is provided, highlighting their strengths and weaknesses.

Finally, a recommendation is made based on both the quantitative and qualitative evaluations, along with a clear explanation for the decision.

Candidates benefit because the system is fair, it understands the context behind their experience. With this level of detailed analysis, hiring teams don’t need to dig deep into every resume. The AI provides clear insights that make shortlisting quicker, and more accurate, saving time while ensuring no strong candidate is overlooked.

Why choose an LLM-Powered Resume Screening?

Instead of vague scores, the system provides clear Yes/No recommendations backed by logical reasoning. It saves time on manual screening and quickly generates a shortlist of the most promising candidates. Strong candidates who may have been overlooked due to poor resume writing now surface automatically, improving the quality of the talent pool.

The system integrates smoothly with your existing ATS, adding a deeper, more human-like evaluation layer that assesses real-world skills and role fit. Resumes can be processed directly from the ATS in batches or integrated via simple APIs with minimal technical effort.

Before even opening a resume, you’ll have a concise, ready summary of each candidate’s strengths and potential. This enables faster shortlisting, fewer hiring mistakes, and ensures that better candidates make it to the interview stage, all without disrupting your current systems.

Try Out Our LLM-Based Resume Analyzer

We built a quick prototype using the same approach explained above, and it’s live for you to try out.
While the article shows how to build one using GPT models, the same idea works just as well with any open-sourced LLM like LLaMa, Mistral, etc.

This demo video walks you through how to use the prototype, and you’ll see for yourself how it goes beyond keyword matching to evaluate real candidate-role fit.

Check it out and see it in action.

Want to Simplify Hiring at Your Organisation?

If you're looking to streamline your hiring process, we can help you harness the power of AI to automate tasks tailored to your specific needs. We've already helped numerous organizations save time, reduce effort, and cut costs by automating their entire hiring workflow.