I
INVOICE MANAGEMENT SYSTEM
By:
Yash M. Kosumbkar 2301624
Paras D. Dhande 2301611
Nehal D. Talele 2301644
Guide
Prof. R.S.Meshram
Department of Information Technology
Konkan Gyanpeeth College of Engineering
Karjat, Raigad – 410201
University of Mumbai (AY 2024-25)
II
CERTIFICATE
This is to certify that the Mini Project entitled “INVOICE
MANAGEMENT SYSTEM” is a bonafide work of,
Yash Kosumbkar (2301624)
Paras Dhande (2301611)
Nehal Talele (2301644)
submitted to the University of Mumbai in partial fulfillment of the
requirement for the award of the degree of “Second year of
Engineering”
in “Information Technology”.
(Prof. Anup Kunte) ( Prof. R.S. Meshram )
Head of Department Guide
III
INDEX
Sr No Content Page No
1. Abstract 1
2. Acknowledgment 2
3. Introduction 3
4. Problem Statemente 4
Key Features
5. 5-6
Block DIagram
6. 7
6. Implementation 8-18
7. Output 19-20
8. Conclusion 21
9. Refrences 22
1
ABSTRACT
This project presents the development of a Python-based Invoice
Management System tailored for small and medium-sized businesses in India.
The application streamlines the process of generating and managing invoices by
providing an intuitive graphical user interface (GUI) built using Tkinter. It
enables users to enter itemized products with support for advanced unit
handling (e.g., kilograms, grams, liters, milliliters), apply automatic tax
calculations, and generate professionally formatted invoices in PDF format
using ReportLab.
A standout feature of the system is its automated invoice numbering,
which resets every financial year in accordance with Indian standards.
Additionally, the system logs all invoice data into an Excel file using OpenPyXL,
facilitating record-keeping and further analysis. For user convenience, the
system includes keyboard interaction shortcuts, such as using the Enter key
to add products and quickly submit invoices.
By combining ease of use with essential business functionalities, this
Invoice Management System offers a practical solution for organizations
seeking to digitize and simplify their billing operations without relying on
external or complex software platforms.
2
Acknowledgment
I would like to express my sincere gratitude to all those who
supported me throughout the development of this project titled
“Invoice Management System using Python.”
First and foremost, I am deeply thankful to my mentor and
guide for their constant encouragement, constructive feedback,
and invaluable suggestions that greatly enhanced the quality of
this work.
I would also like to thank my family and friends for their
unwavering support, motivation, and patience during the entire
development process.
Finally, I acknowledge the role of open-source libraries and
the Python programming community for providing accessible
tools and resources that made the successful implementation of
this project possible.
This project has been a tremendous learning experience, and
I am grateful for the opportunity to apply my programming skills
in solving a real-world business problem.
3
Introduction
In today’s fast-paced digital world, businesses—especially
small and medium enterprises (SMEs)—require efficient tools to
manage their billing and financial transactions. Traditional paper-
based invoicing systems are not only time-consuming but also
prone to errors, misplacement, and lack of scalability. This project
introduces an automated Invoice Management System
developed using Python, designed to simplify and streamline the
invoicing process with accuracy and professionalism.
The system is equipped with a user-friendly Graphical User
Interface (GUI) built with Tkinter, allowing users to create
itemized invoices quickly, add client details, and include products
with varying units such as kilograms, grams, liters, and pieces. It
also supports tax calculations and generates printable PDF
invoices using the ReportLab library. All invoice records are
stored securely in an Excel file, offering easy access for future
reference and analysis.
One of the unique features of this system is the auto-
generated invoice number that follows the Indian financial year
format, resetting annually. The system also supports fast
navigation using the keyboard, improving user efficiency. With
these functionalities, the project addresses real-world challenges
faced by businesses and provides a reliable solution to maintain
organized and professional financial documentation.
4
Problem Statement
Manual invoice generation and recordkeeping methods are
still widely used by many small and medium-sized businesses.
These traditional processes are often inefficient, time-consuming,
and error-prone, especially when dealing with multiple clients,
diverse products, tax calculations, and record maintenance over
long periods. Additionally, the lack of standardized invoice formats,
inconsistent numbering, and improper storage of transaction
history can lead to financial discrepancies and compliance issues.
There is a need for a simple, reliable, and user-friendly digital
solution that can automate invoice generation, support various
units and pricing formats, maintain financial year-based invoice
numbering, and ensure accurate storage of all billing data. This
project aims to address these challenges by developing a Python-
based Invoice Management System that streamlines invoicing
operations, enhances data accuracy, and ensures easy access to
historical records for future business analysis and reporting.
5
Key Features
✅ Graphical User Interface (GUI)
Clean, minimalistic Tkinter-based interface.
All major actions available as buttons.
Real-time input with auto-updating item list.
✅ Invoice Number Automation
Follows the format: INV-YYYY-XXXX
Automatically resets every April 1st based on Indian financial year.
Invoice number is non-editable by the user.
✅ Itemized Product Entry
Description, Quantity, Price, and Unit per item.
Unit options: pcs, kg, gm, ltr, ml
Automatically converts gm → kg and ml → ltr.
Allows decimal quantities.
✅ Enter Key Workflow
Press Enter once → Adds item to cart.
Press Enter twice quickly → Submits invoice.
✅ PDF Invoice Generator
Saves invoices as printable PDFs using ReportLab.
Includes: Client name, Date, Auto-generated invoice number, Item
list, Subtotal, 10% Tax, Grand Total.
✅ Excel Record Maintenance
Logs every invoice in invoices.xlsx with complete breakdown of
each line item and totals.
✅ Persistent Invoice Counter
Uses a .json file to store the latest invoice number per financial
year.
6
Objective:
To design and implement a desktop application using Python
that allows users to create professional invoices, save them as PDF
files, and log all records into an Excel file with the following
features:
- Invoice auto-numbering (reset every Indian financial year)
- Support for itemized entries with unit conversion
- Tax and total calculation
- Keyboard-friendly interaction (Enter key navigation)
Technology Stack:
Component Technology Used
Programming Python
GUI Framework Tkinter
PDF Generation ReportLab
Data Storage Excel (OpenPyXL), JSON
File Format .pdf, .xlsx, .json
Files Generated:
File Name Description
INV-YYYY-XXXX.pdf PDF invoice for each
transaction
invoices.xlsx Excel workbook with all
invoice data
invoice_counter.json Stores invoice counters by
FY
Future Scope (Suggestions):
- Add a company logo and GST info in the PDF.
- Implement client contact saving and auto-fill.
- Create a dashboard to search, filter, and sort past invoices.
- Integrate a print button or PDF preview.
- Add authentication for multi-user access (Admin/Staff).
- Include inventory tracking and payment status.
7
Block DIagram
GUI Initialization
(Tkinter Window Setup)
Excel Initialization
(Create "invoices.xlsx" if not exists)
Generate Invoice Number
(Based on Financial Year using JSON
file)
User Inputs Client and Item
Information
Add Item Logic
Description, Qty, Price
Convert Units if needed
Clear Form Field
Display Item in Listbox
for Next Invoice
Generate Invoice Save Data to Excel
Validate field (Each item with full info
Create PDF using including totals & tax)
8
Implementation
9
import tkinter as tk
from tkinter import messagebox
from reportlab.lib.pagesizes import letter
from reportlab.pdfgen import canvas
from datetime import datetime
import openpyxl
import os
import time
import json
invoice_items = []
last_enter_time = 0
# --- Financial Year & Invoice Number ---
def get_financial_year():
today = datetime.today()
year = today.year
if today.month < 4:
return year - 1
return year
def generate_invoice_number():
fy = get_financial_year()
filename = "invoice_counter.json"
10
if os.path.exists(filename):
with open(filename, "r") as f:
data = json.load(f)
else:
data = {}
str_fy = str(fy)
if str_fy not in data:
data[str_fy] = 1
else:
data[str_fy] += 1
with open(filename, "w") as f:
json.dump(data, f)
return f"INV-{str_fy}-{data[str_fy]:04d}"
# --- Excel Setup ---
def init_excel():
if not os.path.exists("invoices.xlsx"):
wb = openpyxl.Workbook()
sheet = wb.active
sheet.title = "Invoices"
11
headers = ["Invoice No", "Date", "Client", "Item", "Qty",
"Price", "Line Total", "Tax", "Total"]
sheet.append(headers)
wb.save("invoices.xlsx")
# --- Unit Conversion ---
def convert_to_base(qty, unit):
if unit == "gm":
return qty / 1000, "kg"
elif unit == "ml":
return qty / 1000, "ltr"
else:
return qty, unit
# --- Add Item ---
def add_item(event=None):
desc = desc_entry.get()
qty = qty_entry.get()
price = price_entry.get()
unit = unit_var.get()
if not desc or not qty or not price:
messagebox.showerror("Error", "All item fields are required.")
return
12
try:
qty = float(qty)
price = float(price)
except ValueError:
messagebox.showerror("Error", "Quantity must be a number.")
return
base_qty, base_unit = convert_to_base(qty, unit)
invoice_items.append((desc, base_qty, price, base_unit))
item_list.insert(tk.END, f"{desc} | Qty: {base_qty:.3f}
{base_unit} | Price: ₹{price:.2f}")
desc_entry.delete(0, tk.END)
qty_entry.delete(0, tk.END)
price_entry.delete(0, tk.END)
desc_entry.focus()
# --- Generate Invoice ---
def generate_invoice(event=None):
client = client_entry.get()
invoice_num = invoice_number.get()
date = date_entry.get()
if not client or not date:
messagebox.showerror("Error", "Client and Date are
required.")
13
return
if not invoice_items:
messagebox.showerror("Error", "Add at least one item.")
return
filename = f"{invoice_num}.pdf"
c = canvas.Canvas(filename, pagesize=letter)
c.setFont("Helvetica", 12)
c.drawString(50, 750, f"Invoice #: {invoice_num}")
c.drawString(50, 735, f"Date: {date}")
c.drawString(50, 720, f"Client: {client}")
c.drawString(50, 700, "Items:")
y = 680
total = 0
for desc, qty, price, unit in invoice_items:
line_total = qty * price
total += line_total
c.drawString(60, y, f"{desc} - Qty: {qty:.3f} {unit} - Price: ₹
{price:.2f} - Total: ₹{line_total:.2f}")
y -= 20
tax = total * 0.1
14
grand_total = total + tax
c.drawString(50, y - 20, f"Subtotal: ₹{total:.2f}")
c.drawString(50, y - 40, f"Tax (10%): ₹{tax:.2f}")
c.drawString(50, y - 60, f"Total: ₹{grand_total:.2f}")
c.save()
save_to_excel(invoice_num, date, client, tax, grand_total)
messagebox.showinfo("Success", f"Invoice saved as {filename}
and Excel updated.")
clear_form()
# --- Save to Excel ---
def save_to_excel(invoice_num, date, client, tax, grand_total):
wb = openpyxl.load_workbook("invoices.xlsx")
sheet = wb["Invoices"]
for desc, qty, price, unit in invoice_items:
line_total = qty * price
sheet.append([invoice_num, date, client, f"{desc} ({unit})",
qty, price, line_total, tax, grand_total])
wb.save("invoices.xlsx")
# --- Clear Form ---
def clear_form():
client_entry.delete(0, tk.END)
15
invoice_number.set(generate_invoice_number())
date_entry.delete(0, tk.END)
date_entry.insert(0, datetime.today().strftime('%Y-%m-%d'))
item_list.delete(0, tk.END)
invoice_items.clear()
# --- Enter Key Logic ---
def on_enter_press(event):
global last_enter_time
now = time.time()
if now - last_enter_time < 1: # Double press
generate_invoice()
else:
add_item()
last_enter_time = now
# --- GUI Setup ---
root = tk.Tk()
root.title("Invoice Management System (INR)")
root.geometry("600x650")
init_excel()
tk.Label(root, text="Client Name").pack()
16
client_entry = tk.Entry(root)
client_entry.pack()
tk.Label(root, text="Invoice Number").pack()
invoice_number = tk.StringVar()
invoice_number.set(generate_invoice_number())
invoice_entry = tk.Entry(root, textvariable=invoice_number,
state='readonly')
invoice_entry.pack()
tk.Label(root, text="Date (YYYY-MM-DD)").pack()
date_entry = tk.Entry(root)
date_entry.insert(0, datetime.today().strftime('%Y-%m-%d'))
date_entry.pack()
# Item Section
tk.Label(root, text="Add Item").pack()
desc_entry = tk.Entry(root)
desc_entry.pack()
desc_entry.insert(0, "Description")
qty_entry = tk.Entry(root)
qty_entry.pack()
qty_entry.insert(0, "Quantity")
17
price_entry = tk.Entry(root)
price_entry.pack()
price_entry.insert(0, "Unit Price")
tk.Label(root, text="Unit").pack()
unit_var = tk.StringVar(value="pcs")
unit_options = ["pcs", "kg", "gm", "ltr", "ml"]
unit_dropdown = tk.OptionMenu(root, unit_var, *unit_options)
unit_dropdown.pack()
desc_entry.bind("<Return>", on_enter_press)
qty_entry.bind("<Return>", on_enter_press)
price_entry.bind("<Return>", on_enter_press)
item_list = tk.Listbox(root, width=60)
item_list.pack(pady=10)
tk.Button(root, text="Add Item (Enter)",
command=add_item).pack(pady=5)
tk.Button(root, text="Generate Invoice PDF (Double Enter)",
command=generate_invoice).pack(pady=10)
root.mainloop()
18
OUTPUT
19
20
Conclusion
The Invoice Management System developed in this project
offers a comprehensive and efficient solution for managing billing
operations in small to medium-sized businesses. By integrating key
functionalities such as itemized billing, tax calculations, advanced
unit handling, and financial year-based invoice numbering, the
system simplifies the complex process of invoice generation and
recordkeeping.
Through the use of Python and libraries like Tkinter,
ReportLab, and OpenPyXL, the application ensures a smooth user
experience while maintaining the accuracy and professionalism
expected in business documentation. The ability to export invoices
in PDF format and maintain an Excel-based transaction log
enhances both usability and scalability.
Overall, this project not only demonstrates the practical
application of Python in solving real-world problems but also
emphasizes the importance of automating repetitive business tasks
to improve productivity, reduce human error, and maintain proper
financial tracking.
21
REFERENCES :
Python Programming Language: https://www.python.org/
Tkinter GUI
Documentation: https://docs.python.org/3/library/tkinter.html
ReportLab PDF Library: https://www.reportlab.com/
Openpyxl Excel Library: https://openpyxl.readthedocs.io/
Python datetime Module: https://docs.python.org/3/library/datetime.
html
JSON Data Handling: https://docs.python.org/3/library/json.html
Unit Conversion Tool: https://www.unitconverters.net/
Financial Year
(India): https://en.wikipedia.org/wiki/Fiscal_year#India
GeeksforGeeks Python
Tutorials: https://www.geeksforgeeks.org/python/
W3Schools Python Basics: https://www.w3schools.com/python/
