COMPUTER SCIENCE

PROJECT

2024-25

BANK MANAGEMENT
SYSTEM

NAME: HARISANKAR ANIL

VASUDEV.V. PRADEEP
YEAR: 2024 - 25
CLASS XII
 ACKNOWLEDGEMENT

I would like to express my sincere gratitude to everyone who

contributed to the successful completion of this project.
First and foremost, I am thankful to Mrs. Soniya Cherian,
my Computer Science teacher, for her invaluable guidance,
constant support, and encouragement throughout the course of
this project. Her expertise and patience have been instrumental
in helping me learn and apply various concepts.
I would also like to extend my heartfelt thanks to our Principal,
Mrs. Lata Roy, for providing an environment that fosters
learning and creativity, and for always encouraging students to
explore and expand their knowledge.
Lastly, I am grateful to Hagia Sophia Public School for
offering the necessary resources and facilities, which greatly
contributed to the success of this project.
 CONTENTS

 INTRODUCTION
 OBJECTIVE OF THE PROJECT
 PROJECT DESCRIPTION
 FUTURE SCOPE
 PROJECT CATEGORY
(i) HARDWARE USED
(ii) SOFTWARE USED
 SOURCE CODE
 LIMITATIONS
 CONCLUSION
 BIBLIOGRAPHY
 INTRODUCTION

Banking is a critical sector in the modern economy,

facilitating the exchange of financial assets and
the management of accounts. As technology evolves, so
does the demand for efficient, secure, and
scalable solutions that can handle complex banking
operations.
The Bank Management System (EMS) plays a crucial
role in automating banking activities such as
account creation, deposits, withdrawals, and balance
management. With the rise of online and
digital banking, the need for robust systems to manage
millions of transactions daily has increased
exponentially.
BMS applications riot only streamline internal operations
for banks but also improve customer
experience by reducing wait times, minimizing errors, and
ensuring seamless transactions. This
project focuses on creating a foundational bank
management system that can manage customer
data, account balances, and transactions in a secure and
efficient manner. By automating these
operations, the system helps banks operate with higher
accuracy, speed and security.
 OBJECTIVES OF THE PROJECT

The Bank Management System is designed to meet the

following objective:
-AUTOMATION: To reduce the manual effort of
banking staff by automating key processes such as
account creation, data management, and transaction
processing.
-DATA SECURITY: To protect sensitive customer
data from unauthorized access using encryption
and secure authentication mechanisms.
-EFFICIENCY: To ensure that banking operations
such as deposits, withdrawals, and balance
Inquiries are processed swiftly and accurately.
-CUSTOMER SATISFACTION: To improve the
overall banking experience for customers by providing
them with faster and more secure access to their
accounts and transactions.
-SCALABILITY: To design the system so that it can
:

easily scale with the growth of a bank,

accommodating a larger customer base and handling
more transactions without performance
degradation.
-ERROR MINIMIZATION: To reduce human errors
in financial transactions by automating routine
tasks and providing real–time data validation
 PROJECT DESCRIPTION

The Bank Management System (BMS) consists of several core

modules that work together to deliver a comprehensive banking
experience. This system is primarily designed for two types of
users: bank employees (administrators) and customers.
Administrators have access to features that allow them to create
accounts, manage customer information, and monitor
transactions, while customers can perform their own banking
operations such as deposits, withdrawals, and balance
inquiries.
KEY MODULES:
-ACCOUNT MANAGEMENT: This module allows for the
creation of new accounts. Customer information, such as name,
address, contact details, and initial deposit, is stored securely in a
database. Customers can update their personal information when
necessary.
-TRANSACTION MODULE: Handles all transactions within
the bank. Customers can make deposits, withdrawals, and
transfers between accounts. The system ensures that all
transactions are secure and updates account balances in real time.
-USER ROLES: The system differentiates between different
users, .Administrators can access all customer data, modify
accounts, and generate reports, while customers can only
access their own account details and perform transactions. -
daily transaction logs, monthly account summaries, and
financial performance reports for bank
-REPORTING MODULE: Generates various reports such as
daily transaction logs, monthly account summaries, and
financial performance reports for bank administrators to
monitor the health of the bank's operations.
-SECURITY MODULE: Ensures the system's security by
incorporating features like login authentication, encryption of
sensitive data, and transaction logs that can be reviewed for any
discrepancies.
TECHNICAL ASPECTS:
-DATABASE MANAGEMENT: A SQL-based database is
used to store customer details, account information, and
transaction history. Indexing and caching are employed to
speed up access to frequently requested data.
-REAL-TIME PROCESSING: The system ensures that all
transactions are processed in real time, providing instant
feedback on account balances and transaction statuses.
-ERROR HANDLING: The system is equipped with
mechanisms to handle exceptions, such as
insufficient funds during withdrawals or incorrect account
numbers during transfers.
 FUTURE SCOPE

There are several potential enhancements for the Bank

Management System that could be considered for future
development:

-AI and Machine Learning: Incorporating AI to detect and

prevent fraudulent transactions by analyzing customer behavior
and flagging unusual patterns.

-Mobile Banking Integration: Developing a mobile app version

of the BMS to allow customers to manage their accounts from
their smartphones.

-Blockchain Integration: Implementing blockchain technology

to further secure transaction data and create immutable records of
all financial activities, enhancing transparency and security.

-Cloud Deployment: Migrating the system to cloud platforms

like AWS or Google Cloud to improve scalability, availability,
and disaster recovery capabilities.

-Multi-currency and International Transactions:

Expanding the system to handle multiple currencies, allowing
international customers to manage accounts and perform cross
border transactions seamlessly.

-Biometric Authentication: Adding biometric authentication

methods like fingerprint or facial recognition to enhance security
for both customers and bank employees.
 PROJECT CATEGORY

This project falls under the category of Software Development,

specifically targeting Banking and Financial Management
Systems. The development of such systems plays a crucial role
in the digital transformation of banking institutions, allowing for
more efficient, secure, and scalable management of financial
transactions.
As part of the broader field of Information Technology, this
project integrates both front-end and back-end development with
a focus on database management, real -time data processing, and
security mechanisms
HARDWARE USED
 SOFTWARE USED

WINDOWS 10 PYTHON

MY SQL MS WORD
 PYTHON CODE AND OUTPUT

CODE:

import mysql.connector as conn

def main():
while True:
connect = database_connection()
print('Choose 1 for Creating Account')
print('Choose 2 for Depositing Money')
print('Choose 3 for Withdrawing Money')
print('Choose 4 for Changing Account Holder Name')
print('Choose 5 to Delete an Account')
print('Choose 6 to View Account')
print('Choose 7 to Exit')
choice = int(input('Enter your choice:'))
if choice == 1:
name = input('Enter Account holders Name: ')
balance = float(input('Enter Initial balance amount: '))
create_account(connect, name, balance)
elif choice == 2:
account_id = int(input('Enter Account ID to which
Amount has to be Deposited: '))
add = float(input('Enter Amount to be deposited: '))
add_money(connect, account_id, add)
elif choice == 3:
account_id = int(input('Enter Account ID from which
Amount has to be Withdrawn: '))
withdraw = float(input('Enter Money to be withdrawn: '))
withdraw_money(connect, account_id, withdraw)
elif choice == 4:
account_id = int(input('Enter Account ID whose Holder
name should be Updated: '))
new_name = input('Enter New name: ')
update_name(connect, account_id, new_name)
elif choice == 5:
account_id = int(input('Enter Account ID to be
Deleted:'))
delete_account(connect, account_id)
elif choice == 6:
account_id = int(input('Enter Account ID to be
Viewed:'))
view_account(connect, account_id)
elif choice == 7:
print('Exiting the System')
print('Thank you')
connect.close()
break
else:
print('Invalid choice')
continue
def database_connection():
connect = conn.connect(host='localhost', user='root',
passwd='hagia', database='bank')
if connect.is_connected():
print('Database successfully connected')
return connect
else:
 print('Error in connecting database')
return None
def create_account(connect, name, balance):
cursor = connect.cursor()
query = 'insert into accounts (name, balance) values (%s,
%s);'
cursor.execute(query, (name, balance))
print(f'Successfully Created an Account with Account_Name
{name}')
connect.commit()
def add_money(connect, account_id, add):
cursor = connect.cursor()
query = 'update accounts SET balance = balance + %s where
account_id = %s;'
cursor.execute(query, (add, account_id))
print(f'Successfully deposited Amount of {add} to Account
with Account_ID {account_id}')
connect.commit()
def withdraw_money(connect, account_id, withdraw):
cursor = connect.cursor()
cursor.execute('select balance from accounts where
account_id = %s;', (account_id,))
result = cursor.fetchone()
if result and result[0] >= withdraw:
query = 'update accounts set balance = balance - %s where
account_id = %s;'
cursor.execute(query, (withdraw, account_id))
print(f'Successfully withdrew Amount of {withdraw} from
Account with Account_ID {account_id}')
connect.commit()
else:
 print('Insufficient funds or account not found.')
def update_name(connect, account_id, new_name):
cursor = connect.cursor()
query = 'update accounts set name = %s where account_id =
%s;'
cursor.execute(query, (new_name, account_id))
print(f'Successfully updated Account with Account_ID
{account_id}')
connect.commit()
def delete_account(connect, account_id):
cursor = connect.cursor()
query = 'delete from accounts where account_id = %s;'
cursor.execute(query, (account_id,))
print(f'Account with Account_ID {account_id} deleted')
connect.commit()
def view_account(connect, account_id):
cursor = connect.cursor()
query = 'select * from accounts where account_id = %s;'
cursor.execute(query, (account_id,))
account = cursor.fetchone()
if account:
print(f'Account ID: {account[0]}, Name: {account[1]},
Balance: {account[2]}')
else:
print(f'No account found with Account_ID {account_id}')
main()
OUTPUT:

Database successfully connected

Choose 1 for Creating Account
Choose 2 for Depositing Money
Choose 3 for Withdrawing Money
Choose 4 for Changing Account Holder Name
Choose 5 to Delete an Account
Choose 6 to View Account
Choose 7 to Exit
Enter your choice:1
Enter Account holders Name: Vasudev
Enter Initial balance amount: 50000
Successfully Created an Account with Account_Name Vasudev
Database successfully connected
Choose 1 for Creating Account
Choose 2 for Depositing Money
Choose 3 for Withdrawing Money
Choose 4 for Changing Account Holder Name
Choose 5 to Delete an Account
Choose 6 to View Account
Choose 7 to Exit
Enter your choice:1
Enter Account holders Name: Sharan V
Enter Initial balance amount: 40000
Successfully Created an Account with Account_Name Sharan V
Database successfully connected
Choose 1 for Creating Account
Choose 2 for Depositing Money
Choose 3 for Withdrawing Money
Choose 4 for Changing Account Holder Name
Choose 5 to Delete an Account
Choose 6 to View Account
Choose 7 to Exit
Enter your choice:1
Enter Account holders Name: Christo
Enter Initial balance amount: 70000
Successfully Created an Account with Account_Name Christo
Database successfully connected
Choose 1 for Creating Account
Choose 2 for Depositing Money
Choose 3 for Withdrawing Money
Choose 4 for Changing Account Holder Name
Choose 5 to Delete an Account
Choose 6 to View Account
Choose 7 to Exit
Enter your choice:2
Enter Account ID to which Amount has to be Deposited: 18
Enter Amount to be deposited: 40000
Successfully deposited Amount of 40000.0 to Account with
Account_ID 18
Database successfully connected
Choose 1 for Creating Account
Choose 2 for Depositing Money
Choose 3 for Withdrawing Money
Choose 4 for Changing Account Holder Name
Choose 5 to Delete an Account
Choose 6 to View Account
Choose 7 to Exit
Enter your choice:3
Enter Account ID from which Amount has to be Withdrawn: 19
Enter Money to be withdrawn: 10000
Successfully withdrew Amount of 10000.0 from Account with
Account_ID 19
Database successfully connected
Choose 1 for Creating Account
Choose 2 for Depositing Money
Choose 3 for Withdrawing Money
Choose 4 for Changing Account Holder Name
Choose 5 to Delete an Account
Choose 6 to View Account
Choose 7 to Exit
Enter your choice:4
Enter Account ID whose Holder name should be Updated: 20
Enter New name: Johny
Successfully updated Account with Account_ID 20
Database successfully connected
Choose 1 for Creating Account
Choose 2 for Depositing Money
Choose 3 for Withdrawing Money
Choose 4 for Changing Account Holder Name
Choose 5 to Delete an Account
Choose 6 to View Account
Choose 7 to Exit
Enter your choice:5
Enter Account ID to be Deleted: 19
Account with Account_ID 19 deleted
Database successfully connected
Choose 1 for Creating Account
Choose 2 for Depositing Money
Choose 3 for Withdrawing Money
Choose 4 for Changing Account Holder Name
Choose 5 to Delete an Account
Choose 6 to View Account
Choose 7 to Exit
Enter your choice:6
Enter Account ID to be Viewed: 20
Account ID: 20, Name: Johny, Balance: 70000.00
Database successfully connected
Choose 1 for Creating Account
Choose 2 for Depositing Money
Choose 3 for Withdrawing Money
Choose 4 for Changing Account Holder Name
Choose 5 to Delete an Account
Choose 6 to View Account
Choose 7 to Exit
Enter your choice:7
Exiting the System
Thank you
 SQL TABLES

CODE:

Create table Accounts(Account_ID int(10) auto_increment

Primary key, Name varchar(100), Balance Decimal(10,2);

TABLE:

+------------+---------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+------------+---------------+------+-----+---------+----------------+
| Account_ID| int(10) | NO | PRI | NULL |auto_increment |
| Name | varchar(100) | YES | | NULL | |
| Balance | decimal(10,2)| YES | | NULL | |
+------------+---------------+------+-----+---------+----------------+

+------------+---------+----------+
| Account_ID | Name | Balance |
+------------+---------+----------+
| 18 | Vasudev | 90000.00 |
| 20 | Johny | 70000.00 |
+------------+---------+----------+
 LIMITATIONS

Despite its functionality, the Bank Management System has

the following limitations:
-Basic User Interface: The current version is a command-line
application, which may not be user-friendly for all customers.
Future versions could feature a more intuitive graphical user
interface (GUI).
-Limited Security Features: While the system includes basic
password protection, it lacks advanced security features like
encryption, biometric authentication, or multi-factor
authentication, making it vulnerable to certain security threats.
-No Online Functionality: This system is a standalone
application and does not support online banking or remote
access. Integration with internet banking systems is required for
broader use.
-Scalability: As the system grows, handling large volumes of
data and transactions might become challenging without
optimization and upgrading the underlying infrastructure.
-Transaction Types: The current system only handles basic
transactions such as deposits and withdrawals. It does not
support more complex financial operations like loans, fixed
deposits, or investment tracking
 CONCLUSION

In conclusion, the Bank Management System is a foundational

software solution aimed at streamlining banking operations and
enhancing customer experience.
By automating key processes such as account management,
transaction handling, and data security, the system provides a
strong platform for banks to operate efficiently. However, there
isstill room for improvement in areas such as advanced security
features online banking integration, and support for more
complex financial operations. The system serves as a stepping
stone for further developments in banking technology, and future
iterations can incorporate cutting-edge technologies such as
artificial intelligence, blockchain, and mobile banking. By
continuously evolving, the Bank Management System can meet
the growing demands of customers while ensuring regulatory
compliance and operational efficiency. As the banking sector
continues to digitize, systems like these will become essential for
the smooth functioning of financial institutions globally.
 BIBLIOGRAPHY

 Computer Science Textbook for CBSE Class XII by Preeti

Arora
 www.google.com
 Python IDLE
 My SQL