A PBL Report

On

BANK ACCOUNT MANAGEMENT

Submitted to CMREC (UGC Autonomous) In Partial Fulfillment

of the requirements for the Award of Degree of
BACHELOR OF TECHNOLOGY
IN
COMPUTER SCIENCE AND ENGINEERING
(Artificial Intelligence and Machine Learning)

Submitted By
G.JAGAN - 228R1A6686
G.SHASHIDAR - 228R1A6685
V.L.N.SWAMY - 228R1A66C8
K.DANIEL BABU - 228R1A6697

Under the guidance of

Mrs. M. SOUJANYA
Assistant Professor, Department of CSE (AI & ML)

Department of Computer Science & Engineering (AI & ML)

CMR ENGINEERING COLLEGE
(Accredited by NBA, Approved by AICTE, NEW DELHI, Affiliated to JNTU,
Hyderabad)
Kandlakoya, Medchal Road, R.R. Dist. Hyderabad-501 401)
2023-2024
 CMR ENGINEERING COLLEGE
(Accredited by NBA, Approved by AICTE NEW DELHI, Affiliated to JNTU,
Hyderabad) Kandlakoya, Medchal Road, Hyderabad-501 401
Department of Computer Science & Engineering
(Artificial Intelligence and Machine Learning)

CERTIFICATE
This is to certify that the project entitled “BANK ACCOUNT MANAGEMENT” is a
bonafide work carried out by
G.JAGAN - 228R1A6686
G.SHASHIDAR 228R1A6685
-
V.L.N.SWAMY
- 228R1A66C8
K.DANIEL BABU
- 228R1A6697

in partial fulfillment of the requirement for the award of the degree of BACHELOR OF
TECHNOLOGY in COMPUTER SCIENCE AND ENGINEERING (AI & ML) from
CMR Engineering College, under our guidance and supervision.

The results presented in this project have been verified and are found to be satisfactory.
The results embodied in this project have not been submitted to any other university
for the award of any other degree or diploma.

Internal Guide Head of the Department

Mrs. M. SOUJANYA Dr. M . KUMARA SWAMY
Assistant Professor Department Professor & HOD
of CSE (AI & ML),
Department of CSE (AI & ML),
CMREC, Hyderabad
CMREC, Hyderabad
 DECLARATION

This is to certify that the work reported in the present project entitled "BANK ACCOUNT
MANAGEMENT" is a record of bonafide work done by me in the Department of
Computer Science and Engineering (AI & ML), CMR Engineering College. The reports are
based on the project work done entirely by me and not copied from any other source. I
submit my project for further development by any interested students who share similar
interests to improve the project in the future.
The results embodied in this project report have not been submitted to any other
University or Institute for the award of any degree or diploma to the best of our
knowledge and belief.

G.JAGAN - 228R1A6686
G.SHASHIDAR - 228R1A6685

V.L.N.SWAMY - 228R1A66C8

K.DANIEL BABU - 228R1A6697

 CONTENTS

1.Abstract
2.Introduction
3.Problem Statement
Existing Problem
Proposed
Solution
4.ER Diagram
5.Source Code
Database Schema (MySQL)
Application Logic (Python with SQLAlchemy)
6. Relational Model
7.Normalization
First Normal Form (1NF)
Second Normal Form (2NF)
Third Normal Form (3NF)
8.Conclusion
9.Future Enhancements
10. References
 BANK ACCOUNT MANAGEMENT
ABSTRACT
Effective bank account management is a cornerstone of financial
stability and growth for both individuals and businesses. This
comprehensive examination delves into the multifaceted aspects of
managing bank accounts, emphasizing its critical role in financial
planning, budgeting, and overall economic health. The process
involves a series of strategic activities including monitoring account
balances, ensuring timely transactions, safeguarding against fraud,
and optimizing cash flow. Advanced digital banking technologies
have revolutionized account management by providing real-time
access to financial data, enabling automated transactions, and
offering sophisticated analytical tools.

The significance of bank account management extends beyond mere

balance tracking; it encompasses a holistic approach to financial
stewardship. Key components include the regular reconciliation of
accounts to identify discrepancies, the strategic use of various
account types (such as savings, checking, and investment accounts)
to meet specific financial goals, and the importance of maintaining
accurate records for tax purposes and financial audits.

Moreover, this analysis highlights the challenges and best practices in bank
account management. Challenges such as cybersecurity threats,
maintaining liquidity, and navigating complex financial regulations
are discussed, along with strategies to mitigate these risks.

In conclusion, effective bank account management is pivotal for achieving

financial security and operational efficiency. By integrating advanced
technological solutions and adhering to disciplined financial practices,
individuals and businesses can enhance their financial resilience,
optimize resource allocation, and achieve long-term economic
objectives. This abstract underscores the importance of adopting a
proactive and informed approach to managing bank accounts in
today's dynamic financial landscape.
PROBLEM STATEMENT
Traditionally, bank account management refers to the strategic and
operational processes involved in effectively overseeing and controlling
a company's bank accounts, including all functions related to
opening, maintaining, and optimizing bank accounts to achieve
financial efficiency, security, and compliance. Bank account management
is a critical aspect of financial institutions. With the increasing number
of customers and transactions, managing bank accounts manually
becomes challenging and error-prone. This project aims to develop a
bank account management system that automates the processes
involved, providing a user-friendly interface for bank staff and
customers. The system will manage customer information, account
details, transactions, and security, ensuring data integrity and
efficiency.

Existing Problem
Manual management of bank accounts leads to several issues, including:
- Human errors in data entry and calculations.
- Time-consuming processes for bank staff and customers.
- Inconsistent data storage and retrieval.
- Difficulty in tracking and auditing transactions.
- Security vulnerabilities in handling sensitive information.

Proposed Solution

The proposed bank account management system will:

- Automate data entry and calculations to minimize human errors.
- Provide a user-friendly interface for quick and efficient processing.
- Ensure consistent and secure data storage and retrieval.
- Enable easy tracking and auditing of transactions.
- Implement robust security measures to protect sensitive information.
 ER DIAGRAM OF BANK ACCOUNT MANAGEMENT

This bank ER diagram illustrates key information about bank, including

entities such as branches, customers, accounts, and loans. It allows us
to understand the relationships between entities.
Entities and their Attributes are :

Bank Entity : Attributes of Bank Entity are Bank Name, Code and Address.
Code is Primary Key for Bank Entity.
Customer Entity : Attributes of Customer Entity are Customer_id, Name,
Phone Number and Address.
Customer_id is Primary Key for Customer Entity.
Branch Entity : Attributes of Branch Entity are Branch_id, Name and
Address. Branch_id is Primary Key for Branch Entity.
Account Entity : Attributes of Account Entity are Account_number,
Account_Type and Balance. Account_number is Primary Key
for Account Entity.
Loan Entity : Attributes of Loan Entity are Loan_id, Loan_Type and
Amount. Loan_id is Primary Key for Loan Entity.

SOURCE CODE

Database Schema(MySQL)
CREATE DATABASE BankManagement;

USE BankManagement;

CREATE TABLE Customer (

CustomerID INT AUTO_INCREMENT PRIMARY KEY,
Name VARCHAR(100),
Address VARCHAR(255),
Phone VARCHAR(15),
Email VARCHAR(100)
);

CREATE TABLE Account (

AccountID INT AUTO_INCREMENT PRIMARY KEY,
AccountType VARCHAR(50),
Balance DECIMAL(10, 2),
CustomerID INT,
FOREIGN KEY (CustomerID) REFERENCES Customer(CustomerID)
);

CREATE TABLE Transaction (

TransactionID INT AUTO_INCREMENT PRIMARY KEY,
Date DATETIME,
Amount DECIMAL(10, 2),
Type VARCHAR(50),
AccountID INT,
FOREIGN KEY (AccountID) REFERENCES Account(AccountID)
);
 Application Logic(Python with SQLAlchemy)
from sqlalchemy import create_engine, Column, Integer, String, Float, DateTime, ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker, relationship
import datetime

Base = declarative_base()

class Customer(Base):
tablename = 'Customer'
CustomerID = Column(Integer, primary_key=True, autoincrement=True)
Name = Column(String(100))
Address = Column(String(255))
Phone = Column(String(15))
Email = Column(String(100))

class Account(Base):
tablename = 'Account'
AccountID = Column(Integer, primary_key=True, autoincrement=True)
AccountType = Column(String(50))
Balance = Column(Float)
CustomerID = Column(Integer, ForeignKey('Customer.CustomerID'))
customer = relationship(Customer)

class Transaction(Base):
tablename = 'Transaction'
TransactionID = Column(Integer, primary_key=True, autoincrement=True)
Date = Column(DateTime, default=datetime.datetime.utcnow)
Amount = Column(Float)
Type = Column(String(50))
AccountID = Column(Integer, ForeignKey('Account.AccountID'))
account = relationship(Account)

engine = create_engine('mysql+pymysql://username:password@localhost/BankManagement')
Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)
session = Session()

# Example Usage
new_customer = Customer(Name="John Doe", Address="123 Elm Street", Phone="555-1234",
Email="john.doe@example.com")
session.add(new_customer)
session.commit()

new_account = Account(AccountType="Checking", Balance=1000.00,

CustomerID=new_customer.CustomerID)
session.add(new_account)
session.commit()

new_transaction = Transaction(Amount=200.00, Type="Deposit", AccountID=new_account.AccountID)

session.add(new_transaction)
session.commit()
 Relational Model
Attribute Data Type Constraints Description

CustomerID INT PRIMARY KEY, Unique identifier for

AUTO_INCREMENT each customer

Name VARCHAR(100) NOT NULL

Customer's
full name

Address VARCHAR(255) NOT NULL Customer's address

Phone VARCHAR(15) NOT NULL Customer's phone

number

Email VARCHAR(100) NOT NULL, Customer's email

UNIQUE address

Attribute Data Type Constraints Description

AccountID INT PRIMARY KEY, Unique identifier for

AUTO_INCREMENT each account

AccountType VARCHAR(50) NOT NULL Type of account

(e.g., Savings,
Checking)

Balance NOT NULL Current balance in

DECIMAL(10, 2) the account

CustomerID INT FOREIGN KEY, Reference to the

NOT NULL customer who owns the
account
Attribute Data Type Constraints Description

TransactionI INT PRIMARY KEY, Unique identifier for

D AUTO_INCREMENT each transaction

Date DATETIME NOT NULL Date and time of the

transaction

Amount DECIMAL(10, NOT NULL Amount of money involved

2) in the transaction

Type VARCHAR(50) NOT NULL Type of transaction

(e.g., Deposit,
Withdrawal)

AccountID INT FOREIGN KEY, Reference to the account

NOT NULL involved in the
transaction
EXPLANATION OF RELATIONSHIPS
Bank has Branches => 1 : N
One Bank can have many Branches but one Branch can not belong to
many Banks, so the relationship between Bank and Branch is one to many
relationship.
Branch maintain Accounts => 1 : N
One Branch can have many Accounts but one Account can not belong
to many Branches, so the relationship between Branch and Account is
one to many relationship.
Branch offer Loans => 1 : N
One Branch can have many Loans but one Loan can not belong to many
Branches, so the relationship between Branch and Loan is one to many
relationship.
Account held by Customers => M : N
One Customer can have more than one Accounts and also One Account
can be held by one or more Customers, so the relationship between
Account and Customers is many to many relationship.
Loan availed by Customer => M : N
(Assume loan can be jointly held by many Customers).
One Customer can have more than one Loans and also One Loan can be
availed by one or more Customers, so the relationship between Loan and
Customers is many to many relationship.

NORMALIZATION
The tables are normalized to ensure data integrity and eliminate
redundancy:
1NF: Each table has a primary key, and each column contains
atomic values.
2NF: All non-key columns are fully functionally dependent
on the primary key.
3NF: There are no transitive dependencies among non-key
columns.
CONCLUSION

The bank account management system developed in this project

automates and streamlines the processes involved in managing
bank accounts. The system enhances data accuracy, efficiency, and
security, benefiting both the bank staff and customers. The use of a
relational database ensures data integrity and facilitates easy
tracking and auditing of transactions.

FUTURE ENHANCEMENTS

-*Integration with Online Banking*: Allow customers to access and

manage their accounts online.
- *Mobile Application*: Develop a mobile app for convenient access
and management of accounts.
- *Advanced Security Features*: Implement multi-factor
authentication and encryption for enhanced security.
- *Data Analytics*: Incorporate data analytics to provide insights into
customer behavior and bank performance.
- *AI and Machine Learning*: Use AI and ML for fraud detection and
personalized banking services.