Bank backend in python

• 

  output with sample input

The project was inspired by the real-world functioning of banking systems — specifically how data is stored, how transactions are updated, and how security of user accounts is maintained. I wanted to simulate the core backend logic of a bank without using databases or frameworks. The main idea was:

Build a simple backend-like program using only Python and file handling.

This helped me understand how even simple systems follow structured logic similar to bigger applications.

What It Does

The program works like a mini banking backend operated in the terminal:

Creates a new account if the user is new

Allows depositing money

Allows withdrawing money (with balance check)

Displays current balance

All account data is stored in a file named bank.txt. Each record in the file follows:

username : balance username:balance How We Built It

Created a class BankAccount to represent each user’s bank account.

Used Python file handling operations (read, write, append) to store account data persistently.

Implemented three major methods:

deposit()

withdraw()

view_balance()

Used a terminal menu loop to continuously allow user interaction until they exit.

The choice to use file storage instead of a database helped me understand:

Program State ⇒ Persistent Storage Program State⇒Persistent Storage Challenges We Ran Into Challenge Solution File rewriting caused loss of formatting and duplication Carefully processed each line while rewriting the file Detecting whether a user exists Used a flag variable and checked each line while reading the file Keeping the terminal interaction smooth Used an infinite loop with pattern matching (match-case)

A tricky part was ensuring that each update only changed the correct user’s record, without disturbing the remaining data.

Accomplishments We're Proud Of

Built a fully working terminal-based backend banking system

Data persists between executions (no data loss after closing the program)

Implemented logic similar to a real transactional system

This project helped me understand responsibility of backend developers regarding:

Atomicity

+

Accuracy

of

Data Atomicity + Accuracy of Data What I Learned

Basics of Python OOP design

File handling (readlines, write, append)

Importance of data integrity in transactional systems

Improved understanding of how backend logic works behind UIs

What’s Next for the Project

Add authentication (username + password)

Replace text file with a database (SQLite or MongoDB)

Create a graphical interface or integrate with a web backend using Flask/FastAPI

Add transaction history tracking

Current System → Future: API + Database Current System→Future: API + Database

Built With

• python