Contents

1. Abstract
2. Requirement Analysis
 Hardware requirements
 Software requirements
3. Application
4. Design
 Block diagram
 Explanation
5. Flowchart
6. Algorithm
7. Source Code
8. Execution Screenshots/Sample Output
9. Future Enhancement
10. Bibliography
Abstract
The Construction Company Management System is a software application
designed to simplify and automate the day-to-day operations of a construction
company. In the construction industry, managing multiple projects, workers,
suppliers, clients, and financial transactions manually can be time-consuming and
prone to errors. This system aims to overcome these challenges by providing a
centralized and efficient platform for data management.
The system is developed using Python as the front-end interface and MySQL as
the back-end database. Python is used to create a user-friendly interface that
allows users to perform essential operations such as adding, viewing, updating, and
deleting records. MySQL ensures secure, structured, and efficient storage of
company data. The integration of these two technologies enables seamless data
handling and report generation.
The system maintains key information such as:
 Project Details: Project ID, project name, location, start and end dates, status,
and assigned engineers.
 Employee Details: Employee ID, name, designation, salary, and project
assignment.
 Client Details: Client name, contact information, and associated project
records.
 Financial Records: Income, expenses, material costs, and profit/loss reports.
 Supplier and Material Management: Tracking of materials supplied,
quantity, cost, and delivery details.
Additionally, the system can generate financial summaries and progress reports
that assist management in decision-making. This helps reduce manual workload,
improve accuracy, and enhance productivity within the company.
In conclusion, the Construction Company Management System serves as an
effective tool for managing construction-related activities through digital
automation. It demonstrates the practical application of database connectivity, file
handling, and CRUD operations in Python, reflecting the real-world use of
computer technology in the construction industry.
Requirement Analysis
Hardware Requirements:
Component Minimum Requirement Recommended
Processor (CPU) Intel Core i3 / AMD equivalent Intel Core i5 or higher
RAM 4 GB 8 GB or more
Storage 500 MB free space 1 GB free space
Display 1024×768 resolution 1366×768 or higher
Input Devices Keyboard, Mouse Keyboard, Mouse
Others Internet (optional, for installing packages) –

Software Requirements:
Category Requirement Notes
Windows 10 / 11, macOS, or Windows preferred for school
Operating System
Linux submissions
Programming
Python 3.8 or higher Tested with Python 3.10+
Language
MySQL Community Server
Database Required for database storage
8.0+
mysql-connector-python, Installed via pip install -r
Python Libraries
tabulate, pandas [Link]
IDLE / VS Code / PyCharm / Any preferred Python IDE
Editor / IDE
Sublime Text works
Command Line
Command Prompt / Terminal Used to run the CLI program
Tool
For viewing exported CSV
(Optional) Excel or Google Sheets
reports
Applications
This system can be used by construction companies to:
- Maintain a list of ongoing and completed projects.
- Manage employee details and assign workers to projects.
- Track material inventory and receive low-stock alerts.
- Record financial transactions: incomes (project payments) and expenses (salaries,
purchases).
- Generate reports to support management decisions.
Design
Block Diagram:
┌──────────────────┐
│ User (CLI) │
│ ([Link] - Menu Interface) │
└────────┬─────────┘
│
▼
┌────────────────────────┐
│ Application Layer │
│ (Handles user actions & calls modules) │
├────────────────────────┤
│ [Link] [Link] │
│(CRUD operations) (Calculations) │
│ [Link] (Reports/CSV) │
└──────────┬─────────────┘
│
▼
┌────────────────┐
│ Database Layer │
│ ([Link] + MySQL Server) │
│ tables: │
│ • clients │
│ • employees │
│ • materials │
│ • projects │
│ • project_materials │
│ • project_employees │
│ • transactions │
└────────────────┘
│
 ▼
┌────────────────┐
│ Physical Storage │
│ (MySQL Database Files) │
└────────────────┘

Explanation:
Component Description / Function

Acts as the main interface for the user. Provides a menu-driven CLI to
[Link]
manage clients, employees, materials, projects, finance, and reports.

Stores database connection details (host, user, password, database name).

[Link]
Used by [Link].

Handles the connection between Python and MySQL. Provides helper

[Link] functions: get_connection(), fetch_all(), and execute() for database
operations.

Contains CRUD (Create, Read, Update, Delete) functions for each entity
[Link] (Clients, Employees, Materials, Projects, Transactions). Acts as a bridge
between the main program and the database.

Calculates financial summaries for each project and the company (Income,
[Link]
Expense, Profit/Loss).

Generates reports such as Project Reports, Company Financial Summary,

[Link]
and exports data to CSV for analysis. Uses tabulate for formatted output.

SQL script that creates the database schema and inserts sample data
db_setup.sql
(clients, employees, projects, materials, transactions).

[Link] Lists required Python libraries (mysql-connector-python, tabulate, pandas).

MySQL Stores all structured data — clients, employees, materials, projects, financial
Database transactions, etc.
Flowchart
┌────────────────┐
│ Start Program ([Link]) │
└────────┬───────┘
│
▼
┌────────────── ───┐
│ Display Main Menu │
│ [Link] [Link] │
│ [Link] [Link] │
│ [Link] [Link] [Link] │
└────────┬────────┘
│
┌────────────────────┼──────────────────┐
▼ ▼ ▼
┌────────────────┐ ┌────────────────┐ ┌────────────────┐
│ Clients Menu │ │ Employees Menu │ │ Materials Menu │
│ (Add/List/Back) │ │(Add/List/Back) │ │(Add/List/Update) │
└────────┬───────┘ └────────┬───────┘ └────────┬───────┘
│ │ │
▼ ▼ ▼
┌───────────────┐ ┌────────────────┐ ┌────────────────┐
│ Perform CRUD │ │ Perform CRUD │ │ Update Stock / Add New │
│ via [Link] │ │ via [Link] │ │ Material (MySQL ops) │
└───────┬───────┘ └────────┬───────┘ └────────┬───────┘
└──────────────┬─────────┴───────────────┬──┘
▼ ▼
┌──────────────────────┐ ┌──────────────────────┐
│ Projects Menu │ │ Finance Menu │
│ (Add/List/Materials) │ │ (Record/List/Summary) │
└──────────┬───────────┘ └──────────┬───────────┘
 │ │
▼ ▼
┌──────────────────────┐ ┌────────────────────────────┐
│ Add Project / Link │ │ Add Transaction (Income/Exp) │
│ Clients / Materials │ │ Show Project Finance Summary │
└──────────┬───────────┘ └──────────┬─────────────────┘
│ │
▼ ▼
┌──────────────────────┐ ┌────────────────────────────┐
│ Update Database via │ │ Update transactions table │
│ [Link] → [Link] → │ │ using SQL (add / fetch) │
│ MySQL tables │ └──────────┬─────────────────┘
└──────────┬───────────┘ │
▼ ▼
┌─────────────────────────────────────────┐
│ Reports Menu ([Link]) │
│ [Link] Report [Link] CSV [Link] │
└──────────────────┬──────────────────────┘
│
▼
┌─────────────────────────────────────────┐
│ Fetch data from MySQL (via [Link]) │
│ Summarize using [Link] │
│ Display tabulated or export CSV │
└──────────────────┬──────────────────────┘
│
▼
┌──────────────────┐
│ Exit / End Program │
└──────────────────┘
Algorithm
1. Start Program
2. Connect to MySQL Database using the configuration in [Link].
3. Display Main Menu with the following options:
4. 1. Clients
5. 2. Employees
6. 3. Materials
7. 4. Projects
8. 5. Finance (Transactions)
9. 6. Reports
10. 0. Exit
11. Repeat until the user selects Exit:
1. Read user's choice.
2. If choice = 1 (Clients Menu):
 Display:
 1. Add Client
 2. List Clients
 0. Back
 If Add:
 Input name, contact, email, address.
 Insert into clients table.
 If List:
 Select all records from clients.
 Display.
 Return to Main Menu.
3. If choice = 2 (Employees Menu):
  Display:
 1. Add Employee
 2. List Employees
 0. Back
 If Add:
 Input name, role, phone, salary.
 Insert into employees table.
 If List:
 Select all from employees.
 Display.
 Return to Main Menu.
4. If choice = 3 (Materials Menu):
 Display:
 1. Add Material
 2. List Materials
 3. Update Stock
 0. Back
 If Add:
 Input material name, unit, cost, and quantity.
 Insert into materials table.
 If List:
 Select all from materials.
 Display.
 If Update Stock:
 Input material ID and quantity to add/subtract.
 Update qty_in_stock in materials table.
5. If choice = 4 (Projects Menu):
 Display:
 1. Add Project
 2. List Projects
 3. Add Material Usage to Project
 0. Back
 If Add:
 Input project info (name, client_id, dates, budget,
description).
 Insert into projects table.
 If List:
 Select all from projects and show with client names.
 If Add Material Usage:
 Input project ID, material ID, quantity used.
 Calculate cost = quantity × material unit cost.
 Insert into project_materials.
 Reduce material stock.
6. If choice = 5 (Finance Menu):
 Display:
 1. Record Transaction (income/expense)
 2. List Transactions
 3. Project Financial Summary
 0. Back
 If Record:
 Input project_id (optional), type (income/expense), category,
amount, date, notes.
  Insert into transactions table.
 If List:
 Select all from transactions and display.
 If Summary:
 Calculate total income and expense from transactions.
 Compute profit = income - expense.
 Display summary.
7. If choice = 6 (Reports Menu):
 Display:
 1. Project Detailed Report
 2. Export Transactions to CSV
 3. Company Financial Summary
 0. Back
 If Project Report:
 Fetch project details, material usage, and transactions.
 Display.
 If Export CSV:
 Write all transactions to CSV file.
 If Company Summary:
 Calculate total income, total expense, profit.
 Display formatted financial table.
8. If choice = 0:
 Print "Goodbye"
 Stop Program
Source code
db_setup.sql

-- db_setup.sql
DROP DATABASE IF EXISTS construction_mgmt;
CREATE DATABASE construction_mgmt;
USE construction_mgmt;

-- clients
CREATE TABLE clients (
client_id INT AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(150) NOT NULL,
contact VARCHAR(100),
email VARCHAR(150),
address TEXT,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP);

-- employees
CREATE TABLE employees (
emp_id INT AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(150) NOT NULL,
role VARCHAR(100),
phone VARCHAR(50),
salary DECIMAL(12,2) DEFAULT 0.00,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP);

-- materials
CREATE TABLE materials (
material_id INT AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(150) NOT NULL,
unit VARCHAR(50),
unit_cost DECIMAL(12,2),
qty_in_stock DECIMAL(12,3) DEFAULT 0.0,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP);

-- projects
CREATE TABLE projects (
project_id INT AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(200) NOT NULL,
client_id INT,
start_date DATE,
end_date DATE,
budget DECIMAL(15,2) DEFAULT 0.00,
status ENUM('Planned','Ongoing','Completed','Cancelled') DEFAULT 'Planned',
description TEXT,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
FOREIGN KEY (client_id) REFERENCES clients(client_id) ON DELETE SET NULL);

-- project_materials (materials used per project)

CREATE TABLE project_materials (
pm_id INT AUTO_INCREMENT PRIMARY KEY,
project_id INT,
material_id INT,
qty_used DECIMAL(12,3) DEFAULT 0.0,
cost DECIMAL(15,2) DEFAULT 0.00,
FOREIGN KEY (project_id) REFERENCES projects(project_id) ON DELETE CASCADE,
FOREIGN KEY (material_id) REFERENCES materials(material_id) ON DELETE SET NULL);

-- transactions (financial entries: incomes and expenses)

CREATE TABLE transactions (
tx_id INT AUTO_INCREMENT PRIMARY KEY,
 project_id INT,
tx_type ENUM('income','expense') NOT NULL,
category VARCHAR(150),
amount DECIMAL(15,2) NOT NULL,
tx_date DATE DEFAULT (CURRENT_DATE),
notes TEXT,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
FOREIGN KEY (project_id) REFERENCES projects(project_id) ON DELETE SET NULL);

-- employees assigned to projects

CREATE TABLE project_employees (
pe_id INT AUTO_INCREMENT PRIMARY KEY,
project_id INT,
emp_id INT,
role_on_project VARCHAR(100),
hours_worked DECIMAL(12,2) DEFAULT 0.0,
FOREIGN KEY (project_id) REFERENCES projects(project_id) ON DELETE CASCADE,
FOREIGN KEY (emp_id) REFERENCES employees(emp_id) ON DELETE SET NULL);

-- sample inserts
INSERT INTO clients (name, contact, email, address) VALUES
('Greenfield Homes', '9876543210', 'contact@[Link]', '123 Park Lane'),
('Sunrise Builders', '9123456780', 'info@[Link]', '45 Industrial Area');

INSERT INTO employees (name, role, phone, salary) VALUES

('Rajesh Kumar', 'Site Engineer', '9000000001', 30000.00),
('Amit Sharma', 'Mason', '9000000002', 15000.00);

INSERT INTO materials (name, unit, unit_cost, qty_in_stock) VALUES

('Cement (bag)', 'bag', 350.00, 500),
('Sand (cubic meter)', 'm3', 800.00, 50),
('Bricks (1000 pcs)', 'set', 7000.00, 20);

INSERT INTO projects (name, client_id, start_date, end_date, budget, status, description)
VALUES
('Villa at Riverside', 1, '2025-02-01', '2025-10-01', 2000000.00, 'Ongoing', '3-storey
villa'),
('Commercial Complex', 2, '2025-06-15', '2026-04-01', 5000000.00, 'Planned', 'Mall
construction');

INSERT INTO project_materials (project_id, material_id, qty_used, cost) VALUES

(1, 1, 120, 120*350.00),
(1, 2, 30, 30*800.00);

INSERT INTO transactions (project_id, tx_type, category, amount, tx_date, notes) VALUES
(1, 'income', 'Milestone Payment', 500000.00, '2025-03-01', '50% initial payment'),
(1, 'expense', 'Material Purchase', 42000.00, '2025-03-05', 'Cement purchase');

[Link]

mysql-connector-python==8.0.33
tabulate==0.8.10
pandas==2.1.1

You can use pip install -r [Link] after creating virtualenv.

[Link]
# [Link]
DB_CONFIG = {
'host': 'localhost',
'user': 'root',
'password': 'your_password',
'database': 'construction_mgmt'}

[Link] — Connection helper

# [Link]
import [Link]
from [Link] import Error
from config import DB_CONFIG

def get_connection():
try:
conn = [Link](
host=DB_CONFIG['host'],
user=DB_CONFIG['user'],
password=DB_CONFIG['password'],
database=DB_CONFIG['database'])
return conn
except Error as e:
print('Error connecting to DB:', e)
raise

def fetch_all(query, params=None):

conn = get_connection()
cur = [Link](dictionary=True)
[Link](query, params or ())
rows = [Link]()
[Link]()
[Link]()
return rows

def execute(query, params=None, commit=True):

conn = get_connection()
cur = [Link]()
[Link](query, params or ())
if commit:
[Link]()
lastrowid = [Link]
[Link]()
[Link]()
return lastrowid

[Link] — Database operations

# [Link]
from db import fetch_all, execute

# CLIENTS
def add_client(name, contact=None, email=None, address=None):
q = "INSERT INTO clients (name, contact, email, address) VALUES (%s,%s,%s,%s)"
return execute(q, (name, contact, email, address))

def get_clients():
 return fetch_all('SELECT * FROM clients ORDER BY client_id')

# EMPLOYEES
def add_employee(name, role, phone=None, salary=0.0):
q = "INSERT INTO employees (name, role, phone, salary) VALUES (%s,%s,%s,%s)"
return execute(q, (name, role, phone, salary))

def get_employees():
return fetch_all('SELECT * FROM employees ORDER BY emp_id')

# MATERIALS
def add_material(name, unit, unit_cost, qty_in_stock=0.0):
q = "INSERT INTO materials (name, unit, unit_cost, qty_in_stock) VALUES
(%s,%s,%s,%s)"
return execute(q, (name, unit, unit_cost, qty_in_stock))

def update_material_stock(material_id, added_qty):

q = "UPDATE materials SET qty_in_stock = qty_in_stock + %s WHERE material_id = %s"
return execute(q, (added_qty, material_id))

def get_materials():
return fetch_all('SELECT * FROM materials ORDER BY material_id')

# PROJECTS
def add_project(name, client_id=None, start_date=None, end_date=None, budget=0.0,
status='Planned', description=None):
q = "INSERT INTO projects (name, client_id, start_date, end_date, budget, status,
description) VALUES (%s,%s,%s,%s,%s,%s,%s)"
return execute(q, (name, client_id, start_date, end_date, budget, status,
description))

def get_projects():
return fetch_all('SELECT p.*, [Link] as client_name FROM projects p LEFT JOIN clients
c ON p.client_id = c.client_id ORDER BY project_id')

# Project Materials
def add_project_material(project_id, material_id, qty_used, cost):
q = "INSERT INTO project_materials (project_id, material_id, qty_used, cost) VALUES
(%s,%s,%s,%s)"
return execute(q, (project_id, material_id, qty_used, cost))

# Transactions
def add_transaction(project_id, tx_type, category, amount, tx_date=None, notes=None):
q = "INSERT INTO transactions (project_id, tx_type, category, amount, tx_date, notes)
VALUES (%s,%s,%s,%s,%s,%s)"
return execute(q, (project_id, tx_type, category, amount, tx_date, notes))

def get_transactions(project_id=None):
if project_id:
return fetch_all('SELECT * FROM transactions WHERE project_id = %s ORDER BY
tx_date DESC', (project_id,))
return fetch_all('SELECT * FROM transactions ORDER BY tx_date DESC')

[Link] — Finance operations and summaries

# [Link]
from models import get_transactions
from db import fetch_all
from decimal import Decimal
def project_financial_summary(project_id):
rows = fetch_all('''
SELECT tx_type, SUM(amount) as total
FROM transactions
WHERE project_id = %s
GROUP BY tx_type
''', (project_id,))
summary = {'income': Decimal('0.00'), 'expense': Decimal('0.00')}
for r in rows:
summary[r['tx_type']] = Decimal(r['total'] or 0)
summary['profit'] = summary['income'] - summary['expense']
return summary

def company_financials():
rows = fetch_all('''
SELECT tx_type, SUM(amount) as total
FROM transactions
GROUP BY tx_type
''')
summary = {'income': Decimal('0.00'), 'expense': Decimal('0.00')}
for r in rows:
summary[r['tx_type']] = Decimal(r['total'] or 0)
summary['profit'] = summary['income'] - summary['expense']
return summary

[Link] — Generate reports and CSV export

# [Link]
import csv
from db import fetch_all
from finance import project_financial_summary, company_financials
from tabulate import tabulate

def project_report(project_id):
project = fetch_all('SELECT p.*, [Link] as client_name FROM projects p LEFT JOIN
clients c ON p.client_id = c.client_id WHERE p.project_id=%s', (project_id,))
if not project:
return 'Project not found'
p = project[0]
materials = fetch_all('SELECT pm.*, [Link] as material_name FROM project_materials pm
LEFT JOIN materials m ON pm.material_id = m.material_id WHERE project_id=%s',
(project_id,))
txns = fetch_all('SELECT * FROM transactions WHERE project_id=%s ORDER BY tx_date',
(project_id,))
fin = project_financial_summary(project_id)

report = {
'project': p,
'materials': materials,
'transactions': txns,
'financials': fin
}
return report

def export_transactions_csv(filename='transactions_export.csv'):
rows = fetch_all('SELECT * FROM transactions ORDER BY tx_date')
keys = rows[0].keys() if rows else
['tx_id','project_id','tx_type','category','amount','tx_date','notes','created_at']
with open(filename, 'w', newline='', encoding='utf-8') as f:
writer = [Link](f, fieldnames=keys)
 [Link]()
for r in rows:
[Link](r)
return filename

def pretty_company_financials():
fin = company_financials()
table = [['Income', fin['income']], ['Expense', fin['expense']], ['Profit',
fin['profit']]]
return tabulate(table, headers=['Type','Amount'], floatfmt='.2f')

[Link] — Menu-driven CLI

# [Link]
import sys
from models import *
from reports import project_report, export_transactions_csv, pretty_company_financials
from finance import project_financial_summary
from tabulate import tabulate

MENU = '''
Construction Company Management System
1. Clients
2. Employees
3. Materials
4. Projects
5. Finance (Transactions)
6. Reports
0. Exit
Choose: '''

def clients_menu():
while True:
print('\nClients: [Link] [Link] [Link]')
c = input('> ')
if c=='1':
name = input('Name: ')
contact = input('Contact: ')
email = input('Email: ')
address = input('Address: ')
add_client(name, contact, email, address)
print('Client added')
elif c=='2':
rows = get_clients()
print(tabulate(rows, headers='keys'))
else:
break

def employees_menu():
while True:
print('\nEmployees: [Link] [Link] [Link]')
c = input('> ')
if c=='1':
name = input('Name: ')
role = input('Role: ')
phone = input('Phone: ')
salary = float(input('Salary: '))
add_employee(name, role, phone, salary)
print('Employee added')
elif c=='2':
 rows = get_employees()
print(tabulate(rows, headers='keys'))
else:
break

def materials_menu():
while True:
print('\nMaterials: [Link] [Link] [Link] Stock [Link]')
c = input('> ')
if c=='1':
name = input('Name: ')
unit = input('Unit: ')
unit_cost = float(input('Unit cost: '))
qty = float(input('Qty in stock: '))
add_material(name, unit, unit_cost, qty)
print('Material added')
elif c=='2':
rows = get_materials()
print(tabulate(rows, headers='keys'))
elif c=='3':
mid = int(input('Material ID: '))
q = float(input('Quantity to add: '))
update_material_stock(mid, q)
print('Stock updated')
else:
break

def projects_menu():
while True:
print('\nProjects: [Link] [Link] [Link] Material Usage [Link]')
c = input('> ')
if c=='1':
name = input('Project Name: ')
client_id = input('Client ID (blank for none): ')
start = input('Start Date (YYYY-MM-DD): ')
end = input('End Date (YYYY-MM-DD): ')
budget = float(input('Budget: '))
desc = input('Description: ')
add_project(name, int(client_id) if client_id else None, start or None, end
or None, budget, 'Planned', desc)
print('Project added')
elif c=='2':
rows = get_projects()
print(tabulate(rows, headers='keys'))
elif c=='3':
pid = int(input('Project ID: '))
mid = int(input('Material ID: '))
qty = float(input('Qty used: '))
# get unit cost from materials
mats = [m for m in get_materials() if m['material_id']==mid]
if not mats:
print('Material not found')
continue
cost = qty * float(mats[0]['unit_cost'])
add_project_material(pid, mid, qty, cost)
update_material_stock(mid, -qty)
print('Material usage recorded')
else:
break

def finance_menu():
while True:
 print('\nFinance: [Link] Transaction [Link] Transactions [Link] Summary
[Link]')
c = input('> ')
if c=='1':
pid = input('Project ID (blank if general): ')
tx_type = input('Type (income/expense): ')
category = input('Category: ')
amount = float(input('Amount: '))
date = input('Date (YYYY-MM-DD, blank for today): ')
notes = input('Notes: ')
add_transaction(int(pid) if pid else None, tx_type, category, amount, date or
None, notes)
print('Transaction saved')
elif c=='2':
rows = get_transactions()
print(tabulate(rows, headers='keys'))
elif c=='3':
pid = int(input('Project ID: '))
s = project_financial_summary(pid)
print('Income: {:.2f}\nExpense: {:.2f}\nProfit: {:.2f}'.format(s['income'],
s['expense'], s['profit']))
else:
break

def reports_menu():
while True:
print('\nReports: [Link] Report [Link] Transactions CSV [Link] Financials
[Link]')
c = input('> ')
if c=='1':
pid = int(input('Project ID: '))
r = project_report(pid)
if isinstance(r, str):
print(r)
else:
print('\nProject:')
print(r['project'])
print('\nMaterials:')
print(tabulate(r['materials'], headers='keys'))
print('\nTransactions:')
print(tabulate(r['transactions'], headers='keys'))
print('\nFinancials:')
print(r['financials'])
elif c=='2':
fname = input('Filename (default transactions_export.csv): ') or
'transactions_export.csv'
fn = export_transactions_csv(fname)
print('Exported to', fn)
elif c=='3':
print(pretty_company_financials())
else:
break

def main():
while True:
c = input(MENU)
if c=='1':
clients_menu()
elif c=='2':
employees_menu()
elif c=='3':
materials_menu()
 elif c=='4':
projects_menu()
elif c=='5':
finance_menu()
elif c=='6':
reports_menu()
elif c=='0':
print('Bye')
[Link](0)
else:
print('Invalid')

if __name__=='__main__':
main()
Sample Output
Main menu:

Add clients:

Client list:

Employees list:
Material list:

Materials update:

Project list:

Project material usage:

Transaction list:
Project finance:

Company financials:

Export csv:
Future Enhancement
1. Web-Based / Cloud Deployment
o Convert the current system into a web-based application so employees
can access it from anywhere.
o Store data on the cloud for real-time synchronization across multiple
branches.
2. Mobile Application Integration
o Develop a mobile app for managers and field workers to:
 Update project progress on-site
 Mark attendance
 Upload worksite photos
3. Automated Notifications & Alerts
o Send low-stock alerts for materials automatically.
o Notify manager when a project is falling behind schedule or when
payment milestones are due.
4. Biometric Attendance System
o Integrate fingerprint or face recognition devices at work sites.
o Automatically mark employee attendance and calculate working hours
and wages.
5. GPS-Based Vehicle and Equipment Tracking
o Track company vehicles transporting materials.
o Prevent misuse and optimize fuel consumption.
6. Auto-Generated Technical & Financial Reports
o Generate:
 Monthly financial summary
 Profit/Loss report
 Material consumption charts
  Project completion progress graphs
7. Supplier & Contractor Performance Tracking
o Rate suppliers based on:
 Delivery time
 Material quality
 Cost
o Helps in selecting the best vendors.
8. AI-Based Cost Estimation & Forecasting
o Use previous project data to predict project cost and duration.
o Detect chances of cost overruns early.
9. Integration with Government Approval Portals
o Automate filing of documents for:
 Building permits
 Safety certification
 Environmental approvals
10. Customer Portal
o Allow clients to log in and:
 View project progress
 Check payment schedules
 Approve changes
Conclusion
This system has the potential to grow into a complete enterprise-level solution for
construction companies. By implementing future enhancements like mobile
accessibility, cloud architecture, biometric systems, AI forecasting, and smart
reporting, the system can significantly improve productivity, transparency, and
decision-making within the organization.
Bibliography
 Chat-GPT
 [Link]
 Sumita Arora