Bank Loan Automation System

Mini Project submitted in partial fulfillment of the requirement for the award of the
degree of

BACHELOR OF TECHNOLOGY

IN

COMPUTER SCIENCE AND ENGINEERING (DATA SCIENCE)

Under the esteemed guidance of

Mr. Audi Reddy Kayithi

Assistant Professor

By

Arigela Pranay Kumar (20R11A6701)

Charan Sai Paritala (20R11A6708)
Dindar Pranav Sai (20R11A6713)

Department of CSE (DATA SCIENCE)

Geethanjali College of Engineering and Technology

(UGC Autonomous)
(Affiliated to J.N.T.U.H, Approved by AICTE, New Delhi, NAAC A+)
Cheeryal (V), Keesara (M), Medchal.Dist.-501 301.

November-2023

i
Geethanjali College of Engineering & Technology
(UGC Autonomous)
(Affiliated to JNTUH, Approved by AICTE, New Delhi)
Cheeryal (V), Keesara(M), Medchal Dist.-501 301.

DEPARTMENT OF CSE (DATA SCIENCE)

CERTIFICATE

This is to certify that the B. Tech Mini Project report entitled “Bank Loan
Automation System” is a bonafide work done by Arigela Pranay Kumar
(20R11A6701), Charan Sai Paritala (20R11A6708), Dindar Pranav Sai
(20R11A6713), in partial fulfillment of the requirement of the award for the degree
of Bachelor of Technology in “CSE (Data Science)” from Jawaharlal Nehru
Technological University, Hyderabad during the year 2023-2024.

Internal Guide HOD CSE(DS)

Mr. Audi Reddy Kayithi Dr L. Kiran Kumar Reddy
Assistant Professor Associate Professor

External Examiner

ii
Geethanjali College of Engineering & Technology
(UGC Autonomous)
(Affiliated to JNTUH Approved by AICTE, New Delhi)
Cheeryal (V), Keesara(M), Medchal Dist.-501 301.

DEPARTMENT OF CSE (DATA SCIENCE)

DECLARATION BY THE CANDIDATE

We, Arigela Pranay Kumar, Charan Sai Paritala, Dindar Pranav Sai bearing
Roll Nos. 20R11A6701, 20R11A6708, 20R11A6713, hereby declare that the project
report entitled “Bank Loan Automation System” is done under the guidance of Mr.
Audi Reddy Kayithi, Assistant Professor, Department of Computer Science and
Engineering (Cyber Security), Geethanjali College of Engineering and Technology, is
submitted in partial fulfillment of the requirements for the award of the degree of
Bachelor of Technology in CSE (Data Science).

This is a record of bonafide work carried out by me/us in Geethanjali College of

Engineering and Technology, and the results embodied in this project have not been
reproduced or copied from any source. The results embodied in this project report have
not been submitted to any other University or Institute for the award of any other degree
or diploma.

Arigela Pranay Kumar (20R11A6701)

Charan Sai Paritala (20R11A6708)
Dindar Pranav Sai (20R11A6713)

Department of CSE(DS),
Geethanjali College of Engineering Technology,
Cheeryal.

iii
 ACKNOWLEDGEMENT

We are greatly indebted to the authorities of Geethanjali College of Engineering

and Technology, Cheeryal, Medchal District, for providing us the necessary
facilities to successfully carry out this main project work titled
“Bank Loan Automation System”, Firstly, we thank and express our solicit
gratitude to our HOD, Dr L Kiran Kumar Reddy, Associate Professor,
CSE(DS) department, Geethanjali College of Engineering and Technology, for
her invaluable help and support which us a lot in successfully completing our
main project, Secondly, we express our gratitude to Mr. Audi Reddy Kayithi,
Assistant Professor CSE(CS), internal guide, Geethanjali College of
Engineering and Technology, for his suggestion and encouragement which
helped us in the successful completion of our main project.

We would like to express our sincere gratitude to our Principal

Dr. S. Uday Kumar for providing the necessary infrastructure to complete our
project, We convey our gratitude to our Chairman, Mr. G. Ravinder Reddy,
for his invaluable support and encouragement for propelling our innovation
forward. Finally, we would like to express our heartfelt thanks to our parents
who were very supportive both financially and mentally and for their
encouragement to achieve our goals.

Finally, we would like to express our heartfelt thanks to our parents who were
very supportive both financially and mentally and for their encouragement to
achieve our set goals.

Arigela Pranay Kumar (20R11A6701)

Charan Sai Paritala (20R11A6708)
Dindar Pranav Sai (20R11A6713)

iv
 ABSTRACT
The enhancement in the banking sector lots of people are applying for bank loans
but the bank has its limited assets which it must grant to limited people only, so
finding out to whom the loan can be granted which will be a safer option for the
bank is a typical process. So, in this project, try to reduce this risk factor behind
selecting the safe person to save lots of bank efforts and assets. This is done by
mining the Big Data of the previous records of the people to whom the loan was
granted before and based on these records/experiences the machine was trained
using the machine learning model which gives the most accurate result, The main
objective of this project is to predict whether assigning the loan to a particular
person will be safe or not. Here Machine learning techniques are used to predict
many person who is reliable for a loan, based on the previous record of the person
to whom the loan amount is accredited before, The Four machine learning
algorithms like Support Vector Machine, Logistic Regression, Random Forest and
XGBoost are compared and the algorithm with highest accuracy is applied to
predict the loan approval of customers, Majority of the loans are provided by private
bank because the processing time much low, This is a problem because even though
the government banks offers a very low interest rate, may people are not preferring
government banks because it is very slow to update, Many people wait in the cases
of Home loan or Vehicle loans etc., But the same cannot be said about education
loans because if any rejection occurs the applicant is stuck in a foreign country
bound to pay high interest rates.

v
 LIST OF FIGURES/DIAGRAMS/GRAPHS

S. No Diagram Name Page No

4.1 System Architecture 14

4.2.1 Use Case Diagram 16

4.2.2 Class Diagram 17

4.2.3 Sequence Diagram 18

4.2.4 State Chart Diagram 19

4.2.5 Data Flow Diagram 20

5.1.1 Identifying important attributes 22

5.1.2 Correlation Matrix 22

7.1 Application Page 36

7.2 Result Screen 37

7.3 Email Screen 37

7.4 EMI Calculator 38

7.5 Admin Login 38

7.6 Database User Interface 39

11 Plagiarism Report 48

vi
 TABLE OF CONTENTS

S. No Contents Page no
Abstract v
List of Figures vi

1. Introduction……………………………………………………………1

1.1 About the project 1

1.2 Objective 1

2. System Analysis……………………………………………………….2-7

2.1 Existing System 2

2.2 Proposed System 3

2.3 Feasibility Study 4

2.3.1 Details 4

2.3.2 Impact on Environment 4

2.3.3 Safety 4

2.3.4 Ethics 4

2.3.5 Cost 5
2.3.6 Type 5
2.4 Scope of the Project 5

2.5 Modules Description 6

2.6 System Configuration 7

vii
3. Literature Overview……………………………………………....8-13

4. System Design…………………………………………………….14-20

4.1 System Architecture 14

4.1.1 Module Description 15

4.2 System Design 16-20

4.2.1 Use Case Diagram 16

4.2.2 Class Diagram 17
4.2.3 Sequence Diagram 18
4.2.4 State Chart Diagram 19
4.2.5 Data Flow Diagram 20

5. Implementation………………………………………………….21-33

5.1 Implementation 21-24

5.2 Sample code 25-33

6. Testing……………………………………………………………34-35

6.1 Testing 34

6.2 Test cases 34-35

7. Output Screens…………………………………………………..36-39

8. Conclusion………………………………………………………...40

8.1 Conclusion 40

8.2 Further Enhancements 40

9. Bibliography…………………………………………………….41-42

9.1 Books References 41

9.2 Websites References 42

viii
10 Appendices………………………………………………………43-47

10.1 Software used. 43

10.2 Methodologies used. 45

10.3 Testing Methods used. 47

11 Plagiarism Report...………………………………………………48

ix
 1. INTRODUCTION

1.1 About the Project

Loan Distribution is the main business part of many banks. The main portion of banks
income comes from the loan distributed to customers. These banks apply interest on
loans which are distributed to customers.

The main objective of banks is to invest their assets in safe customers. Up to now many
banks are processing loans after regress process of verification and validation. But till
now no bank can give surety that the customer who is chosen for loan application is safe
or not. So, to avoid this situation we introduced a system for the approval of bank loans
known as Loan Prediction System Using Python.

Loan Prediction System is a software which checks the eligibility of a particular

customer who can pay loan or not. This system checks various parameters such as
customer’s marital status, income, expenditure, and various factors. This process is
applied for many customers of trained data set. By considering these factors a required
model is built. This model is applied on the test data set for getting required output. The
output generated will be in the form of yes or no. Yes indicates that a particular
customer is capable of paying loan and no indicates that the particular customer is not
capable of paying for a loan. Based on these factors we can approve loans for customers

1.2 Objective
• To make the process of loan approval easy using fewer resources and human
resources.
• To make a web-app which can be accessible by anyone on the internet without
downloading any desktop software.
• To make the prediction model which will make accurate predictions and help
banks to make approving the loans very easy.

1
 2. SYSTEM ANALYSIS
2.1 Existing System
The existing system for bank loan processing involves a manual and time-consuming
process that requires significant human effort and introduces the possibility of errors.
Loan applications are typically reviewed by bank employees who manually assess the
applicant's creditworthiness, financial history, and other relevant factors before
deciding. This traditional approach often leads to delays in loan approvals, resulting in
customer dissatisfaction and lost business opportunities.

The existing system typically involves a human loan officer manually reviewing a
loan application, collecting, and verifying the applicant's information, and then deciding
on whether to approve or deny the loan. This process can be time-consuming and error
prone, Bank employees check the details of applicants manually and give the loan to
eligible applicants. Checking the details of all applicants takes a lot of time. The present
system involves an employee checking the eligibility criteria of every application. This
process is tedious and ineffective. The result of this is a lot of applications take more
time for approval.

The drawbacks of the Existing System are:

• Checking the details of all applicants consumes a lot of time and effort. There is a
chance of human error may occur due to checking all details manually. There is
the possibility of assigning a loan to an ineligible applicant.
• They had proposed a mathematical model and machine learning algorithms are
not used. Class Imbalance problem was not addressed, and the proper measure
was not taken.

2
2.2 Proposed System
The system will incorporate various components to automate and enhance various
stages of the loan approval process. Initially, customer data will be collected and
analyzed, including financial history, credit scores, income statements, and employment
records. Machine learning algorithms will then assess this information to evaluate the
applicant's creditworthiness and determine the likelihood of repayment. By utilizing
historical loan data, the system will continuously learn and adapt its decision-making
capabilities.

To deal with the problem, we developed automatic loan prediction using machine
learning techniques. We will train the machine with the previous dataset. so, the
machine can analyze and understand the process. Then the machine will check for
eligible applicants and give us results.

3
2.3 Feasibility Study

2.3.1 Details
The feasibility study for this project involved a thorough examination of the market
demand for a loan approval prediction system in the banking sector. Data availability
and accessibility were assessed, and it was determined that a substantial amount of
historical loan data could be obtained for analysis. Technical resources, including
computing power and software tools, were identified as readily available.

2.3.2 Impact on Environment

This project has a minimal impact on the environment as it primarily involves data
analysis and machine learning, which do not consume significant energy or resources.
The environmental footprint of the project is largely associated with the hardware
infrastructure used for training machine learning models.

2.3.3 Safety
Ensuring data safety and privacy is of paramount importance in this project. Stringent
security measures and data encryption are implemented to protect sensitive financial
data. Access controls and authorization mechanisms are in place to prevent
unauthorized access to customer information.

2.3.4 Ethics
Ethical considerations are integral to this project. Measures are taken to ensure fairness
and transparency in the loan approval process. Efforts are made to reduce bias in
machine learning models and to comply with privacy regulations, respecting customers'
personal information.

4
2.3.5 Cost
The project's costs include expenses for data acquisition, hardware infrastructure,
software licenses, and personnel. The initial costs for setting up the project and
acquiring necessary resources have been budgeted, and ongoing operational costs are
monitored and managed.

2.3.6 Type
This feasibility study primarily falls under a technical feasibility study, as it evaluates
the technical requirements and resources needed to develop and maintain the loan
approval prediction system.

2.4 Scope of the Project

The project's scope encompasses the development of a loan approval prediction system
that leverages machine learning techniques. It aims to predict loan applicant reliability
based on historical data. The project's boundaries include data analysis, model
development, and predictions. It does not include the actual approval or rejection of
loans, which remains the prerogative of the bank's loan officers.

5
2.5 Modules Description
The project consists of the following modules:
1. Data Preprocessing: Cleaning and transforming raw loan data for analysis.
2. Feature Engineering: Creating relevant features and variables for machine
learning.
3. Model Training: Employing Support Vector Machine, Logistic Regression,
Random Forest, and XGBoost algorithms to train predictive models.
4. Model Evaluation: Assessing the models' accuracy and performance using
metrics like accuracy, precision, recall, and F1-score.
5. Loan Approval Prediction: Using the best-performing model to predict
whether an applicant is reliable for a loan.
6. Loan Approval From: A front end app that collects all the user data and sends
it to the flask Backend and generates document
7. EMI Calculator: A simple JavaScript implementation to calculate monthly
Emi of payments by the end user

6
2.6 System Configuration
Software requirements
Minimum requirement of software is:
• Operating system: Windows 7/higher, Mac
• Designing tool: Visual Studio Code
• Any web Browser (Google chrome, safari, Microsoft edge)
• Front end: HTML, Cascading Style Sheets, JavaScript
• Deployment: GitHub

Hardware Requirements
Minimum requirement of hardware is:
• RAM: 4GB
• Hard Disk: 50 GB
• Processor: Core i5 or more

The system configuration for this project includes:

• Hardware: High-performance servers with sufficient RAM and GPU support for
model training.
• Software: Python programming language, popular data analysis libraries (e.g.,
Pandas, NumPy), machine learning frameworks (e.g., scikit-learn, XGBoost),
and database management systems (e.g., SQL for data storage).
• Data Sources: Historical loan data obtained from the bank's records.
• Personnel: A team of data scientists, machine learning engineers, and domain
experts responsible for project development and management.

7
 3.LITERATURE OVERVIEW

P. L. Srinivasa Murthy1, G. Soma Shekar2 , P. Rohith3 , G. Vishnu Vardhan

Reddy4
1Associate Professor and Head, Department of Computer Science and Engineering,
Institute of Aeronautical Engineering, Hyderabad, India. 2, 3, 4 Department of
Computer Science and Engineering, Institute of Aeronautical Engineering, Hyderabad,
India

Abstract - With the increase in the banking sector many people are applying for loans in
banks. All these loans are not approvable. The main income of bank assets comes from
gain earned from loans. The main objective of banks is to invest their assets in safe
customers. Today many banks approve loans after many processes of verification and
validation but still there is no surety that the selected customer is safe or not. Therefore,
it is important to apply various techniques in the banking sector for selecting a customer
who pays loan on time. In this report we use random forest algorithm for the
classification of data. Random forests algorithm builds a model from trained dataset and
this model is applied on test data and we get the required output.

8
International Journal of Engineering and Management Research, Volume-13,
Issue-4 (August 2023) K N Adithya G
Date Written: August 4, 2023
Due to significant technological advancements, people's needs have expanded. As a
result, there have been more requests for loan approval in the banking sector. A few
qualities are taken into consideration when choosing a candidate for the loan approval in
order to, determine the loan's status. Banks face a major challenge; when it, comes to
assessing loan applications and lowering the risks associated with potential borrower
defaults This tactic can increase the accuracy with which qualified candidates are
selected from a pool of applicants. As a result, this method can be used to address the
problems with loan approval processes outlined above. Both the loan applicants and the
bank employees profit from the strategy's dramatic reduction in sanctioning time.
Because of the banking industry's expansion, more people were applying for loans at
banks. In order to predict the accuracy of loan approval status for an applied person, we
used four different algorithms namely Random Forest, Naive Bayes, Decision Tree, and
KNN. By using these, we obtained better accuracy of 83.73% with the Naïve Bayes
algorithm as the best one, Algorithms Used are
Random Forest, A component of supervised learning technique is Random Forest(RF).
It will be used for ML problems involving both classification and regression. It is, based
on concept of ensemble learning, which is technique for, integrating many classifiers, to
handle tough problems and develops performance of the model.
It took shorter time for training than other algorithms. It functions well and makes
accurate predictions of the outcome even with the massive dataset.
Decision Tree, The prediction model known as decision tree(DT) uses, flowchart,
structure for base decisions on incoming data. Data branches are built, and the results
are placed at nodes of leaves. Decision trees were used to provide models that are
simple to comprehend to regression, and classification problems. In decision support,
decisions, and their potential outcomes— including chance occurrences, resource costs,
and utility—are represented by hierarchical models known as decision trees.

9
Golak Bihari Rath, Debasish Das & Vishwaraja Acharya
As the needs of people are increasing, the demand for loans in banks is also frequently
getting higher every day. Usually, banks process the loan of any applicant after the
verification and checking of its eligibility which is a tough and time-taking process. In
some cases, some applicants default in payment resulting in loss of capital in banks.
Machine learning approach would be an ideal solution to reduce human efforts and
effective decision making in the loan approval process by implementation of machine
learning tools using classification algorithms to predict the deserving applicants for loan
approval.
Logistic Regression
It is a statistical-based algorithm that determines the probability of an event as a
function of variables using classification function. The classification function calculates
the statistics for a logistic response function. It shows the relationship between the
dependent variable and independent variables
Decision Tree
Decision tree uses the tree representation to produce a model with the most relevant
predictor attributes. Attribute with the highest-ranking attribute of the dataset is placed
as the root node, and other attributes are placed to the leaf node. At each node, a
decision is made where leaf nodes give us the final result. The tree building is continued
until we get an outcome in the internal nodes. The overall results are calculated in the
form of decisions, and the final decisions constitute our category.
We find that the accuracy of the logistic regression model has a prediction accuracy of
nearly 80% which is more than the performance of other models. Further, we can use
this model as a prediction model to test with the data of the applicants. The model can
provide fast, reliable approach in decision making which can be an alternative to the
current procedures adopted by banks for processing loan approval of an applicant.We
can change the prediction variables used in the training of the model for gaining better
accuracy and performance of the model.

10
K.S. Naik NMIMS MPSTME, Mumbai, India Guided by Professor
Dr. Lakshmi Gorty, NMIMS MPSTME, Mumbai, India October 6, 2021

Module Description
1) Logistic Regression Classifier Logistic Regression is heavily used in initial credit
scoring studies. It is easy to implement, and has a well-established history with credit
card delinquency. However, it has limited power when dealing with non-linear data,
which makes it unsuitable for complex default detection problems. Logistic Regression
model is known to overfit the training data, and its overfitting behavior becomes even
more prominent with an increase in training data.

2) Support Vector Machine Classifier Support Vector Machine (SVM) is a linear model
for classification. It creates a line or a hyper-plane which separates the data into classes.
As compared to logistic regression, which focuses on maximizing the probability of two
classes, SVM dwells on maximizing the separation of these classes using the hyper-
plane and in turn improves the classification accuracy (i.e., minimizing the
generalization error). In this model, two hyper-parameters are used, namely: • Gamma:
Determines the curvature needed in a decision boundary (i.e., hyper-plane). A low value
indicates that a lot of points can be grouped together and vice versa. • C: Controls the
margin of hyper-plane with a view to classifying training points correctly. A greater
value of C indicates more correct training points.

3) K-Neighbors Classifier K-Nearest Neighbors (KNN) is a non-parametric

classification model and is also known as a lazy algorithm which means the entire
training dataset is used for testing purposes. The testing phase thus requires greater time
consumption, more memory and higher cost.

4) Decision Tree Classifier A Decision Tree is a supervised machine learning model

with a binary tree structure. Beginning with the training data that lies on a single node,
it is split into two halves. This split occurs by answering the ’if-else’ question. After this
split, the data is then classified into two nodes. This goes on till the tree reaches a leaf
node that incorporates the predicted class value.

11
Dr.C K Gomathy, Ms.Charulatha,Mr.Akash ,Ms.Sowjanya
Impact Factor value: 7.529
ISO 9001:2008 Certified Journal

Banks are making a major part of profits through loans. Though lot of people are
applying for loans. It’s hard to select the genuine applicant, who will repay the loan.
While doing the process manually, a lot of misconceptions may happen to select the
genuine applicant. Therefore, we are developing a loan prediction system using machine
learning, so the system automatically selects eligible candidates. This is helpful to both
bank staff and applicants. The time period for the sanction of loan will be drastically
reduced.

Decision Tree loans

Decision tree is a type of supervised education algorithm that is generally used in
category problems. In this approach, we disassociate the population or sample
into two or added homogeneous sets based on the most significant splitter/
differentiator in input variables.
Decision trees use multiple algorithms to decide to disunite a bump into two or added
sub- knots. The creation of sub- knots increases the unsophistication of attendant sub-
knots. In other words, we can say that chasteness of the bump increases with respect to
the target variable.

12
Predicting the outcomes:
Using the decision tree algorithm, the outcomes of all applicants can be stored in any
file.
Algorithm:
1. Import all the required python modules
2. Import the database for both TESTING and TRAINING.
3. Check any NULLVALUES are exists
4. If NULLVALUES exits, fill the table with corresponding coding
5. Exploratory Data Analysis for all ATTRIBUTES from the table
6. Plot all graphs using MATPLOTLIB module
7. Build the DECISIONTREE MODEL for the coding
8. Send that output to CSV FILE

13
 4. SYSTEM DESIGN

4.1 System Architecture

The Bank loan automation system is designed in such as way that initially the user
enters all the required fields like name, email address, Cibil Score, Income etc. all this
user information are then sent into a machine learning model which is trained on
classified datasets, If the user is eligible it saves the information into the database and
the information is transferred to the backend which does the job of sending the provided
information in the form of document to the provided Email address, The application
also has a administrative module which is password protected which provides all the
information stored in the database right in the application.

14
4.1.1 Module Description
The project consists of the following modules:
• Loan Approval Form: Using the best-performing model to predict whether an
applicant is reliable for a loan the model user SVM algorithm to predict eligible
or not if eligible the data is sent to backend which user Python and JavaScript to
make a document of the user data and send the document as a email, Also all the
eligible applicants data in stored in a database made up of SQLite, This database
cannot be accessed by the user but only can be viewed by the administrator
• Administrative login page this page has a basic login page which when
successful will load all the successful applications details this module uses flask
and SQL Alchemy to retrieve all the data form the SQLite database and render it
using Flasks Jinga Templating Syntax, This module is password protected and
can only be accessed by a POST request
• Machine Learning Module: In this module we tested all the best performing
modules like SVM, XGBoost, Logistic Regression and Decision Tree the
accuracy of all the modules is compared and the best module is selected based
on accuracy which is SVM
• EMI Calculator: A simple JavaScript implementation to calculate monthly Emi
of payments by the end user it assumes a standard EMI rates of 10 percent per
Annum

15
4.2 System Design

4.2.1 Use Case Diagram

A collection of use cases, actors, and their relationships are shown in use case diagrams.
They represent a system's use case perspective. A use case represents a certain system
functionality. The relationships between the functionalities and their internal/external
controllers are therefore described using a use case diagram.

In our system there are 3 main actors User, System and Admin the User has to Open
the Application and input all the necessary fields such as Income, Cibil Score, Email id
etc. after entering the data the ML model gives the results based on the provided data,
The task of preparing the document, generating applicant number and saving the data to
the database is done by the system, The administrative module/Actor can view all the
data stored in the database and a copy of the document is also sent to the Administrator.

16
4.2.2 Class Diagram

Class diagram is basically a graphical representation of the static view of the system and
represents different aspects of the application.

So, A collection of class diagrams represent the whole system. The name of the class
diagram should be meaningful to describe the aspect of the system. Each element and
their relationships should be identified in advance Responsibility (attributes and
methods) of each class should be clearly identified for each class minimum number of
properties should be specified and because, unnecessary properties will make the
diagram complicated. Use notes whenever required to describe some aspect of the
diagram and at the end of the drawing it should be understandable to the
developer/coder. Finally, before making the final version, the diagram should be drawn
on plain paper and reworked as many times as possible to make it correct.

17
4.2.3 Sequence Diagram

Sequence diagrams model the flow of logic within your system in a visual manner,
enabling you both to document and validate your logic, and are commonly used for
both analysis and design purposes. Sequence diagrams are the most popular UML
artifact for dynamic modeling, which focuses on identifying the behavior within your
system. Other dynamic modeling techniques include activity diagramming,
communication diagramming, timing diagramming, and interaction overview
diagramming. Sequence diagrams, along with class diagrams and physical data models
are in my opinion the most important design-level models for modern business
application development.

18
4.2.4 State Chart Diagram

A state diagram shows the behaviour of classes in response to external stimuli.

Specifically, A state diagram describes the behaviour of a single object in response to a
series of events in a system. Sometimes it's also known as a Harel state chart or a state
machine diagram. This UML diagram models the dynamic flow of control from state to
state of a particular object within a system.

In this diagram we can see how the data is transferred from state to state this data is
saved in the database where it can easily be accessed, State diagram helps to understand
all the different steps involved in the project and the data flow in the project.

19
4.2.5 Data Flow Diagram

A data flow diagram (DFD) maps out the flow of information for any process or system.
It uses defined symbols like rectangles, circles and arrows, plus short text labels, to
show data inputs, outputs, storage points and the routes between each destination. Data
flowcharts can range from simple, even hand-drawn process overviews, to in-depth,
multi-level DFDs that dig progressively deeper into how the data is handled. They can
be used to analyse an existing system or model a new one. Like all the best diagrams
and charts, a DFD can often visually “say” things that would be hard to explain in
words, and they work for both technical and nontechnical audiences, from developer to
CEO. That’s why DFDs remain so popular after all these years. While they work well
for data flow software and systems, they are less applicable nowadays to visualizing
interactive, real-time or database-oriented software or systems.

In our project Data flow diagram helps us to understand how different modules are
connected to each other and how Data is shared between all the modules.

20
 5. IMPLEMENTATION

5.1 Implementation
There are many steps in building the project so we divided them into different phases so
that the project can involve module separation and high productivity.
1. Choosing the required model after testing different models here we choose SVM
as it has an accuracy of around 88 percent.
2. User Authentication: In this step we verify admin panel, and all the successful
applications are displayed.
3. Sending Document this step is done via Google app Script, send mail function is
used to update and send the document.
4. Flask Web application in this module we check how to implement a front-end
app along with a Machine Learning model.

Machine Learning Model

This step involved identifying all the key factors that are essential in approval step,
Choose the right model and extract the model from the ipynb file, We tested different
Machine Learning models like SVM, XGBoost, Random Forest etc. we ended up using
SVM as it had an accuracy of around 88 percent after training and evaluating the model
we used Joblib package to extract the Machine Learning model into the disk and later
this extracted file will be used to run prediction in the Flask application, The training
dataset used was from Kaggle but for testing data we generated a new dataset using
Excel random function

21
Fig 5.1.1 Identifying important attributes

Fig 5.1.2 Correlation Matrix

22
User Authentication
1. In our Flask application, we set up a secret key. This key is used for securely
signing the session cookie.
2. Creating a route for handling login requests, typically using the HTTP POST
method. This route will be responsible for accepting the user credentials (e.g.,
username and password) from a form.
3. In the login route, we check the provided username and password against the
predefined credentials for your single user. If the credentials match, consider the
user authenticated.
4. Flask provides a session object that allows you to persist user information across
requests. After authenticating the user, store a session variable indicating that the
user is logged in.
5. There are specific routes or views that should only be accessible by
authenticated users, check the user's authentication status before allowing
access. Flask provides decorators like @login_required for this purpose.

Sending Document
We use Google Apps Script, To access the Script Editor, which is available in Google
Workspace applications. Open the application (e.g., Google Docs) to access the Script
Editor, In the Script Editor, create a new script.

Writing a function that will be responsible for sending the email. In this function,
you'll specify the recipient's email address, the subject of the email, the body of the
email, and attach the document to the email.

To send an email, we'll need to access the Gmail service using the GmailApp class in
Google Apps Script. This class provides methods for sending emails, We use Google
Apps Script to access and retrieve the document you want to send. You may need to
specify the document's ID or use other methods to identify and fetch the document.

23
Compose the email by specifying the recipient's email address, subject, and body.
Attach the document to the email using the appropriate method provided by the
GmailApp class, Use the sendEmail() method provided by the GmailApp class to send
the email. Ensure that you have the necessary permissions, and that the Gmail service is
properly configured.

Flask Application
All the above mentioned modules are combined together with Flask, Flask is a web
framework for python, In this application we used the flask built in SQLite database to
store all the user data, Its routing feature are useful to implement the user authentication
as discussed above, It can be used to send post request to our Google App Script code
so that it can have 2 different backends and error checking is present in both backends,
The machine learning model could be easily loaded in the flask application using Load
function, It uses Jinja templating to use reusability and python like features which was
helpful in loading and viewing the database right in front end with out external services,
It also helps in Data manipulation Unique user id generation, Flask offers the
convenience to load different modules in a single application and has strong library
support.

24
5.2 Sample code
App.py
from flask import Flask, render_template, request, redirect
from flask_sqlalchemy import SQLAlchemy
import joblib
import numpy as np
import uuid
import requests

# Load the trained machine learning model

model = joblib.load('model1.pkl')

# Initialize
app = Flask(__name__)

# SQLite database
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///loan_applications.db'

# SQLAlchemy instance
db = SQLAlchemy(app)

# Define loan application model

class LoanApplication(db.Model):
id = db.Column(db.Integer, primary_key=True)
application_number = db.Column(db.String(36), unique=True,
nullable=False)
name = db.Column(db.String(255), nullable=False)
email=db.Column(db.String(255),nullable=False)
gender = db.Column(db.String(255), nullable=False)
married = db.Column(db.String(255), nullable=False)
dependents = db.Column(db.Integer, nullable=False)
education = db.Column(db.String(255), nullable=False)
self_employed = db.Column(db.String(255), nullable=False)
applicant_income=db.Column(db.Integer, nullable=False)
coapplicant_income=db.Column(db.Float,nullable=False)
loan_amount=db.Column(db.Float,nullable=False)
loan_term=db.Column(db.Float,nullable=False)
credit_history=db.Column(db.String(255),nullable=False)
property_area=db.Column(db.String(255),nullable=False)

def __init__(self, application_number,

name,email,gender,married,dependents,education,self_employed,applicat_inc
ome,coapplicant_income,loan_amount,loan_term,credit_history,property_area
):

25
 self.application_number = application_number
self.name = name
self.email = email
self.gender = gender
self.married = married
self.dependents= dependents
self.education=education
self.self_employed=self_employed
self.applicant_income=applicat_income
self.coapplicant_income=coapplicant_income
self.loan_amount=loan_amount
self.loan_term=loan_term
self.credit_history=credit_history
self.property_area=property_area

# Create loan_applications table if it doesn't exist

with app.app_context():
db.create_all()

# home page route

@app.route('/')
def home():
return render_template('home.html')

@app.route('/form')
def data_submission():
return render_template('form.html')

@app.route('/emi')
def emi_calc():
return render_template('emi_calculator.html')

# Define a route for form submission

@app.route('/predict', methods=['POST'])
def predict():
try:
# Retrieve form data
name = request.form['name']
email = request.form['email']
gender = request.form['gender']
married = request.form['married']
dependents = int(request.form['dependents'])
education = request.form['education']
self_employed = request.form['self_employed']
applicant_income = int(request.form['applicant-income'])
coapplicant_income = float(request.form['coapplicant_income'])
loan_amount = float(request.form['loan_amount'])

26
 loan_term = float(request.form['loan_term'])
credit_history = request.form['credit_history']
property_area = request.form['property_area']

print(name)
print(email)

if gender == 'Male':
g_val=1
else:
g_val=0

if married == 'Yes':
mar_val=1
else:
mar_val=0

if self_employed == 'Yes':
se_val=1
else:
se_val=0

if education == 'Graduate':
e_val=1
else:
e_val=0

if property_area == 'Rural':
pa_val=0
elif property_area == 'Semi Urban':
pa_val=1
else:
pa_val=2

if credit_history=='Yes':
ch_val=1.0
else:
ch_val=0.0

# Make prediction using the machine learning model

input_data = (g_val, mar_val, dependents, e_val, se_val,
applicant_income, coapplicant_income, loan_amount, loan_term, ch_val,
pa_val)

input_data_as_numpy_array = np.asarray(input_data) # Changing

the input_data to a numpy array

27
 input_data_reshaped = input_data_as_numpy_array.reshape(1, -1) #
Reshape the array

prediction = model.predict(input_data_reshaped)

if prediction[0] == 0:
return render_template('success.html', prediction="Rejected",
name=name)
else:
# Generate a UUID for the loan application
application_number = str(uuid.uuid4())

data = {
'application_number': application_number,
'name': name,
'email': email,
'gender': gender,
'married': married,
'dependents': dependents,
'education': education,
'self_employed': self_employed,
'applicant_income': applicant_income,
'coapplicant_income': coapplicant_income,
'loan_amount': loan_amount,
'loan_term': loan_term,
'credit_history': credit_history
}

# print(data)
response =
requests.post('https://script.google.com/macros/s/zzCfiQRqdSQicg-
Q_2VretPhkitaA59loqYsWeaYIQzMAiQ-QD6ZV8t_mMvK_wq6lLrA/exec',data=data)

# Store the data in the database

save_loan_application(application_number, name, email,
gender, married, dependents, education, self_employed, applicant_income,
coapplicant_income, loan_amount, loan_term, credit_history,
property_area)

return render_template('success.html', prediction="Accepted",

application_number=application_number, name=name)

except (KeyError, ValueError) as e:

error_message = str(e)
return render_template('error.html', error_message=error_message)

except Exception as e:

28
 error_message = "An error occurred while processing your
request."
# debugging purposes
print("Error:", str(e))
return render_template('error.html', error_message=error_message)

# Save the loan application data to the database and return the
application number
def
save_loan_application(application_number,name,email,gender,married,depend
ents,education,self_employed,applicant_income,coapplicant_income,loan_amo
unt,loan_term,credit_history,property_area):

# Create a new LoanApplication object

loan_application =
LoanApplication(application_number=application_number, name=name,
email=email,gender=gender,married=married,dependents=dependents,education
=education,self_employed=self_employed,applicat_income=applicant_income,c
oapplicant_income=coapplicant_income,loan_amount=loan_amount,loan_term=lo
an_term,credit_history=credit_history,property_area=property_area)

# Add the loan application to the database session

db.session.add(loan_application)

# Commit the changes to the database

db.session.commit()

return application_number

# Define a route for authentication

@app.route('/auth', methods=['GET', 'POST'])
def auth():
if request.method == "POST":
password = request.form['password']
if password == 'secret': # Replace 'your_password' with the
actual password
print(password)
return redirect('/data')
else:
error_message = "Invalid password. Access denied."
return render_template('auth.html',
error_message=error_message)
return render_template('auth.html')

# Define a route to display all loan application data

29
@app.route('/data', methods=['GET','POST'])
def data():
loan_applications = LoanApplication.query.all()
return render_template('applications.html',
loan_applications=loan_applications)

# 404 errors
@app.errorhandler(404)
def not_found_error(error):
return render_template('error.html', error_message='Page not found'),
404

# 500 errors
@app.errorhandler(500)
def internal_error(error):
# debugging purposes
print("Error:", str(error))
return render_template('error.html', error_message='Internal server
error'), 500

# Run the Flask app

if __name__ == '__main__':
app.run(debug=True)

30
App.gs

function sendEmail(data) {
var recipient = data.email;
var subject = 'Prediction Result';
var templateDocId = '1ofA0aE_0HW20EguMsNR4'; // Replace with your
template document's ID
var folderId = '1E_Z-x_KvHYdaFuczJ'; // Replace with the folder's ID

// Log debugging information

console.log('Recipient: ' + recipient);
console.log('Subject: ' + subject);

// Create a new copy of the template document in the specified folder

var folder = DriveApp.getFolderById(folderId);
var templateDoc = DriveApp.getFileById(templateDocId);
var newDoc = templateDoc.makeCopy('Generated Document', folder);

// Access the body of the new document

var body = DocumentApp.openById(newDoc.getId()).getBody();

// Replace placeholders in the document with form data

body.replaceText('{{Input Field 1}}', data.application_number);
body.replaceText('{{Input Field 2}}', data.name);
body.replaceText('{{Input Field 3}}', data.gender);
body.replaceText('{{Input Field 4}}', data.married);
body.replaceText('{{Input Field 5}}', data.dependents);
body.replaceText('{{Input Field 6}}', data.education);
body.replaceText('{{Input Field 7}}', data.self_employed);
body.replaceText('{{Input Field 8}}', data.applicant_income);
body.replaceText('{{Input Field 9}}', data.coapplicant_income);
body.replaceText('{{Input Field 10}}', data.loan_amount);
body.replaceText('{{Input Field 11}}', data.loan_term);
body.replaceText('{{Input Field 12}}', data.credit_history);
// Add more placeholders and replacements for additional fields

// Log debugging information

console.log('Document ID: ' + newDoc.getId());

// Save the changes to the document

DocumentApp.openById(newDoc.getId()).saveAndClose();

// Convert the new document to PDF

var pdfBlob=
DriveApp.getFileById(newDoc.getId()).getAs('application/pdf');

// Log debugging information

31
 console.log('PDF Blob: ' + pdfBlob);

// Close the new document to save changes

newDoc.setTrashed(true);

// Create the HTML email body

var emailBody = `
<html>
<head>
<style>
/* Add your CSS styling here */
body {
font-family: Arial, sans-serif;
margin: 0;
padding: 20px;
background-color: #f4f4f4;
}
.container {
max-width: 600px;
margin: 0 auto;
padding: 20px;
background-color: #ffffff;
border-radius: 5px;
box-shadow: 0px 2px 4px rgba(0, 0, 0, 0.1);
}
h1 {
color: #3498db;
}
p {
color: #333333;
line-height: 1.6;
}
.footer {
margin-top: 20px;
color: #777777;
}
/* Add your CSS styles here */
</style>
</head>
<body>
<div class="container">
<h1>Prediction Result</h1>
<p><strong>Applicantion number:</strong>
${data.application_number}</p>
<p><strong>Name:</strong> ${data.name}</p>
</div>
</body>

32
 </html>
`;

// Log debugging information

console.log('Email Body: ' + emailBody);

// Send the email with HTML content and attach the PDF
MailApp.sendEmail({
to: recipient,
subject: subject,
htmlBody: emailBody,
attachments: [pdfBlob]
});

// Return a success response

return ContentService.createTextOutput('Email sent successfully');
}

// This function is the entry point for the web app

function doPost(e) {
var formData = e.parameter;
return sendEmail(formData);
}

33
 6. TESTING

6.1 Testing
The purpose of testing is to discover errors. Testing is a process of trying to discover every
conceivable fault or weakness in a work product. It provides a way to check the functionality of
components, sub-assemblies, assemblies and/or a finished product. It is the process of
exercising software with the intent of ensuring that the software system meets its requirements
and user expectations and does not fail in an unacceptable manner. Software testing is an
important element of software quality assurance and represents the ultimate review of
specification, design and coding. The increasing feasibility of software as a system and the cost
associated with the software failures are motivated forces for well-planned through testing.

6.2 Test cases

Experiments include an arrangement of steps, conditions and sources of info that can be
utilized while performing testing undertakings. The principal expectation of this action
is to guarantee whether a product passes or bombs as far as usefulness and different
perspectives. The way toward creating experiments can likewise help discover issues in
the prerequisites or plan of an application. Experiment goes about as the beginning
stage for the test execution, and in the wake of applying an arrangement of information
esteems, the application has a conclusive result and leaves the framework at some end
point or otherwise called execution post condition.

34
 Test Text Case Step to Expected Actual Result Result
Case ID Description Execute Result
Check for Call the Loaded Libraries Pass
01
Libraries libraries Libraries Loaded
02 Path Finding Dataset to Dataset Dataset Pass
Console Loaded Loaded
03 Loading Model Initialized Loaded Loaded Model Pass
training Model without errors
model and without
load it into errors
ON
04 Loading Flask Run Flask run Generate Generated Pass
in command URL for URL for
prompt application application
05 Loading Fill Data viewed Data viewed Pass
Dataset Application successfully Successfully in
with testing in Admin Admin Module
Information Module
06 Filling Fill the Error, there Error, there is Pass
Incorrect data Application is an error in an error in
with wrong provided provided
info information information
please check please check
07 Sending Submit Mail sent Mail sent Pass
Document correct data successfully Successfully
08 Sending Send POST Success Success Pass
Request request to the
API

35
 7. OUTPUT SCREENS
Application Page

Fig 7.1 Application page

36
Result Screen

Fig 7.2 Result Screen

Fig 7.3 Email Screen

37
Emi Calculator

Fig 7.4 EMI Calculator

Admin login

Fig 7.5 Admin login

38
Applications Database

Fig 7.6 Database User Interface

39
 8. CONCLUSION

8.1 Conclusion
The analytical process started from data cleaning and processing, Missing value
imputation with mice package, then exploratory analysis and finally model building and
evaluation. The best accuracy on public test set is 0.811. This brings some of the
following insights into approval. Applicants with Credit history not passing fail to get
approved, probably because they have a probability of not paying back. Most of the
Time, Applicants with high income sanctioning low amount is to more likely get
approved which make sense, more likely to pay back their loans. Some basic
characteristics of gender and marital status seem not to be taken into consideration by
the company.

The software works perfectly and can be used for all banking requirements. This system
can be easily uploaded to any operating system. Since technology is moving towards
online, this system has more scope for the upcoming days. This system is more secure
and dependable. Since we have used Random Forest Algorithm the system returns
accurate results. There is no issue if there are many nos of customers applying for loan.
This system accepts data for N no. of customers. In future we can add more algorithms
to this system to get more accurate results.
The analytical process started from data cleaning and processing, missing value,
exploratory analysis and finally model building and evaluation. The best accuracy on
public test set is higher accuracy score will be found out. This application can help to
find the Prediction of Bank Loan Approval.

8.2 Further Enhancements

• Bank Loan Approval prediction to connect with cloud.

• To optimize the work to implement in Artificial Intelligence environment.

40
 9. BIBLIOGRAPHY

9.1 Books References

1. Amruta S. Aphale, Dr. Sandeep R. Shinde, 2020, Predict Loan Approval in
Banking System Machine Learning Approach for Cooperative Banks Loan
Approval, International Journal Of Engineering Research & Technology (IJERT)
Volume 09, Issue 08 (August 2020)
2. Ashwini S. Kadam, Shraddha R. Nikam, Ankita A. Aher, Gayatri V. Shelke,
Amar S. Chandgude, “Prediction for Loan Approval using Machine Learning
Algorithm” (IRJET) Volume: 08 Issue: 04 | Apr 2021.
3. [3] M. A. Sheikh, A. K. Goel and T. Kumar, "An Approach for Prediction of
Loan Approval using Machine Learning Algorithm," 2020 International
Conference on Electronics and Sustainable Communication Systems (ICESC),
2020, pp. 490- 494, doi: 10.1109/ICESC48915.2020.9155614.
4. [4] Rath, Golak & Das, Debasish & Acharya, Biswaranjan. (2021). Modern
Approach for Loan Sanctioning in Banks Using Machine Learning. Pages={179-
188} 10.1007/978-981-15-5243-4_15.
5. ]Vincenzo Moscato, Antonio Picariello, Giancarlo Sperlí, A benchmark of
machine learning approaches for credit score prediction, Expert Systems with
Applications, Volume 165, 2021, 113986, ISSN 0957-4174.
6. Yash Divate, Prashant Rana, Pratik Chavan, “Loan Approval Prediction Using
Machine Learning” International Research Journal of Engineering and
Technology (IRJET) Volume: 08 Issue: 05 | May 2021

41
9.2 Websites References
1. https://www.geeksforgeeks.org/flask-tutorial/
2. https://www.scnsoft.com/lending/loan-processing-
automation#:~:text=Automated%20loan%20processing%20software%20relies,e
rror%2Dprone%20manual%20le nding%20tasks.
3. https://www.sqlite.org/index.html
4. https://flask-sqlalchemy.palletsprojects.com/en/3.0.x/
5. https://jinja.palletsprojects.com/en/3.1.x/
6. https://www.irjet.net/archives/V8/i4/IRJET-V8I4785.pdf
7. https://www.irjet.net/archives/V8/i1/IRJET-V8I1279.pdf

42
 10 . APPENDICES

10.1 Software Used

FLASK
Python-based Flask is a microweb framework. Because it doesn't require any. specific
tools or libraries, it is categorized as a microframework. It lacks any components. where
pre-existing third-party libraries already provide common functions, such as a database
abstraction layer, form validation, or other components. But Flask allows for extensions
that may be used to add application functionalities just like they were built into. 4344
the core of Flask. There are extensions for object relational mappers, form validation,
upload handling, several open authentication protocols, and a number of utilities
associated with popular frameworks.

HTML
The Hypertext Markup Language or HTML is the standard markup language for
documents designed to be displayed in a web browser. It defines the meaning and
structure of web content. It is often assisted by technologies such as Cascading Style
Sheets (CSS) and scripting languages such as JavaScript.

Web browsers receive HTML documents from a web server or from local storage
and render the documents into multimedia web pages. HTML describes the structure of
a web page semantically and originally included cues for its appearance.

HTML elements are the building blocks of HTML pages. With HTML constructs,
images and other objects such as interactive forms may be embedded into the rendered
page. HTML provides a means to create structured documents by denoting structural
semantics for text such as headings, paragraphs, lists, links, quotes, and other items.
HTML elements are delineated by tags, written using angle brackets.

43
AppScript
Google Apps Script is a scripting platform developed by Google for light-weight
application development in the Google Workspace platform. Google Apps Script was
initially developed by Mike Harm as a side project while working as a developer on
Google Sheets.

Google Apps Script was first publicly announced in May 2009 when a beta testing
program was announced by Jonathan Rochelle, then Product Manager for Google Docs,
In August 2009 Google Apps Script was subsequently made available to all Google
Apps Premier and Education Edition customers, It is based on JavaScript 1.6, but also
includes some portions of 1.7 and 1.8 and a subset of the ECMAScript 5 API, Apps
Script projects run server-side on Google's infrastructure. According to Google, Apps
Script It provides easy ways to automate tasks across Google products and third-party
services.

44
10.2 Methodologies used

Agile Methodology
Agile is an iterative and incremental software development methodology that
emphasizes flexibility, collaboration, and customer satisfaction. It prioritizes delivering
a working product in small, manageable increments, allowing for continuous feedback
and adaptation throughout the development process. The Agile Manifesto, created in
2001 by a group of software developers, outlines the core values and principles of the
Agile approach.
Key Principles and Concepts:
• Individuals and Interactions Over Processes and Tools:
• Agile values effective communication and collaboration among team members.
It emphasizes the importance of people working together to achieve project
goals.
• Working Software Over Comprehensive Documentation:
• While documentation is essential, Agile places a higher value on delivering
functional software. The focus is on providing tangible value to the customer in
each development iteration.
• Responding to Change Over Following a Plan:
• Agile recognizes that requirements are likely to change, and it embraces changes
even late in the development process. The ability to respond to evolving
requirements is a crucial aspect of Agile methodologies.

Feature Driven Development

Feature-Driven Development (FDD) is an iterative and incremental software
development methodology that focuses on building software features and delivering
tangible, working results. FDD was developed by Jeff De Luca and Peter Coad and is
designed to be adaptable to a variety of project sizes and types. It emphasizes
collaboration, domain modeling, and frequent client interactions.

45
Key Principles and Concepts:
• FDD organizes the development process around features, which are small,
client-valued functions. Each feature is designed, implemented, and tested
independently.
• FDD places a strong emphasis on domain modeling to understand the business
domain and represent it in a way that can be easily translated into software. The
model is continuously refined as features are developed.
• FDD follows an iterative and incremental approach. The development is done in
short iterations, and after each iteration, a set of features is delivered to the
client. This incremental delivery helps manage complexity and allows for
flexibility in responding to changing requirements.
• The development process begins with creating a comprehensive feature list
based on the project requirements. Features are then prioritized, and
development efforts are focused on implementing and delivering these features.
• FDD introduces the role of the Chief Programmer, who is responsible for
overseeing the overall technical integrity of the project. The Chief Programmer
works closely with the team to ensure that coding standards and best practices
are followed.

46
10.3 Testing Methods used

1. Unit testing
Unit testing is a software testing method where individual components or functions of a
software application are tested in isolation. The goal is to verify that each unit of the
software performs as designed. A unit in this context is the smallest testable part of an
application, typically a function, method, or procedure.

Key Concepts:
• Isolation: Unit tests are designed to be isolated, meaning they focus on testing a
specific unit without relying on external dependencies. Mock objects or stubs
may be used to simulate interactions with external components.
• Automated: Unit tests are often automated to ensure efficiency and repeatability.
Automated testing frameworks, such as JUnit for Java or pytest for Python, are
commonly used for writing and executing unit tests.
• Fast Execution: Unit tests should be quick to execute, allowing developers to run
them frequently during the development process. Fast execution enables rapid
feedback on code changes.

2. Integration Testing
Integration testing is a software testing method that focuses on verifying the interactions
between different components or systems within an application. The goal is to ensure
that these components work together as intended and that integrated units of the
software function correctly.
Key Concepts:
• Interaction Testing: Integration testing checks for proper communication and
data flow between different parts of the system, such as modules, classes, or
services.
• Top-Down or Bottom-Up Approaches: Integration testing can be performed
using a top-down or bottom-up approach. Top-down testing starts with higher-
level modules, while bottom-up testing begins with lower-level units.

47
 11. PLAGIARISM REPORT

GitHub Link: https://github.com/Pranay-03/Bank-Loan-Automation

48