Complaint Management
& Grievance Redressal System
College Code & Name 3135 - Panimalar Engineering College Chennai City Campus
Subject Name Full Stack with JAVA (Naan Mudhalvan)
Year and Semester IV Year & VII Semester
Project Team Id CSE07
Project Members Register No Name
1. 313522104029 DESHIKA R
2. 313522104127 MOHANAPRIYA R
3. 313522104155 SIVAHARINI S
4.
1
BONAFIDE CERTIFICATE
Certified that this VII Semester - Naan Mudhalvan Project report
“Complaint Management & Grievance Redressal System” is the bonafide
work of who carried out the project work under my
supervision.
SIGNATURE
SPoC – Naan Mudhalvan
Anna University - Naan Mudhalvan Examination held on
INTERNAL EXAMINER EXTERNAL EXAMINER
2
INDEX
CHAPTER NO CONTENT PAGE NO
ABSTRACT 4
1 INTRODUCTION 5
2 SYSTEM ANALYSIS 7
3 SYSTEM DESIGN 10
4 IMPLEMENTATION 12
5 TESTING 16
6 OUTPUT AND RESULT 18
7 CONCLUSION 22
REFERENCES 23
3
ABSTRACT
The Complaint & Grievance Management System is a comprehensive web-
based application designed to streamline the process of submitting, tracking, and
resolving complaints in organizations, educational institutions, and public services.
Traditional grievance handling is often manual, time-consuming, and prone to errors,
leading to delays, miscommunication, and reduced accountability. This system addresses
these challenges by providing a centralized and efficient platform that enhances
transparency, ensures timely resolution, and reduces administrative workload. Users can
submit complaints through a simple and intuitive interface, providing all necessary details
and tracking the progress of their complaints in real time.
Administrators can monitor all complaints using a structured dashboard, filter
them by category or priority, assign them to the appropriate staff, and update their status
to maintain an organized workflow. Staff members can efficiently manage assigned
complaints, respond promptly, and record all updates, ensuring that complaints are
addressed systematically. The frontend is developed using JSP and JSTL, combined with
HTML, CSS, and Tailwind CSS to create a modern, responsive, and visually appealing
interface that enhances user experience. The backend uses Java Servlets to handle HTTP
requests, execute business logic, and interact with a MySQL database that securely stores
user, complaint, and staff information. By integrating these technologies, the system
provides a robust, scalable, and user-friendly solution for complaint management. It
significantly reduces manual effort, improves record-keeping accuracy, and enables
efficient grievance resolution, making it an effective and practical Java full-stack project
suitable for deployment in real-world organizational settings.
4
CHAPTER 1
INTRODUCTION
The Complaint & Grievance Management System is a web-based application
developed to automate and streamline the process of handling complaints and
grievances within organizations, educational institutions, and public services. Traditional
complaint management is often manual, time-consuming, and error-prone, leading to
delayed resolutions and lack of transparency. This system provides a centralized
platform that enables users to submit complaints, track their status in real time, and
receive timely updates, while administrators can efficiently manage, assign, and monitor
complaint resolutions. By integrating a modern frontend using JSP, JSTL, HTML,
CSS, and Tailwind CSS with a robust backend using Java Servlets and MySQL
database, the system ensures efficiency, accountability, and a user-friendly experience
for all stakeholders.
1.1 Objectives
The main objectives of the Complaint & Grievance Management System are:
1. To automate the complaint submission process, eliminating manual paperwork and
reducing administrative effort.
2. To provide a centralized platform for users, staff, and administrators for effective
complaint management.
3. To enable real-time tracking of complaints, keeping users informed about the
status and resolution.
4. To allow administrators and staff to assign, monitor, and resolve complaints
efficiently.
5. To maintain a secure and organized database for storing user information,
complaints, and staff data.
6. To improve transparency, accountability, and responsiveness in the grievance
management process.
5
1.2 Scope
The scope of the system includes:
1. User Module: Users can submit complaints, track status, and view resolution
updates.
2. Administrator Module: Administrators can view all complaints, assign them to
staff, and update their resolution status.
3. Staff Module: Staff can manage assigned complaints, respond to users, and update
progress.
4. Database Management: MySQL database stores all relevant data securely,
supporting efficient retrieval and updates.
5. Web-based Accessibility: The system can be accessed through any modern
browser without additional software installation.
6. Future Enhancement: The system can be scaled to include analytics, reporting, and
notifications for improved decision-making.
6
CHAPTER 2
SYSTEM ANALYSIS
System analysis involves studying the requirements of the system to ensure proper
design, development, and deployment. It includes understanding both the hardware and
software requirements necessary for the smooth functioning of the application.
2.1 Software Requirements
2.1.1 Operating System
Windows 10/11 or any modern Linux distribution
2.1.2 Backend Software
Java JDK 1.8 or higher – Required to develop and run Java Servlets
Apache Tomcat Server – To host JSP pages and Servlets
MySQL Database – For storing users, complaints, and staff details securely
2.1.3 Frontend Software
JSP (JavaServer Pages) – To create dynamic web pages
JSTL (JavaServer Pages Standard Tag Library) – Simplifies looping and
conditional operations
HTML & CSS – Structure and styling of web pages
Tailwind CSS – For modern and responsive UI design
2.1.4 Development Tools
IDE: Eclipse, IntelliJ IDEA, or VS Code with Java support
Browser: Chrome, Firefox, or Edge for testing the application
Postman (Optional): To test API endpoints
7
2.1.5 Additional Software
Git – For version control
Maven – For dependency management and building the project
2.2 Functional Requirements
Users can submit complaints and track status.
Administrators can view, assign, and update complaints.
Staff can manage assigned complaints and provide timely updates.
Secure login for all users to maintain privacy and data integrity.
2.3 Non-Functional Requirements
Scalability – The system should support increasing users without performance
degradation.
Security – All user data and complaints must be securely stored in the database.
Usability – The interface should be simple, responsive, and easy to navigate.
Reliability – The system must perform consistently without crashes or data loss.
2.4 Hardware Requirements
The Complaint & Grievance Management System requires moderate hardware
that most modern desktops or laptops can support. Recommended specifications ensure
smooth operation and efficient handling of users.
8
COMPONENT REQUIREMENT / SPECIFICATION
Intel Core i3 or higher – A modern processor ensures smooth
Processor execution of backend Java Servlets and frontend JSP pages
without delays.
Minimum 8 GB – Adequate memory is required to run the Apache
RAM Tomcat server, MySQL database, and the web browser
simultaneously without performance issues.
Minimum 500 GB – Sufficient storage space is needed to store the
Hard Disk Storage operating system, project files, database files, and additional
software required for development and testing.
14 inches or higher, resolution 1366x768 or above – A standard
Monitor monitor with good resolution ensures clear visibility of the user
interface, development IDE, and system dashboards.
Keyboard and Mouse – Essential for navigating the system,
Input Devices entering complaint data, and managing administrative tasks
efficiently.
Internet connection – Required to access online resources, update
Network the application, and enable any web-based communication or
testing.
9
CHAPTER 3
SYSTEM DESIGN
System design defines the structure, components, and interactions of the
Complaint & Grievance Management System to ensure efficiency, scalability, and
maintainability. The system follows a three-tier architecture, consisting of the
Presentation Layer (Frontend), Business Logic Layer (Backend), and Database
Layer, each performing distinct functions while interacting seamlessly.
3.1 Architectural Overview
Presentation Layer Business Logic Layer Database Layer
(Frontend) (Backend) (MySQL)
JSP, JSTL, HTML CSS, Java Servlets, Stores Users, Complaints,
Tailwind CSS, User Authentication,Complaint Staff Data
Forms,Dashboards. Handling,Status Updates.
1. Presentation Layer (Frontend)
Built using JSP and JSTL, combined with HTML, CSS, and Tailwind CSS
for responsive and visually appealing pages.
Provides interfaces for users, administrators, and staff to submit complaints,
view dashboards, and track statuses.
2. Business Logic Layer (Backend)
Implemented using Java Servlets to handle HTTP requests and execute
business logic.
10
Responsible for authentication, complaint assignment, status updates, and
generating responses for the frontend.
3. Database Layer
MySQL database stores all user data, complaints, and staff information
securely.
Supports operations to insert, update, delete, and retrieve records efficiently,
maintaining data integrity.
3.2 System Flow
1. User Interaction: Users log in and submit complaints via JSP pages.
2. Request Handling: Java Servlets validate input, apply business rules, and process
requests.
3. Database Operations: Servlets interact with MySQL to store and retrieve complaint
data.
4. Response Delivery: Updated complaint statuses, confirmations, and dashboards are
sent back to the frontend.
3.3 Advantages of the Architecture
Modular Design: Frontend, backend, and database are separate, making
maintenance and updates easier.
Scalable: New modules or features can be added without affecting existing
functionality.
Secure: Only authorized users can access or modify complaint data.
User-Friendly: Responsive frontend ensures accessibility and a smooth user
experience across devices.
11
CHAPTER 4
IMPLEMENTATION
4.1 Introduction
The Complaint & Grievance Management System is implemented as a Java full-
stack application. The frontend uses JSP, HTML, CSS, and Tailwind CSS for interactive
user pages. The backend is built with Java Servlets that handle requests and interact with
a MySQL database using JDBC. This section presents essential code snippets with brief
explanations
4.2 Database Implementation
The database stores users, complaints, and staff details. The following schema
defines the required tables:
CREATE DATABASE complaint_db;
USE DATABASE complaint_db;
CREATE TABLE users (
user_id INT AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(100) NOT NULL,
email VARCHAR(100) UNIQUE NOT NULL,
password VARCHAR(100) NOT NULL,
role ENUM('ADMIN', 'EMPLOYEE', 'ENGINEER') NOT NULL
);
CREATE TABLE complaints (
complaint_id INT AUTO_INCREMENT PRIMARY KEY,
12
user_id INT NOT NULL,
title VARCHAR(200) NOT NULL,
description TEXT NOT NULL,
status ENUM('PENDING','ASSIGNED','RESOLVED') DEFAULT 'PENDING',
assigned_to INT,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
FOREIGN KEY (user_id) REFERENCES users(user_id)
);
The users table maintains login and role details, while the complaints table records
complaint information, status, and assignment.
4.3 Frontend Implementation (JSP Page)
The JSP page provides a simple form for users to submit complaints.
<form action="SubmitComplaintServlet" method="post">
<label>Title:</label>
<input type="text" name="title" required><br>
<label>Description:</label>
<textarea name="description" required></textarea><br>
<input type="submit" value="Submit Complaint">
</form>
This form collects complaint details and sends them to the
SubmitComplaintServlet for processing.
4.4 Backend Implementation (Servlet Example)
The servlet processes the complaint submission and inserts the data into the
database.
13
@WebServlet("/SubmitComplaintServlet")
public class SubmitComplaintServlet extends HttpServlet
{
protected void doPost(HttpServletRequest request, HttpServletResponse
response) throws ServletException, IOException
{
String title = [Link]("title");
String description = [Link]("description");
int userId =
[Link]([Link]().getAttribute("user_id").toString());
try (Connection conn = [Link]())
{
String sql = "INSERT INTO complaints (user_id, title, description) VALUES (?, ?,
?)";
PreparedStatement ps = [Link](sql);
[Link](1, userId);
[Link](2, title);
[Link](3, description);
[Link]();
[Link]("[Link]");
}
catch (Exception e) {[Link]();}}}
The servlet reads input from the JSP form, connects to the database, and stores
complaint details before redirecting the user to the complaint list.
14
4.5 Database Utility Class
A utility class is used to simplify database connections across the application.
public class DBUtil
{
private static final String URL = "jdbc:mysql://localhost:3306/complaint_db";
private static final String USER = "root";
private static final String PASSWORD = "your_password";
public static Connection getConnection() throws Exception
{
[Link]("[Link]");
return [Link](URL, USER, PASSWORD);}}
The DBUtil class ensures a single method for database connections, reducing
repetition in multiple servlets.
4.6 CSS Styling
Basic CSS is used to make the user interface clean and user-friendly.
form {
background: white;
padding: 15px;
border-radius: 8px;
width: 400px;
box-shadow: 0px 2px 5px rgba(0,0,0,0.2);
}
CSS improves readability and provides a professional look to forms and pages.
15
CHAPTER 5 TESTING
5.1 Introduction
Testing is a crucial phase in software development to ensure that the system meets
the specified requirements, works reliably, and performs as expected under different
scenarios. The Complaint & Grievance Management System was tested at various levels,
including unit testing, integration testing, system testing, and user acceptance testing.
5.2 Types of Testing
1. Unit Testing
Individual modules such as Servlets, JSP pages, and database functions were
tested.
Example: Testing the SubmitComplaintServlet to verify that user complaints are
inserted into the database correctly.
2. Integration Testing
Verified that all modules (Database, Servlets, JSP) work together.
Example: After complaint submission, the record was checked in the database and
displayed correctly on JSP pages.
3. System Testing
The entire system was tested as a whole to check whether it met functional and
non-functional requirements.
Example: Multiple users submitting complaints simultaneously to test system
response.
4. User Acceptance Testing (UAT)
Conducted with sample users (students, staff, admin).
16
Verified that the interface is user-friendly and workflows are easy to understand.
5.3 Test Cases
Test Case Description Input Expected Result
ID Output
TC01 Complaint Title + Description Complaint stored in Pass
submission DB and shown
in list
TC02 User login Valid Redirect to Pass
validation email/password dashboard
TC03 Invalid login Wrong credentials Error message Pass
displayed
TC04 Admin updates Change status to Status updated inPass
complaint status Resolved DB and reflected
on JSP
TC05 View complaint User navigates to list All complaints Pass
list page displayed
17
CHAPTER 6
OUTPUT AND RESULT
The outputs of the Complaint & Grievance Management System are the actual
screens, forms, and results generated during the execution of the application. These
outputs validate that the system functions according to the specified requirements.
18
19
20
Results
The system successfully recorded user complaints and displayed them in real
time.
Administrators were able to manage complaints by assigning and updating
statuses.
The outputs were consistent with the expected results from testing.
Overall, the system achieved its purpose of providing a transparent and
efficient complaint resolution process.
21
CHAPTER 7
CONCLUSION
The Complaint & Grievance Management System was successfully developed and
implemented as a web-based application to streamline the process of submitting,
tracking, and resolving complaints. The project replaced traditional manual processes
with an automated, centralized platform that ensures efficiency, transparency, and
accountability.
The system allows users to easily submit complaints and monitor their progress,
while administrators and staff can efficiently manage, assign, and resolve grievances. The
use of JSP, Servlets, and MySQL provided a reliable Java full-stack architecture, while
CSS and Tailwind CSS enhanced the user interface with a modern and responsive design.
Through testing and evaluation, the system was proven to perform effectively,
meeting both functional and non-functional requirements. It minimized errors, reduced
manual effort, and provided timely updates, resulting in a user-friendly experience for all
stakeholders.
In conclusion, the Complaint & Grievance Management System is a robust and
scalable solution that addresses real-world challenges in grievance handling. It
demonstrates the practical application of Java full-stack technologies and contributes to
improving organizational workflow, accountability, and customer satisfaction.
22
REFERENCES
1. Elmasri, R., & Navathe, S. B., Fundamentals of Database Systems, 7th
Edition, Pearson, 2016.
2. GeeksforGeeks, Java JDBC MySQL Tutorial. Available at:
[Link]
3. Mozilla Developer Network (MDN), CSS Reference. Available at:
[Link]
4. MySQL Documentation, MySQL Reference Manual. Available at:
[Link]
5. Oracle, JavaServer Pages (JSP) Technology. Available at:
[Link]
6. Oracle, Java™ Platform, Standard Edition Documentation. Available at:
[Link]
7. Pressman, R. S., Software Engineering: A Practitioner’s Approach, 8th
Edition, McGraw-Hill, 2015.
8. Sommerville, I., Software Engineering, 10th Edition, Pearson, 2016.
9. TutorialsPoint, Servlets and JSP Tutorial. Available at:
[Link]
10. W3Schools, JSP Tutorial. Available at:
[Link]
23