AI Resume Screening System – Complete Project Guide with Code

1. Introduction

HR teams receive hundreds (sometimes thousands) of resumes for a single job opening. Manually reading each resume is slow, expensive, and often biased or inconsistent.

In 2025, many companies are moving towards AI-powered resume screening systems that can:

• Read resumes automatically

• Match them with job descriptions

• Filter out unqualified candidates

• Rank the most relevant profiles

For students and beginners, this is an excellent machine learning project because it combines:

• Natural Language Processing (NLP)

• Classification / ranking

• Real-world HR use case

• Web application development

In this complete project guide, we’ll build an AI Resume Screening System step-by-step, including:

• Project architecture

• Dataset ideas

• Model building using Python & scikit-learn

• API using FastAPI

• How to use it in a website or HR portal

• How to present it in your final-year project or portfolio

---

2. What Is an AI Resume Screening System?

An AI Resume Screening System is a tool that automatically reads candidate resumes and predicts:

• How relevant they are for a specific job

• Whether they should be shortlisted or rejected

• Sometimes, the best-matching job role for a given resume

Instead of manually scanning every resume, HR can upload a batch of resumes and get:

• Shortlisted candidates

• Scores or rankings

• Basic analytics

Your project can start simple (shortlist vs not shortlist) and later grow into a smart recommendation system.

---

3. Real-World Use Cases

You can mention these in your report/presentation:

• IT Companies – Filter developers based on skills like Python, Django, React, Docker, etc.

• Recruitment Agencies – Match resumes to multiple job postings.

• EdTech / Training Institutes – Suggest job roles to students based on their resumes.

• Internal HR Portal – Auto-tag resumes into categories (Data Science, Web Dev, DevOps, etc.).

These use cases make your project very industry-relevant.

---

4. Project Overview & Architecture

Let’s design a simple but realistic architecture:

1. Input

   • PDF/DOCX resume uploaded by the user OR

   • Raw text of resume pasted into a text area

   • Job description (JD) entered or selected

2. Preprocessing Layer

   • Extract text from resume file

   • Clean text (remove stopwords, symbols, etc.)

3. Feature Engineering / NLP

   • Convert text to numeric features using TF–IDF or word embeddings

4. Model Layer

   • Classification model (Shortlist vs Reject)

   • OR Matching model (Relevance score 0–100)

5. API Layer (FastAPI)

   • /predict endpoint to receive resume & JD, return score and decision

6. Frontend (Optional)

   • Simple web form to upload resume and enter job description

7. Database (Optional)

   • Store predictions, candidate data, logs

---

5. Tech Stack for This Project

You can mention the following in your project report:

• Programming Language: Python

• Libraries (ML & NLP):

  • pandas, numpy

  • scikit-learn

  • nltk or spaCy (optional but good)

• Model Types:

  • Logistic Regression / SVM / Random Forest

• Backend / API: FastAPI

• Frontend (optional): HTML/CSS/JS or React

• Storage (optional): SQLite / PostgreSQL

---

6. Dataset & Data Preparation

You have a few options for data:

1. Create your own dataset

   • Collect sample resumes (fake or anonymised).

   • For each resume + job description, label:

     • 1 = Good fit (shortlist)

     • 0 = Not a good fit

2. Use job posts & profiles from public platforms (with care)

   • Convert them into resume-like text

   • Use job categories or roles as labels

3. Simple demo dataset (for learning)

   • A CSV file with:

     • resume_text

     • job_role or shortlisted (0/1)

Example: Dataset Structure

We’ll use a structure like this in the code below.

---

7. Building the Machine Learning Model (With Code)

Below is a simple, clean, and explainable ML pipeline that you can use in your project.

7.1. Install Dependencies

pip install pandas scikit-learn fastapi uvicorn

7.2. Basic Model Training Script (train_model.py)

import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
from sklearn.metrics import classification_report
import joblib

# 1. Load dataset
df = pd.read_csv("resume_dataset.csv")  # columns: resume_text, shortlisted

# 2. Basic cleaning (you can customize)
df.dropna(subset=["resume_text", "shortlisted"], inplace=True)

X = df["resume_text"]
y = df["shortlisted"]

# 3. Train-test split
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# 4. Build pipeline: TF-IDF + Logistic Regression
model = Pipeline([
    ("tfidf", TfidfVectorizer(
        max_features=5000,
        ngram_range=(1,2),
        stop_words="english"
    )),
    ("clf", LogisticRegression(max_iter=200))
])

# 5. Train model
model.fit(X_train, y_train)

# 6. Evaluate
y_pred = model.predict(X_test)
print(classification_report(y_test, y_pred))

# 7. Save model
joblib.dump(model, "resume_screening_model.joblib")
print("Model saved as resume_screening_model.joblib")

What this code does:

• Reads a CSV file of resumes

• Converts text into TF–IDF features

• Trains a logistic regression model

• Evaluates performance

• Saves the trained pipeline to disk

You can include the classification report output in your project report.

---

8. Exposing the Model via API (FastAPI Example)

Now we’ll create a small API that HR or your frontend can call.

8.1. Create app.py

from fastapi import FastAPI
from pydantic import BaseModel
import joblib

# Load trained model
model = joblib.load("resume_screening_model.joblib")

app = FastAPI(title="AI Resume Screening API")

class ResumeInput(BaseModel):
    resume_text: str

class PredictionOutput(BaseModel):
    shortlisted: bool
    probability: float

@app.get("/")
def root():
    return {"message": "AI Resume Screening System is running"}

@app.post("/predict", response_model=PredictionOutput)
def predict_resume(input_data: ResumeInput):
    # Model expects a list of texts
    proba = model.predict_proba([input_data.resume_text])[0][1]
    shortlisted = proba >= 0.5  # threshold, can be tuned

    return PredictionOutput(
        shortlisted=bool(shortlisted),
        probability=float(round(proba, 4))
    )

8.2. Run the API

uvicorn app:app --reload

Now you can send a POST request with resume text:

{
  "resume_text": "I am a Python developer with experience in Django, REST APIs, and MySQL..."
}

And the API will respond with:

{
  "shortlisted": true,
  "probability": 0.87
}

This simple endpoint is enough to integrate with a web form or HR dashboard.

---

9. Simple Frontend Flow (Conceptual)

You don’t need a very complex frontend for your project demo. You can build:

• A small HTML form with:

  • Text area for resume text

  • (Optional) upload field for resume file

• JavaScript to:

  • Send fetch request to /predict

  • Display “Shortlisted / Not Shortlisted” with probability score

You can describe this in your report as:

“User uploads a resume or pastes text → frontend sends to FastAPI → FastAPI runs ML model → response is shown with a recommendation.”

---

10. Evaluation Metrics & Testing

To make your project professional, discuss how you measure performance:

Common Metrics:

• Accuracy – Overall correct predictions

• Precision – Of shortlisted candidates, how many are truly good

• Recall – Of all good candidates, how many did we shortlist

• F1-Score – Balance of precision and recall

For HR, recall is very important: missing a good candidate can be costly.

You can include a sample classification report in your documentation.

---

11. Challenges, Limitations & Ethics

Every good project report should include limitations:

1. Bias in Data

   • If training data is biased (more resumes from a certain college, gender, region), the model may reflect that.

2. Keyword Stuffing

   • Candidates might artificially add many keywords to trick the model.

3. Context Understanding

   • Simple models like TF–IDF + Logistic Regression don’t fully understand context like LLMs do.

4. Ethical Concerns

   • AI should be used as an assistant, not the only decision-maker.

   • Human review must remain part of the hiring process.

You can also add a note:

“This project is meant for educational purposes and should be deployed with proper fairness and bias-checking mechanisms in real-world environments.”

---

12. How to Turn This Into a Final-Year Project

To make your AI Resume Screening System stand out:

• Add multiple job roles (Data Scientist, Web Developer, DevOps, QA, etc.).

• Predict top 3 matching roles instead of only shortlist vs reject.

• Add a dashboard showing:

  • Number of resumes uploaded

  • Average match score

  • Distribution by skills

• Use LLM-based embeddings (optional advanced feature).

• Integrate a file uploader that extracts text from PDF using pdfminer / PyPDF2.

In your final presentation, walk the panel through:

1. Problem in manual screening

2. Architecture diagram

3. Dataset preparation

4. Model training

5. Live demo using your API

6. Results & challenges

---

13. Conclusion

An AI Resume Screening System is a powerful and practical project that showcases your skills in:

• Natural Language Processing

• Machine Learning model building

• Backend development with FastAPI

• Real-world HR automation

For beginners and final-year students, this project is the perfect mix of technical depth and practical impact. You’re not just building a toy example—you’re solving a real pain point that companies face every day.

You can extend this system into a full HR analytics platform, integrate it into a career portal, or even build a SaaS product in the future.

---

14. FAQs

1. Is this project suitable for beginners?

Yes. If you know basic Python, pandas, and scikit-learn, you can build a simple version of this system and improve it step by step.

2. Which algorithm is best for resume screening?

For starters, Logistic Regression or Linear SVM with TF–IDF features works very well. Later, you can experiment with BERT, Sentence Transformers, or other advanced models.

3. Do I need a huge dataset?

Not necessarily. For a college project, even a few hundred labelled resumes can be enough to demonstrate the concept, as long as you explain limitations.

4. Can I use this project as my final-year major project?

Definitely. It’s an excellent final-year project because it combines ML, NLP, API development, and real-world use.

5. How can I improve the accuracy?

• Use better preprocessing

• Increase training data

• Try different algorithms

• Use embeddings (e.g., Sentence-BERT)

• Fine-tune decision thresholds