This project is a customer support request portal built to give users a clear and organized way to submit, track, and manage support requests. It replaces scattered communication with a single system where requests can be created, updated, and followed from start to finish.
The application connects a full frontend interface with a working backend and database, allowing users to register, log in, submit requests, and view real-time status updates. The goal was to build something that reflects how a real internal support system would function, not just a static concept.
This project was built to create a more reliable and transparent support experience. Instead of relying on disconnected messages or emails, the system provides a structured way for users to submit requests and track progress in one place. Each request is stored, updated, and tied to a user account, making it easy to review past activity and current status at any time.
The project started with defining a simple but scalable structure for handling support requests. The focus was on building a system that could manage user accounts, store request data, and clearly represent status changes without adding unnecessary complexity. From there, development moved into building the database, connecting the backend, and layering the frontend on top.
The first step was defining how the data would be organized. Since the system revolves around users and their requests, the database was designed around a one-to-many relationship, where each user can create multiple requests.
Each request stores key details like status, timestamps, and descriptions, allowing the system to track progress over time. Creating the ERD early made it easier to map how the backend would handle creating, storing, and retrieving request data.
Users enter the system through a simple account flow that allows them to register and log in. Each account is tied directly to its requests, which keeps all activity organized and specific to the user.
The focus here was keeping things straightforward. Instead of adding unnecessary steps, the goal was to make it easy for users to get into the system and immediately access their request history. This mirrors how most real applications handle authentication without overcomplicating the experience.
Once inside the system, users can submit a new support request through a structured form. Each request captures key information such as a title, category, and description, which allows the system to store and organize requests in a consistent way.
The form was designed to be simple and easy to complete. Rather than overwhelming the user with too many inputs, the goal was to collect only the information needed to clearly define the issue. This keeps the process quick while still making each request useful and actionable.
After a request is submitted, users can view and track their requests through a centralized interface. Each request is stored in the system and can be accessed individually to view its details, including status, category, and timestamps.
The focus here was clarity. Users should be able to quickly understand what they’ve submitted and where it stands without digging through unnecessary information. By keeping the layout organized and consistent, the system makes it easy to review past activity and stay informed on current requests.
The final product is a fully functional support request system with a connected frontend, backend, and database. Users can register, log in, submit requests, and view their request history through a structured interface.
This project strengthened my understanding of how frontend and backend systems work together, especially when handling real data. It also reinforced the importance of building around a clear and well-defined data structure.
Future improvements would include expanding request statuses, adding administrative controls for managing requests, and refining the user experience across different screen sizes. These updates would build on the current foundation and move the system closer to a more complete support tool.
From a technical standpoint, the application could be extended with more advanced backend logic for handling request updates and user roles, building on the existing Node.js and MySQL structure.