Divyansh Kumar Verma
Undergraduate Engineering Student, Gautam Buddha University
- INTRODUCTION
The Public Grievance Prioritization System is a desktop-based software application designed to manage, prioritize, escalate, and resolve public grievances in a structured, transparent, and accountable manner. The system models a real-world administrative grievance redressal mechanism where complaints submitted by citizens are processed across multiple authority levels based on urgency, severity, and predefined escalation rules.
This project was developed as an academic and industry-aligned software system, focusing on clean architecture, real-world workflows, and long-term extensibility. The implementation involves end-to-end software engineering practices including database design, backend business logic, service-level automation, and a fully functional graphical user interface.
The primary objective of this system is to demonstrate how software systems can improve grievance handling efficiency, enforce Service Level Agreements (SLAs), ensure accountability of authorities, and maintain transparency through audit logging and escalation tracking.
- PROBLEM STATEMENT
Traditional grievance redressal systems, especially in public institutions, suffer from several systemic issues:
- Complaints are often processed manually, leading to significant delays.
- There is no objective or consistent prioritization mechanism.
- Escalation of unresolved grievances is informal or ignored.
- Accountability of authorities is poorly tracked.
- Citizens have limited visibility into the status of their grievances.
The absence of a structured and automated system results in unresolved grievances, delayed justice, inefficiency, and erosion of public trust in administrative processes.
- SOLUTION OVERVIEW
The Public Grievance Prioritization System addresses these challenges by providing:
- Digital grievance registration and storage.
- Rule-based priority calculation using severity and contextual factors.
- Enforcement of Service Level Agreements (SLAs).
- Automatic escalation of grievances when SLAs are breached.
- Comprehensive audit logging for accountability.
- Authority-based filtering and role-oriented grievance views.
The system is designed to simulate how a modern, technology-driven grievance redressal framework operates in real governance and enterprise environments.
- KEY CONCEPTS AND TERMINOLOGY
DAO (Data Access Object): A design pattern that abstracts all database operations into dedicated classes. DAO classes handle creation, retrieval, updating, and deletion of data, ensuring separation between business logic and persistence logic.
SLA (Service Level Agreement): A predefined, time-bound agreement that specifies the maximum duration within which a grievance must be acted upon at a given authority level.
Escalation: The automated transfer of a grievance from one authority level to a higher authority when the assigned authority fails to resolve it within the SLA period.
Audit Log: A permanent, immutable record of critical system actions such as grievance creation, escalation, and resolution. Audit logs provide transparency, traceability, and accountability.
Authority: An administrative level or unit responsible for addressing grievances. Each authority is identified using a unique authority identifier.
- SYSTEM ARCHITECTURE
The system follows a layered architecture to ensure modularity, maintainability, and scalability.
-
Presentation Layer:
- Implemented using JavaFX.
- Provides an interactive desktop-based graphical user interface.
- Handles user interaction and displays grievance-related data.
-
Service Layer:
- Contains core business logic.
- Handles priority calculation, SLA enforcement, and escalation rules.
- Includes automated background services.
-
Data Access Layer:
- Implemented using the DAO pattern.
- Responsible for all database interactions.
- Ensures abstraction and data integrity.
-
Database Layer:
- Implemented using SQLite.
- Stores grievances, escalation records, and audit logs.
- DATABASE DESIGN
The system uses a relational database with the following core tables:
-
grievances
- grievance_id (Primary Key)
- title
- description
- category
- severity
- status
- priority_score
- assigned_authority_id
- created_at
-
escalation_records
- escalation_id (Primary Key)
- grievance_id (Foreign Key)
- from_authority_id
- to_authority_id
- reason
- escalated_at
-
audit_logs
- log_id (Primary Key)
- grievance_id
- action
- performed_by
- timestamp
- PRIORITY CALCULATION MECHANISM
Each grievance is assigned a numerical priority score calculated using a rule-based approach that considers:
- Severity level (LOW, MEDIUM, HIGH)
- Category-based weight
- Time sensitivity
The FinalPriorityEngine computes this score, which is used to visually highlight grievances in the user interface and influence escalation decisions.
- SLA ENFORCEMENT AND AUTOMATION
The SLAEscalationService runs as a background process when the application starts.
Its responsibilities include:
- Periodically scanning unresolved grievances.
- Calculating elapsed time since grievance creation.
- Detecting SLA breaches.
- Automatically escalating grievances to higher authorities.
- Recording escalation events and audit logs.
This component simulates automated governance and enterprise-grade workflow enforcement systems.
- AUTHORITY-BASED GRIEVANCE VIEW
The system enforces authority-level visibility:
- Each authority can view only grievances assigned to them.
- Authorities can escalate grievances they are responsible for.
- Final-level authorities can resolve grievances.
The graphical interface dynamically filters grievances based on the selected authority identifier, ensuring role-based access and control.
- ESCALATION HISTORY TRACKING
Each grievance maintains a complete escalation history including:
- Previous authority
- New authority
- Reason for escalation
- Timestamp
This history is permanently stored in the database and displayed in the GUI, ensuring full traceability of grievance movement.
- AUDIT LOGGING
Every significant system action generates an audit log entry, including:
- Grievance creation
- Escalation events
- Resolution actions
Audit logging ensures accountability, transparency, and forensic traceability, which are critical in real-world administrative systems.
- USER INTERFACE DESIGN
The JavaFX-based user interface includes:
- A dashboard for navigation
- Grievance creation form
- Authority-based grievance table
- Detailed grievance information panel
- Escalation history viewer
Visual indicators such as color coding are used to represent grievance status and priority.
- TECHNOLOGY STACK
- Programming Language: Java
- GUI Framework: JavaFX
- Database: SQLite
- Architecture Pattern: Layered Architecture with DAO pattern
- Build Tool: Command-line compilation using javac
- Platform: macOS (Apple Silicon compatible)
- REAL-WORLD RELEVANCE
This system closely mirrors real-world platforms such as:
- Government grievance redressal portals
- Corporate complaint escalation systems
- Customer support ticketing solutions
It demonstrates industry-relevant concepts including automation, accountability, separation of concerns, and scalable system design.
- DEVELOPER LEARNING OUTCOMES
Through the development of this project, the author gained hands-on experience in:
- Designing and implementing layered software architectures
- JavaFX-based desktop application development
- Database schema design and JDBC-based persistence
- Background job execution and automation
- Modeling real-world administrative workflows
- Applying clean code and maintainable design principles
- FUTURE ENHANCEMENTS
- Role-based authentication and authorization
- Web-based frontend implementation
- Notification system using email or SMS
- Analytics and reporting dashboard
- REST API integration for external systems
- CONCLUSION
The Public Grievance Prioritization System is a comprehensive, real-world inspired software solution that reflects strong engineering principles, clean architecture, and practical problem-solving. The project represents significant individual effort and demonstrates the ability to design, implement, and validate a complete software system suitable for academic evaluation, professional portfolios, and technical interviews.
END OF DOCUMENT