1

DESIGN & DEVELOPMENT OF AI POWERED RESUME

RANKER USING NATURAL LANGUAGE PROCESSING
A
MINOR PROJECT-I REPORT
Submitted in partial fulfillment of the
requirements for the degree of
BACHELOR OF TECHNOLOGY
in
CSE-ARTIFICIAL INTELLIGENCE & DATA SCIENCE
By
GROUP NO. 04

Devendra Singh 0187AS231017

Rahul Kushwaha 0187AS231042

Sameer Gupta 0187AS231053

Under the guidance of

Ms. Ruchi Jain
(Assistant Professor)

Department of CSE-Artificial Intelligence & Data Science

Sagar Institute of Science & Technology (SISTec) Bhopal (M.P.)

Approved by AICTE, New Delhi & Govt. of M.P.

Affiliated to Rajiv Gandhi Proudyogiki Vishwavidyalaya, Bhopal (M.P.)
December - 2025

III
 2

Sagar Institute of Science & Technology (SISTec), Bhopal

Department of CSE-Artificial Intelligence & Data Science

CERTIFICATE

I hereby certify that the work which is being presented in the [Link]. Minor Project-I Report
entitled Design and Development of AI Powered Resume Ranker using NLP, in partial
fulfillment of the requirements for the award of the degree of Bachelor of Technology, submitted
to the Department of CSE with Artificial Intelligence & Data Science, Sagar Institute of Science
& Technology (SISTec), Bhopal (M.P.) is an authentic record of my own work carried out
during the period from July-2025 to Dec-2025 under the supervision of Ms. Ruchi Jain
(Assistant Professor).

The content presented in this project has not been submitted by me for the award of any other
degree elsewhere.
Devendra Singh 0187AS231017

Rahul Kushwaha 0187AS231042

Sameer Gupta 0187AS231053

This is to certify that the above statement made by the candidate is correct to the best of my
knowledge.

Date:

Ms. Ruchi Jain Dr. Vasima Khan Dr. Manish Billore

Project Guide HOD, CSE-AI&DS Principal, SISTec
SISTec/BTech/AD/2025/5/Minor Project_I/04 3

ACKNOWLEDGEMENT

We would like to express our sincere thanks to Dr. Manish Billore, Principal, SISTec and Dr.
Swati Saxena, Vice Principal, SISTec Gandhi Nagar, Bhopal for giving us an opportunity to
undertake this project.

We also take this opportunity to express a deep sense of gratitude to Dr. Vasima Khan, HOD,
Department of CSE-Artificial Intelligence & Data Science for her kindhearted support.

We extend our sincere and heartfelt thanks to our Guide, Ms. Ruchi Jain for providing us with
the right guidance and advice at the crucial junctures and for showing us the right way.

I am thankful to the Project Coordinator, Ms. Ruchi Jain who devoted her precious time in
giving us the information about the various aspect and gave support and guidance at every point
of time. I am thankful to their kind and supportive nature. His inspiring nature has always made
my work easy.

I would like to thank all those people who helped me directly or indirectly to complete my
project whenever I found myself in any issue.

III
 4
SISTec/BTech/AD/2025/5/Minor Project_I/04

TABLE OF CONTENTS

TITLE PAGE NO.

Abstract i

List of Abbreviations ii

List of Figures iii

List of Tables iv

Chapter 1 Introduction 1

1.1 About Project 1

1.2 Project Objectives 2

Chapter 2 Software & Hardware Requirements 3

Chapter 3 Problem Description 5

Chapter 4 Literature Survey 7

Chapter 5 Software Requirements Specification 9

5.1 Functional Requirements 9

5.2 Non-Functional Requirements 10

Chapter 6 Software Design 11

6.1 Use Case Diagram 11

6.2 Project Flow Chart 13

Chapter 7 Machine Learning Module 16

7.1 Data Preprocessing Engine 16

7.2 Feature Engineering Layer 16

7.3 Model Training Pipeline 17

7.4 Prediction and Ranking Engine 18

7.5 Output Generation 18

Chapter 8 Front End Connectivity 19

Chapter 9 Coding 21

Chapter 10 Result and Output Screens 38

Chapter 11 Conclusion and Future Work 42

References 43
Appendix-1 Glossary of Terms 44
Project 49
Summary

IV IV
SISTec/BTech/AD/2025/5/Minor Project_I/04 5i

ABSTRACT

This project presents the design and development of an AI-powered resume ranking system that
automates candidate shortlisting using Natural Language Processing (NLP) and Machine Learning
(ML) techniques. Prior research demonstrates that ML-based resume screening improves recruitment
efficiency and reduces manual bias [1]. The proposed system follows a structured pipeline consisting
of resume preprocessing, text normalization, resume parsing, feature extraction, and candidate–job
relevance scoring, as adopted in existing resume ranking methodologies [2]. Resumes are converted
into structured textual representations to extract skills, experience, education, and domain-specific
keywords, while a hybrid ranking approach combining TF-IDF-based keyword weighting and
semantic similarity techniques is employed to evaluate candidate suitability [2]. Supervised machine
learning models are further used to enhance ranking accuracy and consistency [1]. The system is
designed with a modular and scalable architecture to efficiently process large volumes of resumes,
and experimental evaluation indicates improved precision and recall compared to traditional manual
screening methods [3]. The proposed solution provides a practical, extensible framework suitable for
integration with modern Applicant Tracking Systems (ATS), supporting efficient and data-driven
recruitment automation.
 ii
SISTec/BTech/AD/2025/5/Minor Project_I/04

LIST OF ABBREVIATIONS

ACRONYM FULL FORM

AI Artificial Intelligence
ML Machine Learning
TF-IDF Term Frequency-Inverse Document Frequency
UI User Interface
UX User Experience
ATS Applicant Tracking System
JD Job Description
API Application Programming Interface
HTTP Hypertext Transfer Protocol
JSON JavaScript Object Notation
PDF Portable Document Format
URL Uniform Resource Locator
SISTec/BTech/AD/2025/5/Minor Project_I/16 iii

LIST OF FIGURES

FIG. NO. TITLE PAGE NO.

6.1 Use Case Diagram 11
6.2 Project Flow Chart 13
7.1 Data Preprocessing Engine 16
7.2 Feature Engineering Layer 17
7.3 Model Training Pipeline 17
7.4 Prediction and Ranking Engine 18
10.1 Homepage Screenshot 38
10.2 Homepage Screenshot 38
10.3 Login Page Screenshot 39
10.4 User Dashboard Page Screenshot 39
10.5 User Search Page Screenshot 40
10.6 Resume Builder Page Screenshot 40
10.7 Recruiter Dashboard Screenshot 41
10.8 Create Job Page Screenshot 41
 iv
SISTec/BTech/AD/2025/5/Minor Project_I/16

LIST OF TABLES

TABLE NO. TITLE OF TABLE PAGE NO.

2.1 Software Requirements 3
2.2 Hardware Requirements 4
5.1 Functional Requirements 9
5.2 Non-Functional Requirements 10
SISTec/BTech/AD/2025/5/Minor Project_I/4 1

CHAPTER 1
INTRODUCTION
Effective interview preparation is widely recognized as a crucial factor for employment success;
however, traditional preparation methods often fail to deliver practical outcomes. Most candidates
depend on informal mock interviews or costly professional coaching programs, which are financially
inaccessible to a large section of students . Moreover, conventional approaches lack realistic interview
simulation and personalized feedback. They neither replicate real interview pressure nor provide
instant performance analysis. Recent studies identify interview training as a neglected area and
emphasize the urgent need for automated interview simulation platforms to ensure equal access to
quality preparation.

Recent advancements in Artificial Intelligence (AI), particularly deep learning and large language
models (LLMs), present effective solutions to these limitations. AI-driven mock interview systems can
dynamically generate interview questions and analyze candidate responses in real time [2][3]. Machine
learning models are capable of evaluating speech, facial expressions, and linguistic patterns to provide
personalized performance feedback and realistic practice scenarios [2]. The emergence of generative
AI and LLMs further enables the development of virtual interview systems with adaptive questioning
and targeted improvement guidance. In alignment with these advancements, the proposed system
applies AI techniques to simulate domain-specific interviews by generating questions based on the
user profile and providing immediate feedback on both content and delivery [2][3].

1.1 ABOUT THE PROJECT

The proposed AI-based interview preparation application integrates multiple intelligent modules to
provide realistic, adaptive, and personalized interview practice. The system includes a domain-specific
question generation module that utilizes deep learning and Natural Language Processing (NLP) to
dynamically generate interview questions based on the candidate’s selected field. A similar approach
was implemented by Qin et al. [3], where questions were generated using resume data, industry
knowledge, and adaptive difficulty adjustment. The proposed system follows this model by learning
from large textual datasets and a resume parsing engine to ensure accurate and relevant question
generation.

During each mock interview session, the system offers real-time feedback on candidate responses. It
analyzes audio and video inputs, including speech clarity, vocal tone, facial expressions, and
emotional cues, to evaluate confidence and communication effectiveness. In [4], an AI-based mock

1
SISTec/BTech/AD/2025/5/Minor Project_I/16 2

interview tool is presented that utilizes speech recognition and emotion detection algorithms to assess
response quality and provide detailed feedback. The proposed system adopts similar methods by
integrating emotion recognition and NLP-based answer evaluation to generate instant improvement
suggestions.

In addition to question generation and answer analysis, the system also includes resume analysis,
interview scheduling, and performance tracking features. The resume analyzer extracts key skills,
educational background, and work experience from uploaded resumes, which directly influence both
question generation and feedback mechanisms [3]. A scheduling module enables users to plan multiple
mock interview sessions, encouraging consistent practice. Furthermore, a comprehensive performance
dashboard visualizes progress through graphical metrics such as response time, speaking rate, tone
modulation, and answer relevance. Visual feedback mechanisms have been shown to improve user
awareness and performance optimization [4].

Several enhancement modules have been incorporated to improve user engagement and system
effectiveness. A coding practice section allows users to solve technical problems across multiple
programming languages with instant evaluation, strengthening technical and problem-solving skills
alongside interview readiness. Google Analytics integration enables monitoring of user activity,
performance trends, and engagement patterns for continuous system improvement [13]. A quiz module
allows users to test theoretical knowledge through domain-specific multiple-choice questions with
instant scoring and explanations. Additionally, a job search and recommendation module uses
Selenium-based web scraping techniques to retrieve real-time job listings from [Link] [14][15],
thereby directly connecting interview preparation with live employment opportunities.

1.2 PROJECT OBJECTIVE

The primary objectives of the proposed AI-based interview preparation system are as follows:

 Personalization: To deliver customized interview questions and feedback for each user. The
system utilizes resume data and performance history to tailor mock interview sessions and
improvement recommendations.
 Automation: To automate the generation, execution, and evaluation of interview sessions,
thereby minimizing manual intervention and reducing evaluator bias. AI models consistently
assess candidate performance and dynamically adjust question difficulty.

 Data Privacy: To ensure secure handling of user data such as resumes, interview recordings, and
performance analytics. Ethical and privacy concerns are addressed through consent-based data
usage, encryption techniques, and secure storage mechanisms.

2
SISTec/BTech/AD/2025/5/Minor Project_I/4 3

CHAPTER 2
SOFTWARE & HARDWARE REQUIREMENTS

2.1 SOFTWARE REQUIREMENTS

CATEGORY SOFTWARE PURPOSE

Backend Python 3.10+ Primary programming language

Django 5.x Web framework for backend logic

NumPy extract key information using NLP and AI

techniques, compare the extracted data
Machine Learning TF-IDF withjob descriptions,

NLP

Pillow(PIL)

HTML5, CSS3, JavaScript Core web technologies for UI and

Frontend
(ES6+) interactivity.
PyPDF
PyPDF for pdf reader and editor.

Database SQLite3 Default Django database for development

Integrated Development Environment

VS Code
Environment (IDE)
Git & GitHub Version control and code repository

OS Windows Development operating system

Table 2.1: Software Requirements Table

3
SISTec/BTech/AD/2025/5/Minor Project_I/16 4

2.2 HARDWARE REQUIREMENTS

TYPE COMPONENT MINIMUM SPECIFICATION RECOMMENDED

Dual-Core 2.4 GHz Quad-Core 3.0 GHz+

Development CPU
8 GB 16 GB+
RAM
128 GB SSD 256 GB+ NVMe SSD
Storage

ML Training GPU NVIDIA GTX 1660 (6GB NVIDIA RTX 3060+

VRAM) (8GB+ VRAM)

User (Client) Any N/A A modern web

browser
(Chrome, Firefox,
Safari)

Table 2.2: Hardware Requirements Table

4
SISTec/BTech/AD/2025/5/Minor Project_I/4 5

CHAPTER 3
PROBLEM DESCRIPTION

3.1 PROBLEM STATEMENT

Resume screening is one of the most critical stages in the recruitment process. Every year,
organizations receive hundreds or even thousands of resumes for a single job opening.
However, manual resume screening is slow, inconsistent, and highly dependent on human
judgment. Recruiters often face difficulties in identifying the most relevant candidates within a
limited time, which results in delayed hiring and poor selection decisions.

Most traditional screening methods depend on keyword-based filtering or manual shortlisting,

which often fails to capture the actual relevance of a candidate’s skills, experience, and
qualifications. Important candidates may get rejected due to formatting issues, unconventional
resume structures, or missing keywords, even though they possess the required skills.
Additionally, manual screening is prone to human bias related to educational background,
location, gender, or personal preferences.

Another major limitation is the lack of automation and intelligent feedback. Existing systems
rarely provide relevance scoring, skill gap analysis, or candidate ranking based on job
descriptions. As a result, recruiters struggle to identify the best-fit candidates accurately and
efficiently.

Therefore, there is a strong need for an AI-powered automated resume screening and
ranking system that can extract information from resumes, match it with job requirements,
assign relevance scores, and rank candidates intelligently in a fast, accurate, and unbiased
manner.

3.2 CHALLENGES IN THE CURRENT SYSTEM

The traditional resume screening process suffers from multiple challenges that reduce hiring --
efficiency and accuracy.

1. Manual and Time-Consuming Screening

5
SISTec/BTech/AD/2025/5/Minor Project_I/16 6

Recruiters are required to manually review large volumes of resumes, which consumes excessive
time and effort.
Example: A company receiving 1,000 resumes for a software engineer role may take several days
to manually shortlist candidates.

2. Keyword-Based Filtering Errors

Most existing systems rely only on keyword matching and fail to understand the semantic meaning
skills.
Example: A candidate with “Machine Learning Engineer” experience may be rejected if the job
requires “AI Developer” due to keyword mismatch.

3. Lack of Intelligent Candidate Ranking

Traditional systems do not assign relevance scores or provide ranked candidate lists based on job
suitability.
Example: Recruiters must manually compare multiple shortlisted resumes to decide priority.

4. Absence of Skill Gap Analysis

Current methods do not highlight missing or weak skills in a candidate’s profile.

Example: A candidate applying for a backend role may lack database skills, but the system does not
flag this gap.

5. High Human Bias and Inconsistency

Human evaluation varies from recruiter to recruiter and is influenced by personal judgment.
Example: wo recruiters may shortlist completely different candidates from the same resume set.

6. Poor Resume Management

Most platforms do not provide proper resume storage, tracking, or version management.
Example: Recruiters may mistakenly evaluate outdated resumes due to poor record handling.

6
SISTec/BTech/AD/2025/5/Minor Project_I/4 7

CHAPTER 4
LITERATURE SURVEY

AI-Based Resume Screening Systems

Several researchers have explored the use of Artificial Intelligence to automate resume screening
and improve recruitment efficiency. One study proposed an AI-based resume screening system that
uses Natural Language Processing (NLP) to extract candidate skills, education, and experience from
resumes. The extracted features are compared with job descriptions to compute a relevance score.
The results showed that automated screening significantly reduced manual effort and improved
shortlist accuracy .

Another research introduced a machine learning-based candidate ranking system where multiple
classification models were trained on historical hiring data. The system automatically categorized
resumes into suitable and unsuitable groups. Their findings demonstrated that supervised learning
models such as Random Forest and Support Vector Machines achieved higher accuracy than
traditional keyword-based filtering.

A deep-learning-based resume parser was proposed to handle unstructured resume formats more
effectively. The system used word embeddings and sequence learning models to extract named
entities such as skills, organizations, and job roles. This approach improved extraction accuracy
even for poorly formatted resumes.

NLP Techniques for Resume Parsing and Job Matching

Natural Language Processing plays a critical role in resume screening systems. One study presented
an NLP-based resume analysis framework that applied tokenization, lemmatization, and named
entity recognition for structured information extraction. The system successfully converted
unstructured resume text into machine-readable structured data .

Another work proposed a semantic job matching approach using TF-IDF and cosine similarity to
measure the relevance between resumes and job descriptions. Their method provided better
matching accuracy compared to basic keyword matching techniques .

7
SISTec/BTech/AD/2025/5/Minor Project_I/16 8

Transformer-based models such as BERT have also been applied to resume-job matching. These
models capture semantic relationships between skills and job requirements, leading to more accurate
candidate-job alignment even when exact keywords are absent .

Machine Learning for Candidate Ranking and Shortlisting

Several studies have focused on ranking candidates based on suitability scores. One research
developed a weighted scoring model where experience, skill match, project relevance, and education
were assigned specific weights. The final ranking was generated automatically based on the combined
score, improving recruiter decision-making speed.

Another study applied regression-based machine learning models to predict hiring probability from
resume features. The model produced a numerical suitability score that helped recruiters compare
multiple candidates objectively.

Clustering-based techniques were also explored to group candidates based on similar skill profiles.
This approach helped recruiters quickly identify specialized candidate pools for different job roles.

Limitations of Existing Systems

Although existing AI-based resume screening systems show promising results, several limitations still
exist. Many systems rely heavily on keyword-based matching and fail to capture the true semantic
meaning of skills. Some platforms lack domain adaptability, making them unsuitable for multi-role
recruitment scenarios. Additionally, most systems do not provide transparency in scoring logic, which
raises trust and fairness concerns. Data bias in training datasets can also lead to unfair candidate
ranking.

Summary and Research Gap

The literature survey indicates that Artificial Intelligence, Machine Learning, and Natural Language
Processing have significantly improved the automation of resume screening and candidate ranking.
However, most existing systems suffer from limitations such as restricted domain adaptability, lack of
explainable scoring mechanisms, and poor handling of unstructured resume formats.

8
SISTec/BTech/AD/2025/5/Minor Project_I/4 9

CHAPTER 5
SOFTWARE REQUIREMENTS SPECIFICATION

5.1 FUNCTIONAL REQUIREMENTS

ID REQUIREMENTS DESCRIPTION

The system shall allow a new user to create a

FR-01 User Registration
secure account with a unique username and a
hashed password.

The system shall allow an existing user to log

FR-02 User Login
in and access their dashboard.

Users should be able to upload resumes in

FR-03 Resume Upload
PDF/DOCX format for parsing and
evaluation.

System must allow recruiters/job seekers to

FR-04 Job Description Input
input or upload job descriptions for
matching.

System shall extract skills, experience,

FR-05 Resume Parsing
education, job titles, and contact
information using NLP.

System must rank candidates based ok skill

FR-06 Ranking and Shortlisting
match, experience relevance, and
completeness.

System must provide candidates with missing-

FR-07 Improvement Suggestions
keyword feedback and skill-gap
suggestions.

System must display ranked candidate lists,

FR-08 Recruiter Dashboard
filters, and detailed match insights.

System should include a chatbot for FAQs,

FR-09 AI Chatbot
resume tips, and system guidance.

Table 5.1: Table Name (Functional Requirements Table)

9
SISTec/BTech/AD/2025/5/Minor Project_I/16 10

ID CATEGORY REQUIREMENTS

The website pages shall load in under 3 seconds.

NFR-01 Performance
The AI prediction shall return a result in
under 10 seconds.

All user passwords must be securely hashed. The

NFR-02 Security application must be protected against common web
vulnerabilities (e.g., CSRF).

The website must be fully responsive and usable

NFR-03 Usability
on all modern devices (desktops, tablets, and
mobiles).

The code shall be well-commented and adhere to

NFR-04 Maintainability PEP 8 standards (Python) and modern web
standards (HTML/CSS).

The system shall have a high availability and

NFR-05 Reliability
correctly handle invalid user inputs or file types
without crashing.

Table 5.2: Table Name (Non-Functional Requirements Table)

10
SISTec/BTech/AD/2025/5/Minor Project_I/4 11

CHAPTER 6
SOFTWARE DESIGN

6.1 Use Case Diagram

This chapter presents the core design structure of the AI-Powered Resume Screening and Ranking
System using structured diagrams and detailed descriptions. It includes the Use Case Diagram and
Data Flow Diagram (DFD) to illustrate user interaction, system behavior, and information flow.

Figure 6.1 : Use Case Diagram

The Use Case Diagram illustrates the different interactions between the Recruiter (User) and the

Admin with the AI-based Resume Screening System. It highlights the main system functionalities

such as resume upload, job description analysis, candidate scoring, ranking, and data management.

Actors

User (Recruiter/HR): Person responsible for uploading job descriptions, screening resumes, and viewing
ranked candidates.

11
SISTec/BTech/AD/2025/5/Minor Project_I/16 12

Admin: System administrator who manages users, data, and overall system configuration.

Use Cases for User (Recruiter/HR)

 Signup: Create a new recruiter account using email and password.

 Login: Secure access to the system using valid credentials.
 View Profile: Access and manage personal recruiter details.
 Dashboard: View uploaded jobs, resumes, and screening results.
 Upload Job Description: Submit job requirements for screening.
 Upload Resumes: Upload multiple candidate resumes in PDF format.
 View Extracted Resume Data: See automatically extracted skills, education, and experience.
 AI Resume Matching: Automatically match resumes with job requirements.
 View Candidate Score: View AI-generated relevance score for each candidate.
 View Ranked Candidate List: Access ranked results based on suitability.
 Shortlist Candidates: Select top-ranked candidates for further processing.
 Download Resume: Download shortlisted candidate resumes.
 Delete Resume: Remove unwanted resume records.
 Edit Profile: Update recruiter account details.
 Logout: Securely exit the system.

Use Cases for Admin

 Admin Login: Secure access to the administration panel.

 Admin Dashboard: Monitor overall system activities and usage.
 Manage Users: Add, update, block, or remove recruiters.
 Manage Job Data: Monitor uploaded job descriptions.
 Manage Resume Data: Control stored resumes and extracted information.
 System Monitoring: Track system performance and AI evaluation activities.

Include and Extend Relationships

Include Relationships:

 Login includes access to the Dashboard.

 Upload Resumes includes Resume Parsing and Data Extraction.
 AI Resume Matching includes Candidate Scoring and Ranking.

12
SISTec/BTech/AD/2025/5/Minor Project_I/4 13

Extend Relationships:

 Shortlist Candidate extends View Ranked Candidate List.

 Download Resume extends Shortlisted Candidate.
 Delete Resume extends Resume Management.

6.2 Project Flow Chart

Figure 6.2 : Project Flow Diagram

The DFD Level 0 represents the high-level architecture and data flow of the AI-Powered Resume
Screening and Ranking System. It shows how recruiter inputs move through various system components
to generate intelligent resume analysis, relevance scoring, and candidate ranking using AI and Machine
Learning models.

Entities and Components

Frontend

Acts as the user interaction layer of the system.

Functions:

 Resume Upload
13
SISTec/BTech/AD/2025/5/Minor Project_I/16 14

 Job Description Upload

 View Extracted Resume Data
 View Candidate Scores and Rankings
 Shortlisting Interface
 Resume Download
 Recruiter Dashboard

Data Flow:

 Sends: Resume Files & Job Description → Backend Server

 Receives: Candidate Scores, Rankings & Reports ← Backend Server

Backend Server

The core processing unit of the system. It performs:

 User Authentication
 Resume Parsing Requests
 Job Description Processing
 AI-Based Matching & Scoring
 Ranking Computation
 Resume Management
 Report Generation

Data Flow:

 Receives requests from Frontend

 Sends processed results back to Frontend

Communicates with:

 Database
 Cache
 AI/ML Model

Cache (e.g., Redis)

Stores frequently accessed temporary data for faster system response.

Stored Data:

 Recently uploaded resumes

 Extracted resume features
 Recently processed job descriptions
 Latest candidate ranking results

Purpose:

 Reduces repeated ML computation

14
SISTec/BTech/AD/2025/5/Minor Project_I/4 15

 Improves system response speed

Data Flow:

Backend ↔ Cache:

 Store parsed resume data

 Retrieve cached results when required

Database

Stores permanent and structured system data.

Stored Information:

 Recruiter user profiles

 Uploaded resumes
 Job descriptions
 Extracted resume features
 Candidate scores and ranking history
 Shortlisted candidate records

Data Flow:

Backend ↔ Database:

 Store and retrieve resume & job data

 Store screening results and report

AI / Machine Learning Model

Core intelligence of the system responsible for automated screening.

Functions:

 Resume Feature Extraction using NLP

 Semantic Matching between Resume & Job Description
 Relevance Score Generation
 Candidate Ranking

Data Flow:

 Backend → ML Model: Sends Resume & Job Description Data

 ML Model → Backend: Sends Relevance Scores & Rankings.

15
SISTec/BTech/AD/2025/5/Minor Project_I/16 16

CHAPTER 7
MACHINE LEARNING MODULE

This module is responsible for evaluating resumes and ranking them based on job relevance. It operates
through the following internal components:

Data Preprocessing Engine :

Extracts text from PDF/DOC using OCR/Text Parser.

Cleans and normalizes text (lowercasing, stopword removal, lemmatization).

Converts resume into structured fields: Skills, Experience, Projects, Education.

FIGURE 7.1 : Data Preprocessing

Feature Engineering Layer :

TF-IDF / Word Embedding vectors generated for textual similarity.

Skill-matching score computed against job description keywords.

Weight assignment for Experience, Skills, Certifications, Projects.

16
SISTec/BTech/AD/2025/5/Minor Project_I/4 17

FIGURE 7.2 : Feature Engineering Layer

Model Training Pipeline :

Machine Learning models like Logistic Regression / SVM / Random Forest trained to classify
resume relevance.

Scoring formula used :

Final Score = 0.4*Skill Match + 0.3*Experience Score + 0.2*Project Relevance +

0.1*Education Fit

Hyperparameter tuning performed for best F1-score and accuracy.

FIGURE 7.3 : MODEL TRAINING PIPELINE

17
SISTec/BTech/AD/2025/5/Minor Project_I/16 18

Prediction & Ranking Engine :

Each resume processed → relevance score generated.

Resumes sorted descending to produce ATS-style ranking list.

Top resumes highlighted with strength/weakness breakdown.

FIGURE 7.4 : PREDICTION AND RANKING ENGINE

Output Generation :

Scorecard returned to user + recruiter.

HTML/PDF report generated with scoring justificatio

18
SISTec/BTech/AD/2025/5/Minor Project_I/4 19

CHAPTER 8
FRONTEND CONNECTIVITY
This chapter outlines the frontend architecture, components, and connectivity for the AI ATS platform,
which facilitates interaction between users and the backend.

8.1 Frontend Technology Stack

The frontend is built using basic web technologies with Jinja templates for dynamic content rendering:

 HTML5: Structure and layout of web pages.

 CSS3: Styling and responsive design.
 Jinja2: Template engine for rendering dynamic content from Flask/Django backend.
 JavaScript (Optional): Basic client-side interactivity (form validation, DOM
manipulation).

8.2 Frontend Features

User Registration & Login

 Users can register with email or phone.

 Secure login mechanism with password validation.
 Sessions handled using server-side session management or JWT (if implemented in
backend).

Dashboard

 View submitted resumes and application status.

 Manage profile information.

Resume Upload

 Users can upload resumes in supported formats (PDF, DOCX).

 Upload form integrated with backend for storage and processing.

Job Matching & Recommendations

 Users can view job matches based on resume parsing results.

 Displayed dynamically via Jinja templates.

19
SISTec/BTech/AD/2025/5/Minor Project_I/16 20

Contact & Support

 Feedback form for queries, suggestions, or bug reports.

Error Handling & Alerts

 UI-level notifications for invalid inputs or submission errors.

 Server-side validation ensures data integrity.

8.3 Backend Integration

 Template Rendering: Frontend pages rendered dynamically with Jinja using

backend data.
 Form Submission: Resume uploads and user data sent to backend endpoints for
processing.
 Response Display: Feedback, job recommendations, and analytics results
displayed on HTML pages via Jinja templates.

Authentication & Sessions: Server-side session management for secure user login.

8.4 Testing & Debugging

Frontend Testing: Manual testing of forms, file uploads, and page rendering.

Debugging Tools:

 Browser DevTools for inspecting HTML, CSS, console errors, and network
requests.
 Backend logs used to trace issues in form submission and response handling.

20
SISTec/BTech/AD/2025/5/Minor Project_I/16 21

CHAPTER 9
CODING
1. Folder Structure :

21
SISTec/BTech/AD/2025/5/Minor Project_I/4 22

ATS_Project/core/[Link] :

import re

import docx

import PyPDF2

from [Link] import stopwords

from sklearn.feature_extraction.text import TfidfVectorizer

from [Link] import cosine_similarity

from io import BytesIO

def clean_text(text):

text = [Link]()

text = [Link](r'[^a-z0-9\s]', '', text)

stop_words = set([Link]('english'))

words = [Link]()

filtered_words = [word for word in words if word not in stop_words]

return ' '.join(filtered_words)

def read_resume_file(file):

file_extension = [Link]('.')[-1].lower()

text = ""

if file_extension == 'pdf':

try:

reader = [Link](BytesIO([Link]()))
22
SISTec/BTech/AD/2025/5/Minor Project_I/16 23

for page in [Link]:

text += page.extract_text() or ""

except Exception as e:

print(f"Error reading PDF: {e}")

return None

elif file_extension == 'docx':

try:

doc = [Link](BytesIO([Link]()))

for para in [Link]:

text += [Link]

except Exception as e:

print(f"Error reading DOCX: {e}")

return None

else:

print(f"Unsupported file format: {file_extension}")

return None

return text

def get_resume_ranking(resume_file, job_description):

resume_text = read_resume_file(resume_file)

if not resume_text or not job_description:

return 0.0

23
SISTec/BTech/AD/2025/5/Minor Project_I/4 24

cleaned_resume = clean_text(resume_text)

cleaned_jd = clean_text(job_description)

documents = [cleaned_resume, cleaned_jd]

tfidf_vectorizer = TfidfVectorizer()

tfidf_matrix = tfidf_vectorizer.fit_transform(documents)

cosine_sim = cosine_similarity(tfidf_matrix[0:1], tfidf_matrix[1:2])

ranking_score = cosine_sim[0][0] * 100

return ranking_score

24
SISTec/BTech/AD/2025/5/Minor Project_I/16 25

ATS_Project/core/[Link] :

from [Link] import render, redirect, get_object_or_404

from .forms import CandidateSignUpForm

from [Link] import JsonResponse

from [Link] import authenticate,login as auth_login

from [Link] import login_required

from .forms import CandidateSignUpForm, JobPostingForm, ApplicationForm , LoginForm

from .models import Job, Application, JobField

from [Link] import messages

from .api import fetch_adzuna_jobs

from [Link] import Count

from .utils import get_resume_ranking

import fitz

import requests, os

from [Link] import Count, Q

import [Link] as genai

from [Link] import HTTPError

from google import genai

from [Link] import APIError

GEMINI_API_KEY = "AIzaSyCvr1wleqVw-rp3o9Kc0jfUHNEZNNgC0fA"

def candidate_signup(request):
25
SISTec/BTech/AD/2025/5/Minor Project_I/4 26

if [Link] == 'POST':

form = CandidateSignUpForm([Link])

if form.is_valid():

user = [Link](commit=False)

user.is_candidate = True

[Link]()

return redirect('login')

else:

form = CandidateSignUpForm()

return render(request, 'core/[Link]', {'form': form})

def chatbot_response(request):

if [Link] == 'POST' and [Link]('x-requested-with') ==

'XMLHttpRequest':

user_message = [Link]('message')

prompt = f"""You are an AI career assistant. Your goal is to provide helpful and concise advice
to job seekers.

A candidate has a question for you: "{user_message}".

Please provide a professional and direct answer.

"""

try:

client = [Link](api_key=GEMINI_API_KEY)

model_name = 'gemini-2.5-flash'

26
SISTec/BTech/AD/2025/5/Minor Project_I/16 27

response = [Link].generate_content(

model=model_name,

contents=prompt,

# model = [Link]('gemini-2.5-flash')

# response = model.generate_content(prompt)

# ai_response = [Link]

ai_response = [Link]('**', '')

return JsonResponse({'response': ai_response})

except HTTPError as e:

print(f"Gemini API call failed (HTTPError): {e}")

return JsonResponse({'error': 'Sorry, the AI service is currently unavailable

(API Key Issue).'}, status=500)

except Exception as e:

print(f"Gemini API call failed (General Error): {e}")

return JsonResponse({'error': 'Sorry, I am unable to respond at the moment due to a

connection error.'}, status=500)

return JsonResponse({'error': 'Invalid request'}, status=400)

@login_required

def dashboard(request):

if [Link].is_candidate:

return redirect('candidate_dashboard')

27
SISTec/BTech/AD/2025/5/Minor Project_I/4 28

elif [Link].is_recruiter:

return redirect('recruiter_dashboard')

else:

return redirect('home')

@login_required

def candidate_dashboard(request):

if not [Link].is_candidate:

return redirect('dashboard')

query = [Link]('query', '')

location = [Link]('location', '')

internal_jobs = [Link](is_internal=True)

external_jobs = []

if query:

try:

external_jobs_data = fetch_adzuna_jobs(query, location)

for job_data in external_jobs_data:

external_jobs.append({

'title': job_data['title'],

28
SISTec/BTech/AD/2025/5/Minor Project_I/16 29

'description': job_data['description'],

'external_url': job_data['redirect_url']

})

except [Link] as e:

[Link](request, f"API call failed. Please check your internet

connection or API credentials.")

print(f"API call failed with error: {e}")

my_applications = [Link](candidate=[Link])

context = {

'internal_jobs': internal_jobs,

'external_jobs': external_jobs,

'my_applications': my_applications,

'query': query,

'location': location,

return render(request, 'core/candidate_dashboard.html', context)

def generate_job_description(job_title):

client = [Link](api_key=GEMINI_API_KEY)

model_name = 'gemini-2.5-flash'

29
SISTec/BTech/AD/2025/5/Minor Project_I/4 30

prompt = f"Write a detailed and professional job description for the role of a {job_title}. The
description should include responsibilities, qualifications, and company information. The length
should be around 250-300 words. Return only the job description content."

try:

response = [Link].generate_content(

model=model_name,

contents=prompt,

return [Link]

except Exception as e:

print(f"Gemini API call failed (General Error): {e}")

return JsonResponse({'error': 'Sorry, I am unable to respond at the moment due to a

connection error.'}, status=500)

except Exception as e:

print(f"Gemini API call failed (General Error): {e}")

return "Could not generate job description. Error: Connection Issue."

@login_required

def recruiter_dashboard(request):

30
SISTec/BTech/AD/2025/5/Minor Project_I/16 31

if not [Link].is_recruiter:

return redirect('dashboard')

recruiter_jobs = [Link](recruiter=[Link])

total_applications = [Link](job__in=recruiter_jobs).count()

shortlisted = [Link](job__in=recruiter_jobs,
status='shortlisted').count()

rejected = [Link](job__in=recruiter_jobs, status='rejected').count()

context = {

'jobs': recruiter_jobs,

'total_applications': total_applications,

'shortlisted': shortlisted,

'rejected': rejected,

return render(request, 'core/recruiter_dashboard.html', context)

@login_required

def post_job(request):

generated_jd = None

if [Link] == 'POST':

if 'generate_jd' in [Link]:

job_title = [Link]('title', '')

if job_title:

31
SISTec/BTech/AD/2025/5/Minor Project_I/4 32

generated_jd = generate_job_description(job_title)

form = JobPostingForm(initial={'title': job_title, 'description': generated_jd})

if "Could not generate job description" in generated_jd:

[Link](request, generated_jd)

else:

[Link](request, "Job Description generated successfully!")

else:

form = JobPostingForm([Link])

[Link](request, "Please enter a job title first.")

else:

form = JobPostingForm([Link])

if form.is_valid():

job = [Link](commit=False)

[Link] = [Link]

[Link]()

return redirect('recruiter_dashboard')

else:

form = JobPostingForm()

return render(request, 'core/post_job.html', {'form': form, 'generated_jd':

32
SISTec/BTech/AD/2025/5/Minor Project_I/16 33

generated_jd})

@login_required

def apply_for_job(request, job_id):

if not [Link].is_candidate:

return redirect('dashboard')

job = get_object_or_404(Job, id=job_id, is_internal=True)

if [Link](candidate=[Link], job=job).exists():

[Link](request, "Aap is job par pehle hi apply kar chuke hain.")

return redirect('candidate_dashboard')

if [Link] == 'POST':

form = ApplicationForm([Link], [Link])

if form.is_valid():

resume_file = [Link]['resume']

job_description = [Link]

ranking_score = get_resume_ranking(resume_file, job_description)

if ranking_score is None:

[Link](request, "Resume file read nahi ho payi. Kripya sahi format mein file

33
SISTec/BTech/AD/2025/5/Minor Project_I/4 34

upload karein.")

return redirect('apply_for_job', job_id=[Link])

application = [Link](commit=False)

[Link] = [Link]

[Link] = job

application.ranking_score = ranking_score

[Link]()

[Link](request, "Aapka application safal ho gaya hai!")

return redirect('candidate_dashboard')

else:

form = ApplicationForm()

return render(request, 'core/apply_for_job.html', {'form': form, 'job': job})

def home(request):

return render(request, 'core/[Link]')

@login_required

def recruiter_job_applications(request, job_id):

if not [Link].is_recruiter:

return redirect('dashboard')

job = get_object_or_404(Job, id=job_id, recruiter=[Link])

34
SISTec/BTech/AD/2025/5/Minor Project_I/16 35

applications = [Link](job=job).order_by('-ranking_score')

return render(request, 'core/recruiter_job_applications.html', {'job': job, 'applications':

applications})

@login_required

def shortlist_application(request, app_id):

if not [Link].is_recruiter:

return redirect('dashboard')

application = get_object_or_404(Application, id=app_id,

job__recruiter=[Link])

[Link] = 'Shortlisted'

[Link]()

[Link](request, f"{[Link]} has been

shortlisted.")

return redirect('recruiter_job_applications', job_id=[Link])

def candidate_login(request):

if [Link] == 'POST':

form = LoginForm(request=request, data=[Link])

if form.is_valid():

user = form.get_user()

if user.is_candidate and not user.is_recruiter:

auth_login(request, user)
35
SISTec/BTech/AD/2025/5/Minor Project_I/4 36

return redirect('candidate_dashboard')

else:

[Link](request, "Invalid login credentials for a candidate.")

else:

[Link](request, "Invalid username or password.")

else:

form = LoginForm()

return render(request, 'registration/[Link]', {'form': form})

def recruiter_login(request):

if [Link] == 'POST':

form = LoginForm(request=request, data=[Link])

if form.is_valid():

user = form.get_user()

if user.is_recruiter and not user.is_candidate:

auth_login(request, user)

return redirect('recruiter_dashboard')

else:

[Link](request, "Invalid login credentials for a recruiter.")

else:

[Link](request, "Invalid username or password.")

36
SISTec/BTech/AD/2025/5/Minor Project_I/16 37

else:

form = LoginForm()

return render(request, 'registration/[Link]', {'form': form})

@login_required

def reject_application(request, app_id):

if not [Link].is_recruiter:

return redirect('dashboard')

application = get_object_or_404(Application, id=app_id, job__recruiter=[Link])

[Link] = 'Rejected'

[Link]()

[Link](request, f"{[Link]} has been rejected.")

return redirect('recruiter_job_applications', job_id=[Link])

37
SISTec/BTech/AD/2025/5/Minor Project_I/4 38

CHAPTER 10
RESULT & OUTPUT SCREENS

FIGURE 10.1

FIGURE 10.2

38
SISTec/BTech/AD/2025/5/Minor Project_I/16 39

FIGURE 10.3

FIGURE 10.4

39
SISTec/BTech/AD/2025/5/Minor Project_I/4 40

FIGURE 10.5

40
SISTec/BTech/AD/2025/5/Minor Project_I/16 41

FIGURE 10.7

FIGURE 10.8

41
 SISTec/BTech/AD/2025/5/Minor project _I/4 42

CHAPTER 11
CONCLUSION & FUTURE WORK

11.1 CONCLUSION
The AI-based Applicant Tracking System (ATS) automates resume screening and candidate shortlisting,
leveraging backend algorithms to extract skills, qualifications, and experience from resumes. This
project demonstrates how AI can streamline recruitment by reducing manual effort, improving
accuracy in candidate evaluation, and speeding up the hiring process. Users can upload resumes, view
the extracted information, and receive automated recommendations for suitable job roles. The system
provides a simple, user-friendly interface using HTML, CSS, and Jinja templates, making it accessible
and easy to use. Overall, this ATS bridges the gap between job seekers and employers, offering a more
efficient, reliable, and scalable recruitment process.

11.2 FUTURE WORK

I. Enhanced Resume Parsing: Incorporate NLP models to extract more nuanced information such as
certifications, projects, and achievements.
II. Job Matching Algorithms: Implement AI-based ranking of candidates against job descriptions for
improved relevance.
III. Candidate Analytics Dashboard: Provide visual insights into candidate statistics, trends, and skill
gaps.
IV. Automated Notifications: Add email or SMS alerts to notify candidates about application status or
feedback.
V. Integration with Job Portals: Enable automatic fetching of live job postings to match candidates
with relevant opportunities.
SISTec/BTech/AD/2025/7/Major Project_I/04 43

REFERENCES

[1] A. R. Vishaline, R. K. P. Kumar, V. V. N. S. Sai Pramod, K. V. K. Vignesh, and P. Sudheesh, “An ML-
based Resume Screening and Ranking System,” in *2024 International Conference on Signal Processing,
Computation, Electronics, Power and Telecommunication (IConSCEPT)*, Karaikal, India, Jul. 4–5, 2024,
pp. 1–6. doi:10.1109/IConSCEPTXXXX.10627825.
[2] K. Tejaswini, V. Umadevi and S. Revanna, “Design and Development of Machine Learning based
Resume Ranking System,” *Global Transitions Proceedings*, vol. 3, no. 2, Nov. 2022.
doi:10.1016/[Link] (S2666285X21001011). :contentReference[oaicite:1]{index=1}
[3] N. Aidasani, P. Adep, V. Darade, S. Chavan, and Dr. Shagufta Md. S. Sheikh, “AI-Powered Resume
Ranking System: Enhancing Recruitment Efficiency through Natural Language Processing,” *International
Journal for Research Trends and Innovation (IJRTI)*, vol. 10, no. 5, pp. b367–b371, May 2025, ISSN 2456-
3315, doi:10.6084/[Link].IJRTI2505141. :contentReference[oaicite:0]{index=0}

43
SISTec/BTech/AD/2025/7/Major Project_I/01 44

APPENDIX-1 GLOSSARY OF TERMS

Term Definition

Accuracy Ratio of correctly ranked/classified resumes to total resumes processed.

Secure backend dashboard to manage users, logs, rankings, and system

Admin Panel
activity.

URL routes used by frontend to fetch rankings, upload resumes, get

API Endpoint
predictions etc.

Server logic handling preprocessing, prediction, authentication, and

Backend
database operations.

Deep neural model used for extracting contextual meaning from resume
Bi-LSTM text.

Table showing model’s true/false positives and negatives across resume

Confusion Matrix
labels.

Maximum users who can upload resumes or run evaluations at the same
Concurrent Users
time.

Synthetic text expansion techniques to improve training data quality.

Data Augmentation

Password hashing, JWT, HTTPS, and access restrictions to protect

Data Security
user/resume data.

User interface showing rankings, analytics, interview history and modules.

Dashboard

A subset of machine learning involving neural networks with multiple

Deep Learning layers that can learn from vast amounts of unstructured data.
44
SISTec/BTech/AD/2025/7/Major Project_I/04 45

Term Definition

Documentation API specs, model training reports, and deployment instructions.

One full pass over the training dataset during model training.
Epoch

Harmonic mean of precision and recall used to measure model quality.

F1-Score

User-facing interface built for uploading resumes, viewing rankings, and

Frontend
interacting with modules.

Tokenization, cleaning, normalization, and vectorization of resume text.

Input Preprocessing

Token-based authentication for secure session handling.

JWT (JSON Web Token)

Converts resume categories (e.g., “ML Engineer”, “Frontend Dev”) into

Label Encoding
numeric labels.

Measures how far predicted labels are from actual labels during training.
Loss Function

Automated interview simulation module for user practice.

Mock Interview

Accuracy, precision, recall, F1-score, and confusion matrix assessment.

Model Evaluation

Scaling input vectors for stable model training.

Normalization

NLP (Natural Language Techniques enabling the model to understand and classify resume text.

45
SISTec/BTech/AD/2025/7/Major Project_I/01 46

Term Definition

OTP (One-Time One-time password used for verifying users during login/registration.
Password)

When model memorizes training data instead of learning patterns.

Overfitting

Increasing minority-class resume samples to fix dataset imbalance.

Oversampling

Making text sequences the same length for the neural model.
Padding

Ratio of true positive predictions to total predicted positives.

Precision

Ratio of true positives to all actual positives.

Recall

UI adapts to all devices (mobile, desktop).

Responsive Design

Standard API design used for resume uploads, scoring, and result retrieval.
RESTful API

Adjusting numeric values for consistent model training.

Scaler/Normalization

System can handle more users, resumes, and features without crashing.
Scalability

Unseen data used to measure model performance after training.

Test Set

46
SISTec/BTech/AD/2025/7/Major Project_I/04 47

Term Definition

An NLP technique used to categorize text inputs (e.g., user responses) into
Text Classification
predefined labels or categories.

A tool in NLP used to break text into individual elements such as words or
Tokenizer
subwords for further processing.

A process of renewing an expired access token using a refresh token to

Token Refresh
maintain session continuity securely.

Training Set The subset of data used to train the deep learning model.

A state-of-the-art NLP architecture that processes data in parallel and uses

Transformer
attention mechanisms for language understanding.

A module that allows users to solve domain-based coding challenges in

Practice Coding Problems multiple programming languages and receive instant feedback on code
accuracy and performance.

A quiz feature designed to test users’ theoretical knowledge through

Attempt Quiz
domain-specific questions, providing instant results with explanations.

A functionality that dynamically fetches and displays relevant job listings

Job Recommendations
from [Link] using Selenium-based web scraping.

A feature integrated with Google Analytics to monitor user performance,

Analytics Insights
engagement, and progress trends over time.

A technique used to balance datasets by reducing the number of samples

Under sampling
from the majority class.

A portion of the dataset used to evaluate the model during training to tune
Validation Set
hyperparameters and prevent overfitting.

Word Embedding A vector representation of a word capturing its semantic meaning and

47
 SISTec/BTech/AD/2025/5/Minor Project_I/4 48
48

PROJECT SUMMARY
About Project
Title of the project Design and Development of an AI-Powered
Applicant Tracking System (ATS)
Semester 5
Members DEVENDR SINGH–0187AS231017
SAMEER GUPTA – 0187AS231053
RAHUL KUSHWAHA-0187AS231042

Team Leader DEVENDRA SINGH

Rahu Kushwaha : UI/UX Designer
Describe role of every Devendra Singh: Lead Developer & AI Specialist,
member in the project
Backend Developement
Sameer Gupta: Frontend Dev

The motivation for this project arises from the inefficiencies and subjectivity
What is the motivation for
selecting this project? in traditional resume screening processes. Recruiters often spend hours
manually reviewing resumes, which is error-prone, inconsistent, and biased.
The AI-powered ATS was chosen to:

Reduce Screening Time: Automatically parse resumes, extract key

skills, and rank candidates, saving significant recruiter time.

Minimize Bias: Provide a standardized, data-driven evaluation to

reduce human subjectivity in candidate selection.

Improve Accessibility: Offer a centralized, intelligent platform for

recruiters to manage applications and interact with candidates
efficiently .
48
SISTec/BTech/AD/2025/5/Minor Project_I/4 49

Project Type Web Application

(Desktop Application, Web
Application, Mobile App, Web)

Tools &Technologies
Programming language Python, HTML, CSS, JS
used
Compiler used Python 3.12.8
(withversion)
IDE used Visual Studio Code (VS Code)
(with version)
Version: 1.103.2

HTML5
Front End Technologies
(with version, wherever CSS3
Applicable) JavaScript (ES6+)
Python (v3.12.8)
Back End Technologies
(with version, wherever Django (v5.x)
applicable) NumPy

Database used SQLite3 (default with Django)

(with version)
 SISTec/BTech/AD/2025/5/Minor Project_I/4 50

Software Design& Coding

Is prototype of the software Yes
developed?
SDLC model followed Agile
(Waterfall, Agile, Spiral etc.)
Why above SDLC model is Agile (Iterative and Incremental), chosen for
followed?
flexibility to integrate AI model and web features
progressively.

Justify that the SDLC model The project was built incrementally. We started with
mentioned above is followed in
the project. the core prediction UI, then iteratively added the
backend API, the result page, the full disease library,
and the user authentication system. Each component
was developed and refined in a separate cycle,
allowing for flexible adjustments and continuous
improvement, which is a hallmark of the Agile
methodology.
Software Design approach Object-Oriented
followed
(Functional orObjectOriented)
Use Case Diagram
Name the diagrams
developed Project Flow Chart
(according to the Design
approach followed)

Encapsulation: Django models (like the User model)

In case Object Oriented
approach is followed, which of encapsulate data (fields) and behavior (methods).
the OOPS principles are Inheritance: Django's UserCreationForm and class-
covered in design? based views inherit from base classes.
Abstraction: The Django ORM abstracts complex
SQL queries into simple Python objects, hiding the
database-level complexity.
 SISTec/BTech/AD/2025/5/Minor Project_I/4 51

No. of Tiers 3-tier

(example 3-tier)
Total no. of front end pages 9
Total no. of tables in database ~10-12 (including Django's built-in tables for Users,
Sessions, and Admin)
Database is in which Normal Third Normal Form (3NF)
Form?
Are the entries in database User passwords are not encrypted; they are securely
encrypted?
hashed using Django's built-in PBKDF2 algorithm.
Front end validations applied Yes
(Yes / No)
Session management done
(in case of web applications)
Yes (Handled by Django's built-in authentication and
session framework)

Is application browser Yes (Compatible with all modern browsers like

compatible
(in case of web applications) Chrome, Firefox, and Edge)
Exception handling done Yes (The predict view uses try...except blocks to catch
(Yes / No)
errors and return JSON-formatted error messages)
Commenting done in code Yes
(Yes / No)
Naming convention followed Yes (PEP 8 for Python, camelCase for JavaScript)
(Yes / No)
The primary challenges were: 1) Correctly configuring
What difficulties faced during
deployment of project? static file serving (whitenoise) for the CSS and
JavaScript. 2) Ensuring the production server had the
correct file path to the large .h5 model file. 3)
Managing environment variables for the Django
SECRET_KEY and database settings.
Total no. of Use-cases 9
 Register Account
Give titles of Use-cases  Login
 Logout
 SISTec/BTech/AD/2025/5/Minor Project_I/4 52

 Interact with Chatbot

Project Requirements
MVC architecture followed Yes
(Yes / No)
If yes, write the name of MVT (Model-View-Template), which is Django's implementation
MVC architecture followed analogous to MVC-2.
(MVC-1, MVC-2)
Design Pattern used Yes
(Yes / No)
If yes, write the name of  Model-View-Template (MVT)
Design Pattern used  Singleton (for loading the AI model once on server start)

Interface type GUI (Graphical User Interface)

(CLI / GUI)

No. of Actors 3 (1 Primary, 2 Secondary)

Name of Actors  Primary: User (Guest or Authenticated)
 Secondary: AI Model, Google Maps API

 Performance: The AI prediction must return a result in

List few important non- under 10 seconds.
Functional Requirements  Security: All user passwords must be hashed. All forms
must be protected by CSRF tokens.
 Usability: The application must be fully responsive and
intuitive on both desktop and mobile devices.

Devendra Singh–0187AS231017 Guide Signature

Rahul Kuswaha–0187AS231042 Ms. Ruchi Jain
SameerGupta – 0187AS231053
SISTec/BTech/AD/2025/5/Minor Project_I/4 53