VIKRANT UNIVERSITY

Minor Project report On

Banking System Project

Submitted to
School of Engineering and Technology
IN PARTIAL FULFILLMENT
OF THE DEGREE OF

Bachelor of Technology in Computer Science and

Engineering
Batch(2022-2025)
SESSION(2024-25)
BY

Name: Satyam Paliya

Roll No.:01ECSB003
Enrollment No. : VU20220158

Under the Supervision of

Guide name : Mr. Dharmendra Sharma
Asst. Prof. Department of CSE
Vikrant University
 Vikrant University, Gwalior (M.P)

“CERTIFICATE”

This is to certify that the project titled “Banking system” is a Bonafide

work carried out by. Satyam Paliya(01ECSB003), a student of
Vikrant University, under the guidance of Prof. Dharmendra
Sharma, Department of Computer Science and Engineering.
This project has been submitted in partial fulfilment of the requirements
for the award of the degree.

Date 07/05/2025
Guide:
DR. Shashank swami Prof. Dharmendra Sharma
HOD OF CSE Department of CSE
Vikrant University Vikrant University
 Vikrant University, Gwalior (M.P)

“DECLARATION CERTIFICATE”

I, Satyam Paliya, student of Vikrant University, hereby declare that

the project work entitled “Banking System” is an original work done
by me under the guidance of Prof. Dharmendra Sharma, Department
of Computer Science and Engineering.
This work has not been submitted elsewhere for the award of any other
degree or diploma.
Place:
Vikrant University

Date: ____________
Signature:
Satyam Paliya(01ECSB003)
 Acknowledgment
I would like to express my sincere gratitude to all those who have
supported me throughout the completion of this project, “Banking
System.”
First and foremost, I would like to thank Prof. Dharmendra Sharma,
Department of Computer Science and Engineering, Vikrant
University, for his invaluable guidance, encouragement, and
continuous support. His expert advice and insightful feedback greatly
enhanced the quality of this project.
I also extend my heartfelt thanks to the faculty members of the CSE
Department for providing the necessary facilities and resources during
the course of this project.
My deepest appreciation goes to my family and friends for their moral
support, constant motivation, and encouragement throughout the
project journey.
Lastly, I would like to thank Vikrant University for providing a
learning environment that encouraged innovation and practical
application of theoretical concepts.
Satyam Paliya
Student, CSE
Vikrant University
 INDEX
Page
S. No. Section Title Sub-sections (if any)
No.

Abstract

1.1 Project Overview

Introduction 1.2 Problem Statement
1.
1.3 Background & Scope
2.1Goals of the System
2. Objective
2.2Real-world Applications

3.1Hardware Requirements
3. System Requirements
3.2Software Requirements

4.1 Frontend
4.2 Backend
4. Technologies Used
4.3 Database
4.4 Tools & Platforms

5. Software Development Life Cycle 5.1 Iterative Model

6.1 System Flow

6. System Design & Architecture
6.2 Architecture Diagram

7.1 Booking System

7. Functional Modules 7.2 Payment Module
7.3 Admin Controls

8.1. Entity-Relationship Diagram

8. Database Design
8.2 Tables Overview

9.1 Unit Testing

9. Testing
9.2 Integration Testing

10.1 Customer Role

10. User Roles
10.2 Admin Role

11. Implementation 11.1Screen Shot

12. Conclusion 12.1 Summary

13. Future Enhancements 13.1 Planned Features

14. References References

 Abstract
The Banking System is designed to streamline the core
operations of a financial institution by automating and
managing essential tasks such as account creation,
deposits, withdrawals, balance inquiries, fund transfers,
and transaction tracking. This system provides a secure
and intuitive interface for both users and administrators,
enhancing operational efficiency, customer service, and
data integrity. The primary objective is to reduce
manual intervention, ensure secure access, and offer
real-time visibility into banking operations.
The system features modules for managing user
accounts, validating transactions, recording activities,
and generating reports. A secure authentication
mechanism ensures that only authorized users can
perform operations. The integrated database maintains
records of users, accounts, and all transaction histories,
allowing for traceability and auditing. Additionally, the
administrative panel offers tools to oversee all
activities, manage data, and ensure regulatory
compliance.
By delivering a complete digital solution, the Banking
System not only facilitates efficient day-to-day financial
operations but also improves decision-making,
strengthens data security, and contributes to the
scalability and reliability of digital financial services.
 Chapter - 1
Introduction
1.1 Project Overview -:
The GrowBank Banking System is a desktop-based application designed to simplify and
automate fundamental banking operations. It enables secure handling of account creation, user
authentication, deposits, withdrawals, transaction history tracking, and administrative controls.
The system provides an intuitive interface for both customers and administrators to manage
financial activities efficiently and reliably.
The project is developed using Python for the core logic and PyQt5 for the graphical user
interface, while SQLite serves as the backend database for data storage and management. This
technology stack ensures a lightweight, fast, and user-friendly environment, capable of
delivering essential banking functions with a focus on security, data integrity, and ease of use..

1.2 Problem Statement-:

In the traditional banking model, many fundamental operations such as cash deposits,
withdrawals, transaction tracking, and customer account handling are either manually managed
or require physical presence at a bank branch. This creates inefficiencies, increases human
error, and limits accessibility, especially for users who seek quick and secure access to banking
services.

• Key Challenges in Existing Manual or Semi-Automated Systems:

• Lack of Instant Access: Users cannot access account information or perform
transactions outside banking hours.
• Security Risks: Manual handling of account information increases the chances
of data breaches or unauthorized access.
• Data Inconsistency: Without centralized tracking, transaction records can be
lost or mishandled.
• Limited Transparency: Customers may not have real-time visibility into their
balances or transaction history.
• Dependency on Bank Staff: Basic services like balance inquiries or fund
transfers require in-person interactions.

These issues highlight the need for a secure, efficient, and user-centric digital banking
platform that operates independently of physical constraints.
1.3 Background & Scope-:
In traditional hotel management, most tasks are handled manually, leading to inefficiencies,
delays, and human errors. With the growing demand for digital transformation, this system
aims to digitize hotel operations, improve customer satisfaction, and enhance business
productivity.
The scope of this project includes:
• Online room booking and reservation management.
• Real-time availability tracking.
• Admin dashboard for room and user control.
• Secure billing and payment module.
• Role-based access for admin and users.
This system is ideal for small to medium-sized hotels and can be further enhanced to support
multiple branches, mobile platforms, and integration with third-party APIs such as online
payment gateways and SMS/email notification systems.

Chapter – 2
Objective
The primary objective of the GrowBank Banking System is to develop a secure,
user-friendly, and functional application that simulates core banking operations.
This project aims to demonstrate how digital tools can streamline financial
services while ensuring data security and ease of use for both users and
administrators.

2.1 Goals of the System -:

1. Automation of Banking Operations: To replace traditional manual banking activities such
as deposits, withdrawals, and transaction recording with a fully automated desktop application.
2. Real-Time Transaction Handling: To allow users to perform and track financial operations
in real-time with instant updates to the database.
3. Secure User Authentication: To implement OTP-based login and credential verification
for both users and admins, ensuring only authorized access.
[Link]-Based Navigation: To provide a simple and intuitive dashboard that allows
users to manage their financial activities efficiently.
[Link] and Donation Modules: To simulate real-world banking add-ons like SIP
(Systematic Investment Plans) and charity donations, enhancing educational value.
 [Link] Monitoring Tools: To enable admin users to view transactions, manage SIP
enrollment, monitor donations, and maintain overall system oversight.
[Link] Integrity and History Tracking: To ensure that all transactions are logged correctly
and can be audited or reviewed through a dedicated history module.

2.2 Real-World Applications -:

[Link] Use: Ideal for students and institutions to demonstrate banking system concepts
and OOP-based GUI applications.
[Link] Prototypes: Serves as a base model for developing more advanced systems,
including mobile or online banking services.
[Link]-Controlled Finance Apps: Useful for small organizations or clubs to simulate fund
management, user contributions, and reporting.
[Link] Literacy Tools: Can be used to teach personal finance management, investment
planning, and secure online banking practices.

Chapter – 3
System Requirements
This section outlines the hardware and software specifications necessary to develop, deploy,
and run the Hotel Management System efficiently.

3.1 Hardware Requirements:-

Component Specification
Intel Core i3 or higher (or AMD equivalent); for
Processor
better performance, Core i5/i7 is recommended.

Minimum 4 GB (8 GB or more preferred for smoother

RAM
multitasking during development).

At least 500 MB of free disk space for source code,

Storage
database, Python environment and software setup.

Minimum 1024×768 resolution; higher resolutions

Display
provide better UI experience.

Input Devices Standard keyboard and mouse for user interaction

3.2 Software Requirements-:
Software Component Details
Windows 10/11, Linux (Ubuntu), or
Operating System
macOS
Python 3.x – used for backend logic and
Programming Languages
GUI handling
PyQt5- for creating interactive and
GUI Framework
visually appealing desktop interfaces
SQLite- lightweight relational database
Database
embedded in python via sqlite3
Visual Studio Code, Pycharm or any
IDE/Editor
pyhthon-compatible code editor
Pyinstaller- for compiling the project into
Packaging Tool
an executable (.exe) file
Image viewer or web browser to view
Graphics Viewer
generated reports and diagrams

Chapter - 4
Technologies Used
The GrowBank system is built using a combination of backend logic, graphical
user interface tools, and database technologies. Each component plays a vital
role in ensuring that the application is functional, secure, and easy to use.

4.1 Frontend Technologies-:

1. PyQt5 (Python Qt GUI Library): A powerful Python binding for the Qt
application framework used to design the graphical user interface. It enables the
creation of interactive windows, buttons, labels, and forms used throughout the
application.
2. QSS (Qt Style Sheets): Styling features within PyQt5 are handled using QSS, which
functions similarly to CSS. It allows for customization of colors, fonts, and layouts to maintain
a professional and modern appearance.

4.2Backend Technologies
1. Python 3.x: Python is the core programming language used in the project. It
provides flexibility, readability, and powerful libraries that help handle backend
logic, data processing, and GUI management.
2. Built-in Python Libraries:
• sqlite3: Enables seamless communication between the Python application and
the SQLite database.
• random: Used for OTP generation and simple numeric logic.
• datetime: Tracks timestamps of transactions.
• os: Facilitates system-level operations like launching files or handling paths.

4.3 Database Technology

1. Visual Studio Code / PyCharm: Used for writing, debugging, and managing
the Python source code. Supports syntax highlighting, terminal commands, and
plugin integration.
2. PyInstaller: A packaging tool that converts the Python code into a standalone
.exe executable for easy distribution and installation.
3. Windows OS / File Explorer:The GrowBank application is tested primarily
on Windows and supports desktop file navigation.
4. [Link] / Lucidchart (optional): For creating diagrams such as the Use Case
Diagram, Class Diagram, and Activity Flowcharts

.4.4 Development & Utility Tools:-

1. Visual Studio Code / PyCharm: Used for writing, debugging, and
managing the Python source code. Supports syntax highlighting,
terminal commands, and plugin integration.
2. PyInstaller: A packaging tool that converts the Python code into a
standalone .exe executable for easy distribution and installation.
3. Windows OS / File Explorer: The GrowBank application is tested
primarily on Windows and supports desktop file navigation.
4. [Link] / Lucidchart (optional): For creating diagrams such as the
Use Case Diagram, Class Diagram, and Activity Flowcharts.

.
 Chapter - 5
Software Development Life Cycle
The Software Development Life Cycle (SDLC) provides a structured framework for designing,
developing, testing, and maintaining software applications. The GrowBank system follows the
Iterative Model, where the application is built in cycles, with each iteration adding new
functionalities and refinements based on testing feedback.

5.1 Water full Iterative Model-:

In the Iterative model in SDLC, each cycle results in a semi-developed but deployable version;
with each cycle, some requirements are added to the software, and the final cycle results in the
software with the complete requirement specification

1. Requirement Analysis
• Identified key banking features such as user login, account
management, transaction tracking, and admin control.
• Considered both functional requirements (e.g., deposit/withdrawal)
and non-functional needs (e.g., security, usability).
2. System Design
• Designed modular components such as [Link], [Link],
[Link], and admin_panel.py.
• Defined database structure in [Link] using SQLite tables for
users, transactions, SIPs, and donations.
• Diagrams (Use Case, Class Diagram) were created to visualize flow
and structure.
3. Implementation (Coding)
• Developed the application using Python 3.x and PyQt5.
• Separated code into logical modules for better organization and
debugging.
• Used SQLite for lightweight, embedded database operations.
• PyInstaller was used to convert the Python files into a .exe application.
4. Testing
• Conducted unit testing for each module (e.g., login, transaction).
• Performed integration testing to ensure smooth communication
between components.
• Verified data integrity in the SQLite database after each transaction.
5. Deployment
• Final executable file created using PyInstaller.
• The application can be distributed and run independently on any
compatible Windows system without requiring Python to be pre-
installed.
6. Maintenance
• The project is structured for easy feature updates, bug fixes, and future
enhancements.
• New modules like multi-user login, two-factor authentication, or
online database integration can be added later.
 Chapter - 6
System Design & Architecture
This chapter explains how the Growbank application is structured, how its components interact,
and how data flows through the system.

6.1System Flow-:
1. Application Launch
• the user starts the executable ([Link]).
• A Splash / Login Window built with PyQt5 is displayed.
2. Authentication Layer
• Signup – new users create an account; credentials are stored in Users table in [Link].
• Login – existing users enter username and request a one‑time password (OTP).
• OTP is generated in [Link] and verified before access is granted.
• Admin Login – separate credentials verified against Admin table.
3. Dashboard Navigation
• After successful login, [Link] loads:
• Account Summary – current balance and last 5 transactions.
• Buttons for Deposit, Withdrawal, SIP, Donate, View History, Logout.
4. Transaction Processing
• User chooses Deposit or Withdrawal.
• Amount is validated; on success, a record is inserted into Transactions table with type,
amount, date‑time.
• Balance is recalculated and displayed instantly.
5. Value‑Added Modules
• SIP Plan – available only if user age ≥ 18; details stored in SIP table.
• Child Fund Donation – amount is moved to Donations table; running total visible to admin.
6. Admin Panel (admin_dashboard.py)
• View all users, search by username, reset passwords.
• Monitor complete transaction log, active SIP plans, donation ledger.
• Export tables to CSV for audit purposes.
7. Logout / Exit • User session variables are cleared; the login window reappears or the
application closes.
6.2 Architecture Diagram

6.3 Use‑Case Diagram -:

Provide a graphic that shows:
• Customer → Sign Up, Login, Deposit, Withdraw, View History, Start SIP,
Donate.
• Admin → Login, View Users, View Transactions, Manage SIP,
View Donations, Reset Password.
6.4 Class Diagram -:
Classes and key relationships:
Class Key Attributes Key Methods
User deposit(), withdraw(),
id, name, age, balance view_history()
Admin(User) privileges reset_password(), export_csv()

Transaction
txn_id, user_id, amount, type,
(constructor only)
date
SIP
sip_id, user_id, monthly_amt,
start_sip(), calculate_maturity()
tenure
DatabaseManager connection execute_query(), fetch_records()

6.5 Sequence Diagram -: “Deposit Flow” (example)

1. User clicks Deposit
2. Dashboard → DepositWindow (opens)
3. DepositWindow → DatabaseManager.execute_query() (INSERT)
4. DatabaseManager → SQLite (commit)
5. Balance returned to DepositWindow → Dashboard → UI refreshed.
Narrative Summary
The GrowBank architecture follows a clear MVC-like separation:

• View (GUI) – PyQt5 windows and dialogs.

• Controller (Logic) – Python classes handling events, validations,
business rules.
• Model (Data) – SQLite tables accessed through a lightweight
DatabaseManager.

This layered design promotes maintainability, testability, and easy future

upgrades (e.g., switching SQLite to a remote MySQL server or integrating
additional security like 2-FA).

Chapter – 7
Functional Modules
The GrowBank system is divided into clear functional modules, each designed to execute a
specific banking operation. These modules interact with the [Link] SQLite database and
provide a user-friendly GUI built with PyQt5

7.1 User Management Module

Purpose:
To handle user registration, authentication, and account management.

Functionality:

• [Link]: Allows new users to register with username, password, phone number, and
account type (e.g., Savings).
• [Link]: Manages login using OTP verification sent during the session.
• User credentials and initial balance are saved in the users table.

DatabaseFields:
users(id, username, password, balance, account_type, phone)

7.2 Admin Authentication Module

Purpose:
To grant administrative access to approved staff.

Functionality:
 • admin_login.py: Validates login against credentials stored in the admin table.
• Admin users can then access the admin_dashboard.py.

DatabaseFields:
admin(id, username, password)

7.3 Deposit Module

Purpose:
To allow users to deposit funds into their account.

Functionality:

• [Link]: Users enter the amount to deposit.

• Balance is updated in the users table.
• A transaction is recorded in the transactions table with type 'Deposit'.

Database Fields Used:

• [Link] updated
• transactions(username, type, amount, date, account_type) inserted

7.4 Withdrawal Module

Purpose:
To let users withdraw funds with balance checks.

Functionality:

• [Link]: Accepts user input for withdrawal.

• Verifies if the balance is sufficient.
• Updates balance and logs the withdrawal in transactions.

Validation:
No overdraft allowed. Negative balances are prevented at logic level.

7.5 Transaction History Module

Purpose:
To give users visibility into their financial activities.

Functionality:

• view_transactions.py: Fetches all deposits and withdrawals for the logged-in user.
• Displayed chronologically in the dashboard.

DatabaseTable:
transactions
7.6 Dashboard Module

Purpose:
To serve as the central hub after login.

Functionality:

• [Link]: Launches the main user interface with buttons for deposit, withdrawal,
transaction history, SIP, donations, and logout.
• Displays real-time balance fetched from the database.

7.7 SIP Plan Module

Purpose:
To simulate a Systematic Investment Plan for eligible users.

Functionality:

• Age is set using the user profile (handled in [Link]).

• SIP can be initiated with a fixed amount and tenure.
• SIP status is stored in memory or optionally written to database (not present in current
schema, but shown in UI logic).

7.8 Child Fund Donation Module

Purpose:
To allow users to donate to a shared child support fund.

Functionality:

• User enters a donation amount.

• Deducted from their balance and shown in the admin dashboard summary.
• Tracked via dictionary or in-memory structure (no dedicated table in DB, optional for
future).

7.9 Admin Dashboard Module

Purpose:
To allow admin users to monitor and manage all banking operations.

Functionality:
 • admin_dashboard.py: Admin can view all registered users, transaction history, total
donations, and SIP participations.
• Admin can reset user passwords via an interface.

This structure ensures each banking operation is handled securely and modularly using a
combination of GUI elements and SQLite database calls.

Chapter – 8
Database Design:-
The database is the backbone of the GrowBank Banking System. It ensures all user data,
transactions, and administrative records are stored securely and efficiently. GrowBank uses
SQLite, a lightweight embedded database, accessed using Python’s built-in sqlite3 module.

[Link]-Relationship (ER) Diagram:-

The GrowBank system is centered around three key entities:

1. Users
2. Transactions
3. Admin

Entity Relationships:

• Each User can perform multiple Transactions.

• Each Admin can access and manage all Users and their Transactions.
• Relationships are one-to-many from Users → Transactions.

8.2. Tables Overview:-

[Link] Table-:

Field Name Data Type Description

id INTEGER Primary key (auto-increment)
username TEXT Unique identifier for each user
password TEXT Encrypted/hashed password string
 Field Name Data Type Description
balance REAL Current account balance
account_type TEXT Type of account (e.g., 'Savings')
phone TEXT User’s phone number (for OTP purposes)

[Link] table-:
Field Name Data Type Description
id INTEGER Primary key (auto-increment)
username TEXT Foreign key referencing [Link]
type TEXT Type of transaction (Deposit/Withdraw)
amount REAL Amount involved in the transaction
date TEXT Timestamp of the transaction
account_type TEXT Same as user's account type

[Link] Table-:

Field Name Data Type Description

id INTEGER Primary key (auto-increment)

username TEXT Admin’s login name

password TEXT Admin password

8.3 Data Handling-;

• All transactions are logged in real-time to the transactions table.
• The balance field in the users table is updated dynamically upon each deposit or
withdrawal.
• Login credentials are validated using simple SQL SELECT queries with sanitized
input.
• Admins access backend features without modifying records directly unless necessary.
 Chapter – 9
Testing
The GrowBank system was tested through both manual GUI interaction and code-level
validation. Each Python module was individually verified for correct functionality and
combined for integration testing. Since the project is GUI-based using PyQt5, the primary
method of testing was interactive usage testing backed by SQLite database queries.

9.1 Unit Testing(BasedonActual Modules)-:

Module Test Scenario Expected Outcome Result

[Link]
OTP is generated and compared Access granted if OTP
Pass
with user input matches

[Link]
User blocked from
Incorrect OTP is entered Pass
proceeding

reset_password.py
Matching phone number and Password updated in
Pass
username provided database

[Link]
Create account with unique New user added to users
Pass
username table

[Link]
Buttons trigger deposit, withdraw,
Correct windows open Pass
transaction windows

[Link]
Balance updated,
Valid numeric amount entered Pass
transaction logged

[Link]
Success and new balance
Withdraw amount less than balance Pass
shown

[Link]
Error shown, transaction
Withdraw amount exceeds balance Pass
not allowed

view_transactions.py
Chronological list is
User views past transactions Pass
displayed

[Link] Testing-:
Testing of how all modules interact together within the running EXE ([Link]):

Test Case Steps Expected Result Result

Signup → Login with OTP → Deposit All features function in

Full user cycle Pass
→ Withdraw → View transactions order

Invalid login Enter wrong OTP Login fails Pass

 Test Case Steps Expected Result Result

Transaction Entries appear in

Perform deposit and withdrawal Pass
logging transactions table

SIP & donation Actions logged or reflected

Trigger SIP or donation from dashboard Pass
features in admin panel

Admin Admin login → view user accounts and Admin panel displays
Pass
operations transactions correct data

Testing Methodology
• Manual GUI Testing via PyQt5 windows.
• Database Verification through direct inspection of [Link].
Code-level input validation (especially in [Link], [Link], and reset_password.py)
ensures robustness.

Chapter – 10
User Roles
The GrowBank application defines two primary roles within the system: User and
Admin. Each role has specific access levels, responsibilities, and interface experiences.
This role-based approach ensures proper authorization, data security, and controlled
access to banking functionalities.

10.1 Regular User Role

Access Rights:

• Sign up and create a new banking account

• Login using username and OTP
• Perform secure transactions (deposit and withdraw)
• View transaction history
• Participate in SIP (Systematic Investment Plan) if eligible
• Donate to the child fund

Interface:
Upon login, users are redirected to the Dashboard ([Link]) which
provides buttons for each available action. The user can only access and view
their own data.

Limitations:

• Cannot view other users' data

• Cannot access or modify system records
• Cannot view SIP or donation summaries beyond their own

10.2 Admin Role

Access Rights:

• Login using a secure admin portal (admin_login.py)

• View a list of all registered users
• Monitor all transactions performed across the system
• Access SIP participation details
• View and track donations
• Reset user passwords (via admin_dashboard.py)

Interface:
After successful login, the admin is directed to the Admin Dashboard, where
they have access to management panels and real-time database insights.

Privileges:

• Read-only access to all user and transaction data

• Control over password recovery and account integrity
• High-level visibility for auditing and tracking system performance

10.3 Role Summary Table

Functionality User Admin

Sign Up / Login Yes Yes (Admin only)

 Functionality User Admin

Deposit / Withdraw Yes No

View Personal History Yes Yes (All users)

Manage SIP / Donate Yes View only

View All Users No Yes

Reset Passwords No Yes

Access Admin Panel No Yes

Chapter – 11
Future Enhancements
Although the GrowBank Banking System fulfills its current objectives effectively, there are
several areas where the application can be expanded or improved. These enhancements would
further increase usability, scalability, and security, making it suitable for larger-scale or real-
world applications.

11.1 GUI Improvements

• Responsive Layout: Adjust GUI layout to adapt to different screen sizes or
resolutions.
• Dark Mode / Themes: Allow users to toggle between light and dark interface
themes.
• Multi-language Support: Add localization features to support regional languages.

11.2 Security Enhancements

• Hashed Passwords: Replace plain-text passwords in the database with secure
hashing algorithms (e.g., SHA256).
• Two-Factor Authentication (2FA): Add email or SMS verification for an additional
layer of security.
• Session Management: Implement timed logouts and session timeout features.
11.3 Feature Additions
• Fund Transfer Between Users: Enable direct money transfers between user
accounts.
• Loan and EMI Calculator: Introduce loan application modules with automated EMI
calculations.
• Notification System: Display real-time alerts for deposits, withdrawals, and other key
actions.

11.4 Database Upgrades

• Migration to MySQL/PostgreSQL: Upgrade from SQLite to a server-based
database for better concurrency and scalability.
• Cloud Integration: Host the database remotely to allow multi-device access to the
same user account.

11.5 Platform Compatibility

• Mobile Version: Develop an Android or iOS version of GrowBank using frameworks
like Kivy or Flutter.
• Web Interface: Recreate the front-end using HTML/CSS/JS and connect via Flask or
Django for browser-based access.

11.6 Admin Tools

• Audit Logs: Maintain logs for every login, update, and transaction for compliance
auditing.
• CSV/Excel Export: Allow admins to export filtered transaction reports.
• User Status Management: Admins could temporarily deactivate or suspend user
accounts.

These future enhancements will significantly increase the professional capabilities of the
GrowBank system, transforming it from a student project to a production-ready application.

Chapter – 12
Conclusion
The GrowBank Banking System project successfully demonstrates the
development of a secure, modular, and user-friendly desktop banking
application using Python, PyQt5, and SQLite. By implementing core
banking functionalities such as account management, deposits,
withdrawals, transaction tracking, and admin controls, the system
simulates a real-world banking environment within an academic
framework.

The application adopts best practices in GUI design and database

interaction, ensuring a smooth user experience and reliable data
handling. The use of OTP-based login, SIP investment planning, and
child fund donation features introduces value-added services that
enhance the application's relevance beyond basic banking.

Through this project, key programming concepts such as Object-

Oriented Programming (OOP), modular coding, database CRUD
operations, and graphical interface development were put into
practical use. In addition, the project lays a solid foundation for future
development, with scalable architecture that can accommodate more
advanced features like cloud integration, mobile access, and real-time
analytics.

Overall, GrowBank not only meets its intended objectives but also
serves as a potential blueprint for more sophisticated personal or
institutional banking tools.

Chapter – 13
References
References

1. Python Software Foundation. Python 3.x Documentation. Retrieved from:

[Link]
2. Riverbank Computing. PyQt5 Reference Guide. Retrieved from:
[Link]
3. SQLite Consortium. SQLite Documentation – Lightweight SQL Database.
Retrieved from: [Link]
4. GeeksforGeeks. Tutorials on Python GUI with PyQt5 and SQLite
integration. Retrieved from: [Link]
5. Real Python. Best Practices for Python Programming and File Handling.
Retrieved from: [Link]
6. PyInstaller Documentation. Creating standalone executable files from
Python applications. Retrieved from: [Link]
7. W3Schools / TutorialsPoint. Basic SQL Queries and Database Operations.
8. Stack Overflow. Community-driven solutions for PyQt5 UI handling and
error debugging.
9. Lucidchart / [Link]. Tools used for creating ER diagrams, sequence
diagrams, and system architecture.