INTRODUCTION

A Bank Management System is a software platform that helps manage the day-to-day operations of
a bank or financial institution efficiently. This system centralizes key banking processes such as
customer account management, transaction processing, loan management, financial record keeping,
and reporting. It provides a secure and reliable environment for handling a large volume of data and
transactions, ensuring compliance with regulatory requirements.

The main objective of a Bank Management System is to streamline operations, reduce manual
efforts, enhance customer experience, and maintain the security of sensitive financial data.
2.Enlist Requirements for Bank Management System

Here’s a concise list of key requirements for a Bank Management System :

1. Customer Account Management

- Account opening, closing, and management.

- Managing customer profiles and KYC (Know Your Customer) data.

2. Transaction Management

- Handling deposits, withdrawals, transfers, and payments.

- Real-time transaction tracking.

3. Loan Management

- Loan application, approval, and repayment processing.

- Interest calculation and loan scheduling.

4. Security and Authentication

- Multi-factor authentication.

- Role-based access control. - Data encryption (SSL/TLS).

- Fraud detection systems.

5. ATM and Card Management - Issuing

and managing debit/credit cards.

- Real-time ATM and POS transaction handling.

- Card blocking and renewal.

6. Online and Mobile Banking

- Internet and mobile banking integration.

- Secure customer portals for transactions and account viewing.

7. Compliance and Reporting

- Compliance with banking regulations (AML, KYC, etc.).

- Financial and tax reporting for auditing.

8. Interest and Fee Management

- Automated interest calculation for accounts and loans.

- Management of service fees and penalties.

9. Cash and Fund Management

- Monitoring cash flows and branch-wise cash handling.

- ATM replenishment and cash reconciliation.

10. Customer Relationship Management (CRM) -

Managing customer interactions and service requests.

- Personalization and loyalty programs.

11. Currency Exchange and Foreign Transactions

- Foreign exchange handling.

- Processing international transfers.

12. Data Backup and Recovery -

Regular data backups.

- Disaster recovery mechanisms.

13. Audit Trails and Activity Logging

- Recording user activities for internal audits.

- Tracking of all financial transactions.

14. Scalability and Integration

- Scalable to accommodate growing users and transactions.

- Integration with third-party services (e.g., credit scores, payment gateways).

15. Customer Support

- Integrated helpdesk system for customer service.

- Query and complaint management.

These requirements ensure efficient operations, customer satisfaction, security, and regulatory
compliance for the bank.
3.ER-DIAGRAM OF BANK MANAGEMENT SYSTEM
4. Normalization of database bank management system

Normalization is the process of organizing a database to reduce redundancy and improve data
integrity. For a Bank Management System , we would follow the standard normalization steps to
ensure efficiency and consistency in data storage and relationships.

Here’s the normalization of the Bank Management System database through the different normal
forms (1NF, 2NF, 3NF):

---

1st Normal Form (1NF)

In 1NF , we ensure that each table has a unique identifier (Primary Key), and each column contains
atomic values (no repeating groups or arrays).

Tables in 1NF:

Customer Table

- Customer_ID (PK)

- Name

- Address

- Contact_Number

- Email

- Date_of_Birth

- KYC_Status

---
 2nd Normal Form (2NF)

In 2NF , we remove partial dependencies, i.e., all non-key attributes must depend on the entire
primary key (if the table has a composite primary key). Also, any attributes that do not depend on
the primary key are moved to a separate table.

- For all tables, their primary keys are single-column, so we check if any attributes depend only on
part of the primary key.

Improvements for 2NF:

- Transaction Table :

All attributes (Date, Amount, Transaction_Type) depend only on the `Transaction_ID`, so no changes
are needed.

- Account Table :

All attributes (Account_Type, Balance, Interest_Rate) depend only on the `Account_Number`, so no

changes are needed.

- Loan Repayment Table :

Since all attributes depend on `Payment_ID`, no changes are needed.

---

3rd Normal Form (3NF)

In 3NF , we remove transitive dependencies, where non-key attributes are dependent on other
non-key attributes. All non-key attributes must depend only on the primary key.

Improvements for 3NF:

 Account Table (3NF)

- Account_Number (PK)

- Account_Type

- Balance

- Interest_Rate

- Customer_ID (FK)

Relationships After Normalization :

1. Customer ↔ Account : One-to-Many (One customer can have multiple accounts).

2. Account ↔ Transaction : One-to-Many (One account can have multiple transactions).

3. Customer ↔ Loan : One-to-Many (One customer can have multiple loans).

4. Loan ↔ Loan Repayment : One-to-Many (One loan can have multiple repayments).

5. Customer ↔ Card : One-to-Many (One customer can have multiple debit/credit cards).

6. Branch ↔ Employee : One-to-Many (One branch can have multiple employees).

7. Branch ↔ ATM : One-to-Many (One branch can have multiple ATMs).

8. Transaction ↔ Audit : One-to-One (One transaction can be linked to one audit record).

---
5. Scenarious and how data fetched queries

In a Bank Management System , different scenarios arise when managing customer accounts, transactions, loans, and other
bank-related activities. Here are some common scenarios and the corresponding SQL queries to fetch data from the
normalized database:

---

Scenario 1: Fetch Customer Details by Customer ID

A bank employee wants to fetch the details of a specific customer using their Customer ID.

Query :

```sql

SELECT

FROM Customer

WHERE Customer_ID = 'CUST001';

```

---

Scenario 2: Fetch All Accounts of a Customer

A customer requests to see a list of all their bank accounts.

Query :

```sql

SELECT Account_Number, Account_Type, Balance

FROM Account

WHERE Customer_ID = 'CUST001';

```

Scenario 3: Fetch Transaction History for an Account

A customer wants to view the transaction history of their specific bank account.

Query :

```sql

SELECT Transaction_ID, Date, Transaction_Type, Amount

FROM Transaction
WHERE Account_Number = 'ACC12345'

ORDER BY Date DESC;

```

---

Scenario 4: Fetch All Active Loans for a Customer

A bank employee wants to see all active loans for a customer, including the type and remaining amount.

Query :

```sql

SELECT Loan_ID, Loan_Type, Loan_Amount, Interest_Rate, Start_Date, End_Date

FROM Loan

WHERE Customer_ID = 'CUST001' AND End_Date > CURRENT_DATE;

```

---

Scenario 5: Fetch Loan Repayment History

A customer wants to view the repayment history for a particular loan.

Query :

```sql

SELECT Payment_ID, Payment_Amount, Payment_Date

FROM Loan_Repayment

WHERE Loan_ID = 'LN987654'

ORDER BY Payment_Date DESC;

```

---

6. Relational Algebra Queries

In a Bank Management System , relational algebra queries are used to perform operations on
relational databases. Here are some relational algebra queries based on different scenarios:
 Schema:

Let’s assume the following relations (tables):

1. Customer (Customer_ID, Name, Address, Contact_Number, Email, DOB, KYC_Status)

2. Account (Account_Number, Account_Type, Balance, Interest_Rate, Customer_ID)

3. Transaction (Transaction_ID, Date, Amount, Transaction_Type, Account_Number)

4. Loan (Loan_ID, Loan_Type, Loan_Amount, Interest_Rate, Start_Date, End_Date, Customer_ID)

5. Card (Card_ID, Card_Type, Card_Number, Expiry_Date, Customer_ID, Account_Number)

6. Branch (Branch_ID, Branch_Name, Branch_Address, IFSC_Code)

7. Employee (Employee_ID, Name, Position, Branch_ID)

8. Loan_Repayment (Payment_ID, Payment_Amount, Payment_Date, Loan_ID, Customer_ID) 9.

ATM (ATM_ID, Location, Branch_ID)

---

1. Fetch All Accounts of a Customer

Scenario: Retrieve the details of all accounts belonging to a customer with `Customer_ID = 'C001'`.

Relational Algebra Query:

```

π(Account_Number, Account_Type, Balance) (σ(Customer_ID = 'C001') (Account))

```

- Explanation:

- `σ(Customer_ID = 'C001') (Account)` filters the rows where `Customer_ID` is `'C001'`.

- `π(Account_Number, Account_Type, Balance)` selects the attributes `Account_Number`,

`Account_Type`, and `Balance` from the result.

---
 2. Fetch Transaction History for an Account

Scenario: Retrieve the transaction history for the account with `Account_Number = 'A12345'`.

Relational Algebra Query:

```

π(Transaction_ID, Date, Transaction_Type, Amount) (σ(Account_Number = 'A12345') (Transaction))

```

- Explanation:

- `σ(Account_Number = 'A12345') (Transaction)` filters the transactions for the specific account.

- `π(Transaction_ID, Date, Transaction_Type, Amount)` projects the relevant transaction details.

---

3. Fetch All Active Loans for a Customer

Scenario: Fetch all active loans for the customer with `Customer_ID = 'C001'` (loans where
`End_Date > current_date`).

Relational Algebra Query:

```

π(Loan_ID, Loan_Type, Loan_Amount, Interest_Rate) (σ(Customer_ID = 'C001' End_Date >

current_date) (Loan))

```

- Explanation:

- `σ(Customer_ID = 'C001' ∧ End_Date > current_date) (Loan)` selects loans of the customer that are
still active.

- `π(Loan_ID, Loan_Type, Loan_Amount, Interest_Rate)` retrieves the loan details.

---

4. Fetch Customers with a Balance Below a Certain Threshold

Scenario: Find customers whose account balance is less than 500.

Relational Algebra Query:

```

π(Customer_ID, Name) (σ(Balance < 500) (Account ⨝ Customer))

```

- Explanation:

- `Account ⨝ Customer` is a natural join between the `Account` and `Customer` tables based on
`Customer_ID`.

- `σ(Balance < 500)` filters accounts with a balance less than 500.

- `π(Customer_ID, Name)` selects the customer details.

---

5. Fetch Loan Repayment History for a Loan

Scenario: Retrieve the repayment history for the loan with `Loan_ID = 'L12345'`.

Relational Algebra Query:

```

π(Payment_ID, Payment_Amount, Payment_Date) (σ(Loan_ID = 'L12345') (Loan_Repayment))

```

- Explanation:

- `σ(Loan_ID = 'L12345') (Loan_Repayment)` selects repayment records for the specified loan.

- `π(Payment_ID, Payment_Amount, Payment_Date)` retrieves the relevant repayment details.

---

7. References:

• https://www.coursera.org/

• https://www.researchgate.net/

• https://stackoverflow.com/