How to Build a Simple Checking Account Program in Linux

What a checking account program does, and why you might build one

A checking account program in Linux is a command-line tool that tracks deposits, withdrawals, and your running balance. It stores transactions in a file, reads them back when you ask, and does basic math to show you where your money is. You build it yourself using a scripting language like Bash or Python, which means you control exactly what it does and how it stores your data.

Most people use a bank's app or website instead. But building one teaches you how transactions actually work — how a debit and a credit balance each other, how a ledger records the order of events, and why that order matters. If you work in fintech or payments, understanding the mechanics from the ground up is useful. If you just want to learn Linux scripting, a checking account is a concrete project with real logic to it.

Key Takeaways

A straightforward checking account program stores transactions in a text file, one per line, with the date, type (deposit or withdrawal), and amount.
Bash scripts can read the file, add new transactions, and calculate the current balance by adding deposits and subtracting withdrawals.
Python programs do the same work with less code and are easier to extend later if you want to add features like interest or overdraft warnings.
The hardest part is not the code — it is deciding how to store data so you can read it back reliably and prevent mistakes like duplicate entries.

Storing transactions in a plain text file

The simplest approach is a CSV file — comma-separated values — where each line is one transaction. A line looks like this:

2024-01-15,deposit,500.00

The three fields are the date, the type of transaction, and the amount. You can add more fields later — a description, a category, a running balance — but start with these three. Store the file in your home directory with a name like checking.csv.

The advantage of CSV is that it is human-readable. You can open it in a text editor and see exactly what happened. The disadvantage is that there is nothing stopping you from typing garbage into it by hand. A real bank database has constraints — a withdrawal cannot be larger than the balance, a date must be a valid date — but a text file does not enforce those. For a learning project, that is fine. For anything real, you would use a database.

Writing a Bash script to add transactions

A Bash script can read the filename, ask you for the transaction details, and append a new line to the file. Here is the basic structure:

#!/bin/bash ACCOUNT_FILE="$HOME/checking.csv" echo "Enter date (YYYY-MM-DD):" read DATE echo "Enter type (deposit or withdrawal):" read TYPE echo "Enter amount:" read AMOUNT echo "$DATE,$TYPE,$AMOUNT" >> $ACCOUNT_FILE

The read command waits for you to type something. The >> operator appends the line to the file without erasing what is already there. Save this as a file called add_transaction.sh, then run chmod +x add_transaction.sh to make it executable. After that, you can run it by typing ./add_transaction.sh.

This script does no error-checking. It does not verify that the date is real, that the type is actually "deposit" or "withdrawal", or that the amount is a number. Adding those checks makes the script longer but more reliable. A production system would reject bad input before it ever touches the file.

Calculating the balance with a Bash loop

To see your current balance, you need to read every line in the file, add up all the deposits, subtract all the withdrawals, and print the result. A Bash loop does this:

#!/bin/bash ACCOUNT_FILE="$HOME/checking.csv" BALANCE=0 while IFS=',' read -r DATE TYPE AMOUNT; do if [ "$TYPE" = "deposit" ]; then BALANCE=$((BALANCE + AMOUNT)) elif [ "$TYPE" = "withdrawal" ]; then BALANCE=$((BALANCE - AMOUNT)) fi done < $ACCOUNT_FILE echo "Current balance: $BALANCE"

The while loop reads one line at a time. The IFS=',' tells it to split each line at the comma. The if statement checks whether the type is "deposit" or "withdrawal" and adds or subtracts accordingly. At the end, it prints the balance.

This script reads the entire file every time you run it. For a small account with a few hundred transactions, that is when ready. For millions of transactions, it would be slow. A real bank does not recalculate from the beginning each time — it stores the balance and updates it as each transaction arrives.

Using Python for more readable code

Bash works, but Python is cleaner for this kind of logic. Here is a Python version that does the same thing:

#!/usr/bin/env python3 import csv ACCOUNT_FILE = "/home/username/checking.csv" def get_balance(): balance = 0 with open(ACCOUNT_FILE, 'r') as f: reader = csv.DictReader(f, fieldnames=['date', 'type', 'amount']) for row in reader: amount = float(row['amount']) if row['type'] == 'deposit': balance += amount elif row['type'] == 'withdrawal': balance -= amount return balance print(f"Current balance: ${get_balance():.2f}")

Python's csv module handles the parsing for you. The DictReader turns each line into a dictionary, so you can refer to fields by name instead of position. The float() function converts the amount from text to a number. The f-string at the end formats the balance as currency with two decimal places.

Python is easier to extend. If you want to add a feature — like listing all transactions, or calculating interest, or warning when the balance drops below zero — you just add another function. Bash can do those things too, but the code gets harder to read.

Preventing common mistakes

Once you have a working program, you will run into problems. The most common ones are:

Duplicate transactions. If you run the add script twice by accident, the same transaction appears twice. A real system prevents this by assigning each transaction a unique ID and checking for duplicates before writing. For a learning project, you can just be careful, or add a timestamp to each entry so duplicates are obvious.

Negative balances. Your script will happily subtract more than you have. A real bank either rejects the withdrawal or charges an overdraft fee. Your program can check the balance before allowing a withdrawal, or just let it go negative and flag it when you print the balance.

Corrupted data. If you edit the file by hand and introduce a typo — like writing "depositt" instead of "deposit" — the script will not recognize it and will skip that line. A validation step that checks each line before processing it catches these errors early.

What happens next if you keep building

A basic checking account program is about 20 lines of code. From there, you can add features that real banks have. A running balance column shows your balance after each transaction, so you can see when you dipped below zero. A transaction history command lists the last 10 transactions with dates and amounts. A category field lets you tag transactions as groceries, gas, or rent, so you can see where your money goes.

If you want to go further, you can add multiple accounts, transfers between them, recurring transactions, and a straightforward web interface so you do not have to use the command line. Each of these is a real problem that payment systems solve. Building them yourself, even in a toy program, teaches you how the actual systems work.

Frequently Asked Questions

Should I use Bash or Python?

Bash is fine for a very straightforward program — just adding and viewing transactions. Python is better if you think you will add features later or if you want the code to be straightforward to read. Python is also more portable; the same script runs on Linux, Mac, and Windows without changes.

Where should I store the CSV file?

Your home directory is the simplest place. Use $HOME/checking.csv in Bash or /home/username/checking.csv in Python, replacing "username" with your actual username. Never store it in a shared directory where other users can see or edit it.

What if I want to edit a transaction after I have entered it?

The simplest approach is to delete the line from the file and re-enter it correctly. A more robust program would let you specify a transaction by date and amount, then overwrite just that line. For now, manual editing is fine.

Can I use a database instead of a CSV file?

Yes. SQLite is a lightweight database that runs on Linux and stores data in a single file. It enforces data types and lets you write queries to find transactions by date or amount. It is more complex to set up but much more reliable for anything beyond a learning project.

How do I prevent someone else from reading my account data?

Set the file permissions so only you can read it. Run chmod 600 checking.csv to make the file readable and writable only by you. If you are storing real financial data, encrypt the file or use a database with password protection.

This guide is for general information only and is not medical, financial, legal, or other professional advice. For decisions specific to your situation, consult a qualified professional. See our Editorial Policy.