Online Complaint Management System

A CAPSTONE PROJECT REPORT

IS

Submitted in the partial fulfillment for the award of the degree of

BACHELOR OF TECHNOLOGY

In

ARTIFICIAL INTELLIGENCE AND DATA SCIENCE

Submitted by

NITHESH. Y (192521305)

KANISH KUMAR .V (192524361)

UNDER THE SUPERVISION OF

Dr. S. SANKAR

December – 2025
 ACKNOWLEDGEMENT

we, Nithesh.y and kanish kumar .v students of Bachelor of Technology in Artificial

Intelligence & Data Science, Institute of Computer Science and Engineering, Saveetha Institute
of Medical and Technical Sciences, Saveetha University, Chennai, hereby declare that the work
presented in this Capstone Project Work entitled "Title" is the outcome of our Bonafide work and
is correct to the best of our knowledge and this work has been undertaken taking care of
Engineering Ethics.

Nithesh . y (192521305)

Kanish kumar .v (192524361 )

 CERTIFICATE

This is to certify that the project submitted by Nithesh .y and kanish kumar.v has been
carried out under our supervision. The project has been submitted as per the requirements in the
current semester of B. Tech Artificial Intelligence & Data Science.

Teacher-in-charge

Dr. s. sankar
 Abstract
In today’s digital era, organizations and institutions require efficient systems to manage and
resolve complaints in a timely and transparent manner. The Online Complaint Management
System is a web-based application developed using Python that aims to simplify the process of
registering, tracking, and resolving complaints. The system provides a centralized platform
where users can submit complaints online without the need for physical visits or paperwork,
thereby saving time and resources for both users and administrators.

The proposed system allows users to create an account, log in securely, and submit complaints
related to various categories such as services, infrastructure, or administrative issues. Each
complaint is recorded in a database with a unique complaint ID, enabling users to track the status
of their complaints in real time. The system also allows users to upload relevant documents or
images to support their complaints. Automated notifications inform users about complaint
submission, updates, and resolution status, ensuring transparency and accountability.

From the administrative perspective, the system provides tools to manage complaints efficiently.
Administrators can view, categorize, assign, and prioritize complaints based on urgency. They
can update the complaint status, add remarks, and communicate directly with users through the
system. The use of Python frameworks such as Django or Flask ensures a robust backend, secure
authentication, and seamless interaction with the database. Python’s simplicity and flexibility
make the system scalable and easy to maintain.

The Online Complaint Management System enhances efficiency by reducing manual work,
minimizing errors, and improving response time. It also helps organizations analyze complaint
data to identify recurring issues and improve service quality. By maintaining a digital record of
all complaints and actions taken, the system promotes transparency and builds trust between
users and service providers.

In conclusion, the Online Complaint Management System using Python is an effective solution
for modern complaint handling. It offers a user-friendly interface, secure data management, and
efficient administrative control. The system can be adapted for use in educational institutions,
government offices, corporate organizations, and service-based industries, making it a versatile
and practical application for complaint management in a digital environment.
 TABLE OF CONTENTS

[Link] Title [Link]

1. Acknowledgement 2

2. Certificate 3

3. Abstract 4

4. List of Figures 7

5. List of Tables 8

6. Introduction 8

1.1 Overview

1.2 Project Objectives

1.3 Significance

1.4 Scope

1.5 Methodology Overview

7. Problem Identification and Analysis 10

2.1 Description of the Problem

2.2 Evidence of the Problem

2.3 Stakeholders
 2.4 Supporting Data/Research

8. Solution Design and Implementation 12

3.1 Development and Design Process

3.2 Tools and Technologies Used

3.3 Solution Overview

3.4 Engineering Standards Applied

3.5 Solution Justification

9. Implementation 14

4.1 Program Code

4.2 Sample Input

4.3 Output

4.4 Table for Bug Summary

10. Results and Recommendations 20

5.1 Evaluation of Results

5.2 Challenges Encountered

5.3 Possible Improvements

5.4 Recommendations

11. Reflection on Learning and Personal Development 22

 6.1 Key Learning Outcomes

6.2 Challenges Encountered and Overcome

6.3 Application of Engineering Standards

6.4 Insights into the Industry

6.5 Conclusion of Personal Development

12. Conclusion 25

7.1 Summary of Key Findings

7.2 Project Significance

13. References 27

14. Appendices 29

LIST OF FIGURES

[Link] Figure Title [Link]

4.1 Static Analysis Tool Output 19

4.2 Bug Summary Table 19

LIST OF TABLES

[Link] Table Title [Link]

3.1 Features of the Static Analysis Tool 12

4.1 Bug Summary 19

 6. Introduction
1.1 Overview
With the rapid growth of information technology, organizations are shifting from
traditional manual systems to automated digital solutions. Complaint handling is a critical
process in any organization, and manual complaint management often leads to delays,
data loss, and lack of transparency. The Online Complaint Management System is a
Python-based application designed to provide a reliable and efficient platform for users to
register complaints and for administrators to manage and resolve them effectively. This
system replaces paper-based and email-based complaint processes with a centralized
online system that improves communication, accountability, and service quality.

1.2 Project Objectives

The main objective of this project is to design and develop an online system that
simplifies the complaint registration and resolution process. The specific objectives
include:

 To allow users to submit complaints online easily and securely.

 To provide a complaint tracking mechanism using unique complaint IDs.
 To enable administrators to view, categorize, prioritize, and resolve complaints.
 To reduce manual work and paperwork using Python-based automation.
 To maintain a secure and structured database of complaints for future reference.

1.3 Significance
The significance of the Online Complaint Management System lies in its ability to
improve efficiency and transparency. By using Python programming and database
integration, the system ensures faster complaint handling and accurate record
maintenance. Users benefit from real-time updates and reduced waiting time, while
organizations gain better control over complaint resolution processes. The system also
helps in analyzing complaint trends, which can be used to improve services and decision-
making. Overall, it enhances user satisfaction and organizational productivity.
1.4 Scope

The scope of this project includes user registration, complaint submission, complaint
tracking, and administrative management. The system supports multiple complaint
categories and allows status updates such as pending, in progress, and resolved. It can be

1.5 Methodology Overview

The development of this system follows a structured methodology. Initially, system

requirements are analyzed to understand user and administrator needs. The system is then
designed using Python frameworks such as Flask or Django, with a database like MySQL
or SQLite for data storage. Coding, testing, and debugging are carried out to ensure
system reliability and security. Finally, the system is deployed and evaluated for
performance and usability, ensuring it meets the project objectives effectively.
 7. PROBLEM IDENTIFICATION AND ANALYSIS
2.1 Description of the Problem
Many organizations still rely on manual or semi-manual methods such as paper forms,
emails, or verbal communication to handle complaints. These traditional systems are
inefficient, time-consuming, and prone to errors. Complaints may be misplaced, ignored,
or delayed due to lack of proper tracking mechanisms. Users often have no way to check
the status of their complaints, leading to dissatisfaction and lack of trust in the system.
Administrators also face difficulties in organizing, prioritizing, and resolving complaints
efficiently due to scattered records and unstructured data. The absence of a centralized
system results in poor transparency and accountability.

2.2 Evidence of the Problem

The inefficiencies of manual complaint handling systems are evident in frequent delays in
response time, repeated complaints on the same issues, and poor record maintenance. In
many institutions, complaints are stored in registers or email inboxes, making retrieval
difficult. There is no automated method to monitor complaint progress or generate
reports. This often results in unresolved complaints and user frustration. Additionally,
lack of proper documentation makes it difficult for management to review past
complaints or identify recurring problems, which affects service improvement.

2.3 Stakeholders
The primary stakeholders of the Online Complaint Management System include users,
administrators, and management. Users are individuals who submit complaints and
expect timely resolution. Administrators are responsible for reviewing, categorizing,
assigning, and resolving complaints using the system. Management or organization heads
use the system to monitor performance, evaluate complaint trends, and make informed
decisions. Other stakeholders may include IT staff responsible for system maintenance
and support. Each stakeholder benefits from an organized and transparent complaint
management process.
2.4 Supporting Data / Research
Studies and surveys conducted across service-based organizations show that digital
complaint management systems significantly reduce response time and improve user
satisfaction. Research indicates that automated systems help organizations track issues
more effectively and reduce operational costs. Python-based systems are widely adopted
due to Python’s simplicity, flexibility, and strong support for database integration and
web frameworks such as Django and Flask. The growing demand for transparency and
accountability in public and private organizations further supports the need for an Online
Complaint Management System.

In conclusion, the existing manual complaint handling systems present several challenges
that affect efficiency and user satisfaction. Implementing an Online Complaint
Management System using Python addresses these issues by providing a centralized,
automated, and transparent platform for effective complaint handling.
 8. SOLUTION DESIGN AND IMPLEMENTATION
3.1 Development and Design Process

The development of the Online Complaint Management System follows a systematic and
structured approach to ensure efficiency and reliability. The process begins with
requirement analysis to identify user needs, administrative functions, and system
constraints. Based on these requirements, a system design is prepared that includes user
interface design, database structure, and system workflow. The application is developed
using Python programming, ensuring modularity and ease of maintenance. After
development, the system undergoes thorough testing to identify and correct errors.
Finally, the system is deployed and evaluated to ensure it meets the project objectives and
performs effectively.

3.2 Tools and Technologies Used

The system is developed using Python as the core programming language due to its
simplicity and flexibility. Python web frameworks such as Flask or Django are used to
handle backend operations, routing, and authentication. The database is implemented
using MySQL or SQLite to store user details, complaints, and status updates securely.
HTML, CSS, and JavaScript are used to design the front-end interface for better user
interaction. Additional tools such as Git are used for version control, and integrated
development environments (IDEs) like PyCharm or VS Code assist in coding and
debugging.
3.3 Solution Overview

The Online Complaint Management System provides a centralized platform for

complaint handling. Users can register, log in, submit complaints, and track their status
using a unique complaint ID. Administrators can view all complaints, categorize them,
assign priorities, and update their status. The system maintains a complete digital record
of complaints and actions taken, ensuring transparency. Automated notifications and
status updates improve communication between users and administrators, making the
complaint resolution process faster and more efficient.
3.4 Engineering Standards Applied
The system is developed by following standard software engineering practices. Modular
programming is used to improve code readability and reusability. Proper database
normalization ensures data integrity and avoids redundancy. Security standards such as
user authentication, role-based access control, and input validation are applied to protect
sensitive data. The system design follows usability standards to ensure a simple and user-
friendly interface. Regular testing and debugging help maintain system reliability and
performance.

3.5 Solution Justification

The proposed solution effectively addresses the limitations of traditional complaint

management systems. By using Python-based automation, the system reduces manual
effort, minimizes errors, and improves response time. The centralized design ensures
better organization and tracking of complaints. Python’s scalability allows future
enhancements such as mobile app integration, email/SMS notifications, and advanced
analytics. Therefore, the Online Complaint Management System is a cost-effective,
reliable, and efficient solution for modern complaint handling.
 9. IMPLEMENTATION
4.1 program code

The Online Complaint Management System was fully implemented in Python,

incorporating functions for complaint registration, tracking, status updating, deletion,
searching by status, and displaying complaints. The program file manages complaint
records using a combination of Linked Lists for dynamic data storage and Hashing
(Python Dictionary) for fast access and retrieval based on complaint IDs.

Each complaint is represented as a node containing the complaint ID, complainant name,
status, and a reference to the next node. The system follows a menu-driven approach,
allowing users to interactively perform operations such as registering new complaints,
tracking existing complaints, and updating complaint statuses efficiently.

The use of modular class-based functions improves code readability, simplifies

debugging, and supports easy expansion in future versions, such as database integration
or web-based deployment. This design ensures efficient complaint handling while
demonstrating practical application of data structures in real-world problem solving.

4.2 Sample Input

4.3 Sample Output

Table: Bug Summary

 10. RESULTS AND RECOMMENDATIONS

5.1 Evaluation of Results

The Online Complaint Management System developed using Python successfully achieved its
primary objectives. The system allows users to register complaints easily, generates unique
complaint IDs, and enables administrators to view and update complaint status efficiently.
Testing results show that the system performs all basic operations such as complaint submission,
display, and status update accurately. The program reduces manual effort and improves response
time compared to traditional complaint handling methods. The results demonstrate improved
organization of complaint data, better tracking, and increased transparency. Overall, the system
works as intended and provides a reliable solution for basic complaint management.

5.2 Challenges Encountered

During the development and implementation of the system, several challenges were encountered.
One major challenge was handling invalid user inputs, such as entering incorrect menu choices
or complaint IDs, which initially caused program errors. Another challenge was maintaining data
consistency while updating complaint status. Designing a simple yet effective user interface
using a console-based approach was also challenging, as it required clear instructions for users.
Additionally, the absence of database integration limited data persistence, as complaints were
lost when the program was terminated.

5.3 Possible Improvements

Although the system functions correctly, there is scope for improvement. The application can be
enhanced by integrating a database such as MySQL or SQLite to store complaints permanently.
A web-based interface using Python frameworks like Flask or Django can improve usability and
accessibility. Additional features such as user authentication, role-based access control, email or
SMS notifications, and complaint priority levels can further strengthen the system. Implementing
data analytics and report generation would help organizations analyze complaint trends and
improve service quality.

5.4 Recommendations

It is recommended that this system be implemented in institutions where complaint handling is

still manual. Organizations should consider upgrading the system to a web-based platform for
better scalability and user experience. Regular maintenance and updates should be carried out to
ensure security and performance. Training administrators and users on system usage will
improve efficiency. Future developers are encouraged to enhance the system by incorporating
advanced features such as mobile application support and cloud-based storage. With these
improvements, the Online Complaint Management System can become a comprehensive and
efficient solution for modern complaint management.
 11. Reflection on learning and personal development
6.1 Key Learning Outcomes

The development of the Online Complaint Management System using Python provided
extensive learning opportunities in both technical and personal domains. One of the
major learning outcomes was gaining a deeper understanding of Python programming
concepts such as data types, dictionaries, functions, loops, and conditional statements. I
learned how to design a menu-driven application and manage user input effectively. This
project also enhanced my understanding of problem analysis, where a real-world issue
was identified and converted into a practical software solution. Additionally, I gained
experience in documenting software projects in a structured and professional manner,
which is essential for academic and industry environments.

6.2 Challenges Encountered and Overcome

During the development of this project, several challenges were faced. One of the
primary challenges was handling incorrect user inputs, such as invalid menu options or
incorrect complaint IDs, which initially caused runtime errors and unexpected behavior.
This challenge was overcome by implementing proper validation checks and conditional
statements. Another challenge was organizing complaint data efficiently using Python
dictionaries, especially when updating and retrieving records. Through repeated testing
and debugging, I improved my logical thinking and problem-solving skills. Time
management was also a challenge, as balancing coding, testing, and documentation
required careful planning and discipline.

6.3 Application of Engineering Standards

The project was developed by following basic engineering and software development
standards. Modular programming was applied by dividing the system into functions such
as complaint registration, complaint viewing, and status updating. This improved code
readability and maintainability. Proper naming conventions were used for variables and
functions to make the code self-explanatory. Testing was performed after each functional
module to ensure accuracy and reliability. Error handling and input validation were
applied to improve system robustness. These engineering practices helped in creating a
structured, efficient, and user-friendly system.
6.4 Insights into the Industry

This project offered valuable insights into how complaint management systems are used
in real-world organizations. It highlighted the importance of digital solutions in
improving transparency, efficiency, and user satisfaction. The project also demonstrated
the growing demand for Python-based applications in the software industry due to
Python’s simplicity, scalability, and versatility. Understanding how similar systems are
implemented in government offices, educational institutions, and corporate environments
helped me appreciate the relevance of such applications in today’s technology-driven
world.
6.5 Conclusion of Personal Development

In conclusion, working on the Online Complaint Management System significantly

contributed to my personal and professional growth. The project enhanced my technical
skills, improved my confidence in Python programming, and strengthened my ability to
solve real-world problems through software solutions. It also improved my
communication and documentation skills. The knowledge and experience gained from
this project will be valuable for future academic pursuits and career development in the
software industry.
 12. CONCLUSION
7.1 Summary of Key Findings

The Online Complaint Management System developed using Python successfully meets
its intended objectives by providing an efficient and structured approach to complaint
handling. The project demonstrates that manual and traditional complaint management
methods can be effectively replaced with a digital system that improves accuracy,
transparency, and response time. The system allows users to register complaints easily,
generate unique complaint IDs, and track the status of their complaints. Administrators
can view, manage, and update complaints efficiently through a centralized platform.
The implementation results indicate that the system performs all core functions reliably,
including complaint registration, viewing, and status updates. Testing confirmed that
common errors such as invalid inputs and incorrect complaint IDs were handled
effectively through proper validation mechanisms. The use of Python programming
enabled faster development, clear logic implementation, and easy maintenance. The
system structure ensures organized data handling and reduces the chances of data loss or
duplication during operation.
7.2 Project Significance

The significance of this project lies in its practical applicability and relevance in real-
world scenarios. Complaint management is an essential process in organizations such as
educational institutions, government offices, corporate organizations, and service-based
industries. By automating this process, the Online Complaint Management System
improves efficiency, accountability, and user satisfaction. It reduces paperwork,
minimizes manual effort, and ensures timely resolution of complaints.
The project also highlights the importance of Python as a powerful and flexible
programming language for developing real-time applications. Its simplicity makes the
system easy to understand, modify, and extend. The project serves as a strong foundation
for further enhancements such as database integration, web-based deployment, user
authentication, and notification services.
 [Link]

The development of the Online Complaint Management System using Python has been
supported by a combination of textbooks, official documentation, and online educational
resources that provide both theoretical and practical insights into programming, software
engineering, and system development. The official Python documentation provided by
the Python Software Foundation was a key reference for understanding core Python
concepts, including data types, loops, functions, dictionaries, error handling, and modular
programming techniques. These resources were essential for implementing a reliable and
structured system. The book Learning Python by Mark Lutz served as a comprehensive
guide for Python programming fundamentals and practical applications, helping to
develop logic for complaint registration, status updates, and menu-driven interaction
within the system. Python for Everybody: Exploring Data Using Python 3 by Charles R.
Severance was another important source, providing guidance on applying Python to solve
real-world problems and manage user input, data storage, and processing.
For understanding the software development life cycle, system analysis, design, and
testing methodologies, Software Engineering: A Practitioner’s Approach by Roger S.
Pressman and Software Engineering by Ian Sommerville were referred to. These books
offered insight into requirement analysis, system modeling, testing strategies, and best
practices in software engineering, which were applied to design a modular, user-friendly,
and efficient complaint management system. Online tutorials and educational platforms
such as W3Schools were consulted to clarify Python syntax, error handling, and
implementation of program logic. Additionally, official framework documentation of
Django and Flask was studied to understand how Python-based applications could be
extended into web-based solutions, providing a scalable and maintainable architecture.
Together, these references provided a solid foundation for understanding both the
programming and engineering principles necessary to successfully design, implement,
and test the Online Complaint Management System. They ensured that the project
followed best practices, maintained code quality, and implemented a system capable of
handling complaints efficiently and effectively.
 [Link]

# Node for Linked List

class ComplaintNode:

def _init_(self, complaint_id, name, status):

self.complaint_id = complaint_id

[Link] = name

[Link] = status

[Link] = None

# Complaint Management System

class ComplaintManagementSystem:

def _init_(self):

[Link] = None

self.complaint_map = {} # Hashing for fast access

# Register complaint

def add_complaint(self, complaint_id, name, status="Pending"):

if complaint_id in self.complaint_map:

print("Complaint ID already exists!")

return

new_node = ComplaintNode(complaint_id, name, status)

if [Link] is None:

[Link] = new_node
 else:

temp = [Link]

while [Link]:

temp = [Link]

[Link] = new_node

self.complaint_map[complaint_id] = new_node

print("Complaint registered successfully")

# Track complaint

def track_complaint(self, complaint_id):

if complaint_id in self.complaint_map:

node = self.complaint_map[complaint_id]

print(f"Complaint ID: {node.complaint_id}")

print(f"Name: {[Link]}")

print(f"Status: {[Link]}")

else:

print("Complaint not found")

# Update complaint status

def update_status(self, complaint_id, new_status):

if complaint_id in self.complaint_map:

self.complaint_map[complaint_id].status = new_status

print("Complaint status updated successfully")

else:

print("Complaint not found")

# Delete complaint

def delete_complaint(self, complaint_id):

if complaint_id not in self.complaint_map:

print("Complaint not found")

return

temp = [Link]

prev = None

while temp:

if temp.complaint_id == complaint_id:

if prev is None:

[Link] = [Link]

else:

[Link] = [Link]

del self.complaint_map[complaint_id]

print("Complaint deleted successfully")

return

prev = temp

temp = [Link]

# Search complaints by status

def search_by_status(self, status):

found = False

temp = [Link]

print(f"\nComplaints with status '{status}':")

while temp:
 if [Link]() == [Link]():

print(f"ID: {temp.complaint_id}, Name: {[Link]}")

found = True

temp = [Link]

if not found:

print("No complaints found with this status")

# Display all complaints

def display_complaints(self):

if [Link] is None:

print("No complaints available")

return

temp = [Link]

print("\n--- All Complaints ---")

while temp:

print(f"ID: {temp.complaint_id}, Name: {[Link]}, Status: {[Link]}")

temp = [Link]

# ------------------ Menu Driven Program ------------------

cms = ComplaintManagementSystem()

while True:

print("\n==== Online Complaint Management System ====")

print("1. Register Complaint")

print("2. Track Complaint")

print("3. Update Complaint Status")

print("4. Display All Complaints")

print("5. Delete Complaint")

print("6. Search Complaint by Status")

print("7. Exit")

choice = int(input("Enter your choice: "))

if choice == 1:

cid = int(input("Enter Complaint ID: "))

name = input("Enter Complainant Name: ")

cms.add_complaint(cid, name)

elif choice == 2:

cid = int(input("Enter Complaint ID: "))

cms.track_complaint(cid)

elif choice == 3:

cid = int(input("Enter Complaint ID: "))

status = input("Enter new status (Pending/In Progress/Resolved): ")

cms.update_status(cid, status)

elif choice == 4:

cms.display_complaints()

elif choice == 5:
 cid = int(input("Enter Complaint ID to delete: "))

cms.delete_complaint(cid)

elif choice == 6:

status = input("Enter status to search: ")

cms.search_by_status(status)

elif choice == 7:

print("Exiting system...")
break

else:

print("Invalid choice! Try again")