TASK MANAGEMENT SYSTEM 2024-25

CHAPTER 1
EXECUTIVE SUMMARY
This report presents the successful completion of a Task Management System developed as
part of a Full Stack Java Development internship undertaken at A Cube, Mysuru, from 17th
February 2025 to 28th May 2025. The project aimed to design and implement an efficient,
user-friendly web application to manage tasks systematically within teams or organizations.

The Task Management System is a web-based solution built using Spring Boot (Java) for
the backend, MySQL as the relational database, and HTML, CSS, JavaScript for the
frontend. This full-stack implementation ensures seamless communication between
different application layers while offering a responsive and dynamic user interface.

The need for such a system arises from the common challenges faced by teams in tracking,
assigning, and monitoring tasks manually. These challenges often result in
miscommunication, delays, and inefficiencies in team collaboration. The developed system
automates task workflows and allows users to create, assign, edit, delete, and monitor tasks
in real-time, with role-based access for different users like administrators, managers, and
employees.

The key objectives of this project were:

 To improve team productivity through task digitization.

 To ensure clear communication and task visibility.
 To enable real-time status updates for tasks.
 To provide a secure, role-based access control mechanism.

During the internship, the project was developed following industry best practices in
software development, including modular coding, database normalization, responsive
design, and extensive testing. The result is a scalable and reliable application that serves as
a centralized platform for managing tasks, deadlines, and project progress.

Dept of CSE, GEC, CHAMARAJANAGARA. Page-1

TASK MANAGEMENT SYSTEM 2024-25

This system has been tested thoroughly in various use-case scenarios and has proven to
significantly reduce the time and effort spent on manual task tracking. It enhances
transparency, boosts accountability, and ensures that teams can function more effectively
without the need for constant follow-up and micromanagement.

In summary, the Task Management System developed during this internship not only meets
its functional goals but also reflects a strong grasp of modern web technologies and
professional software engineering practices. It serves as a practical and impactful
contribution to solving real-world team coordination challenges.

Dept of CSE, GEC, CHAMARAJANAGARA. Page-2

TASK MANAGEMENT SYSTEM 2024-25

CHAPTER 2
COMPANY PROFILE
Name A-CUBE (Alpha Ace Academy)

Address #515, 2nd Floor, Sri Annapoorneshwari Complex, Panchamantra

Road, Kuvempu Nagar, Mysuru, Karnataka 570023

Contact number +917899161862

E-mail [email protected]

Website [https://www.acubemysore.com](https://www.acubemysore.com)

Type of company Educational & Training Services

Category of the IT Training and Technical Services

company
Contact Logo `

Vision To bridge the gap between education and industry by

equipping clients and students with the tools and knowledge
needed to excel in the rapidly evolving tech landscape.
Management Mr. Manoj M V (Web Developer and MERN Stack Mentor)
Directory
Mission Empower professionals and businesses through industry-relevant
training, IT services, and digital transformation solutions.

2.2 About the Company

A-CUBE is a leading software training institute and IT service provider headquartered in

Mysore, Karnataka. The company specializes in delivering hands-on training in Full Stack
Web Development, Java, Python, Data Science, Machine Learning, and Cloud Computing.

Dept of CSE, GEC, CHAMARAJANAGARA. Page-3

TASK MANAGEMENT SYSTEM 2024-25

Alongside training, A-CUBE offers services such as software development, IT infrastructure

management, cybersecurity, and digital marketing, enabling a seamless transition from
learning to real-world implementation.

With a team of seasoned professionals from various domains, A-CUBE ensures high-quality
education combined with practical exposure. Their commitment to excellence is reflected in
workshops, project-based learning, and community-driven events like coding competitions
and free workshops.

2.3 Services Offered by the Company

2.3.1 Training Programs

Full Stack Web Development

Java Programming
Python Programming

Data Science & Machine Learning

Cloud Computing
These programs focus on practical application through project-based learning.

2.3.2 Software and IT Services

Software Development
IT Infrastructure Management

Cybersecurity Solutions

2.3.3 Digital Marketing

SEO, social media promotions, paid advertising, and more.
Let me know if you'd like this in Word format or integrated into a report.

Dept of CSE, GEC, CHAMARAJANAGARA. Page-4

TASK MANAGEMENT SYSTEM 2024-25

CHAPTER 3
WEEKLY REPORT
3.1 WEEKLY OVERVIEW REPORT
Week 1 Introduction of webpage, website, Full stack development

Week 2 Introduction of HTML

Week 3 CSS

Week 4 Bootstrap

Week 5 JavaScript

Week 6 ReactJS

Week 7 Introduction of Front-End Fundamental of Object-Oriented

Programming
Week 8 Introduction to SQL

Week 9 Spring Web Development and Data persistence theory

Week 10 Selecting Project Based on Java Full-Stack, Task Management System,

Problem Statement, Objectives

Week 11 Building Architecture

Week 12 Implementation Of Modules

Week 13 Demonstration of the Application and Result

Week 14 Project Demonstration

Dept of CSE, GEC, CHAMARAJANAGARA. Page-5

TASK MANAGEMENT SYSTEM 2024-25

CHAPTER 4
TASK PERFORMED
Introduction to Web Development and Full Stack

The internship began with an overview of websites and web pages, explaining the
differences and purposes of static and dynamic content. We were introduced to the concept
of full stack development, covering the roles of front-end, back-end, and database layers.
Discussions included popular tech stacks like MERN and Java Full Stack. Emphasis was
placed on how a full stack developer handles both client-side and server-side coding. We
explored tools used in development such as IDEs, version control systems, and frameworks.
The importance of responsive and interactive web applications was highlighted. This
foundational week set the tone for the upcoming technical learning.

HTML Fundamentals

This focused on HTML, the backbone of any web page. We learned about basic tags like
headings, paragraphs, links, lists, and tables. Structure and semantics were emphasized to
create clean and readable code. Students practiced building static pages using forms and
multimedia elements. The significance of nesting and attribute usage was discussed.
HTML5 elements and their purpose in structuring modern websites were introduced. By the
end of the week, we created small static web pages using only HTML.

Cascading Style Sheets (CSS)

CSS was introduced to enhance the appearance of HTML elements. We learned the
difference between inline, internal, and external CSS. Topics included selectors, color
schemes, fonts, borders, padding, and margins. Special focus was given to the box model
and how layout adjustments are handled. We practiced using Flexbox and Grid for layout
design. Responsive web design principles were discussed, including media queries.
Assignments included creating a styled portfolio page using CSS.

Dept of CSE, GEC, CHAMARAJANAGARA. Page-6

TASK MANAGEMENT SYSTEM 2024-25

Bootstrap Framework

This focused on Bootstrap, a popular front-end framework used for developing responsive
websites quickly. We learned about its grid system, responsive utilities, and layout classes.
Components like buttons, cards, modals, alerts, and navigation bars were explored in depth.
Students built pages using pre-built Bootstrap elements, speeding up the development
process. The use of Bootstrap icons and customization techniques was demonstrated.
Projects were created using Bootstrap for responsive and mobile-first designs. By the end of
the week, we had developed fully responsive pages.

Java Script Basics

Was dedicated to JavaScript, a scripting language used to make web pages interactive. We
started with variables, data types, operators, and control structures. Functions, arrays, and
objects were introduced for structuring logic. DOM manipulation was covered to
dynamically alter content and structure. Event handling such as onClick, onHover, and form
validation was practiced. Students built simple interactive elements like calculators and to-
do lists. This week laid the groundwork for more advanced JavaScript concepts.

ReactJS Introduction

We explored ReactJS, a JavaScript library for building user interfaces. We learned the
concepts of components, JSX syntax, props, and state. Functional and class components
were created to understand data flow and reusability. Students practiced creating dynamic
UIs using hooks such as use State and use Effect. Routing between pages using React
Router was introduced. The use of components for modular development was emphasized.
By the end, we built a mini React app to demonstrate our understanding.

Front-End Integration & OOP Basics

This week focused on integrating all front-end technologies learned so far—HTML, CSS,
JavaScript, and ReactJS. We built small web applications that connected structure, style, and

Dept of CSE, GEC, CHAMARAJANAGARA. Page-7

TASK MANAGEMENT SYSTEM 2024-25

logic cohesively. Simultaneously, we were introduced to Object-Oriented Programming

concepts like classes, objects, inheritance, polymorphism, and encapsulation. Java examples
were provided to demonstrate OOP in action. Understanding OOP was crucial for upcoming
back-end development. Practical exercises were performed to reinforce the theory.

Introduction to SQL

The focus shifted to backend and database technologies, starting with SQL. We learned
about database concepts like tables, keys, and relationships. SQL commands such as
SELECT, INSERT, UPDATE, DELETE, and JOINs were practiced. Students created and
managed databases using MySQL or PostgreSQL. Exercises included writing queries to
extract and manipulate data. The concept of normalization and database design was also
introduced. Projects involved creating relational schemas for sample applications.

Spring Boot and Data Persistence

Introduced us to Spring Boot, a Java-based framework used for building backend services.
We set up our first Spring Boot application and learned about its layered architecture.
RESTful APIs were developed to communicate with front-end applications. Spring Data JPA
was introduced for ORM and database persistence. Students connected their SQL databases
to backend services using repositories. Dependency injection, controllers, and services were
explained in depth. Simple CRUD operations were implemented to practice backend logic.

Project Selection & Planning

This week was dedicated to planning the final project—a Task Management System.
Students chose the project based on real-world utility and feasibility. The problem statement,
project scope, and objectives were clearly defined. Roles were assigned for team-based
execution. Wireframes and flow diagrams were prepared for front-end and back-end
integration. Technologies and tools for each module were finalized. Initial database schema
and architecture diagrams were drawn. This planning phase provided clarity before
development began.

Dept of CSE, GEC, CHAMARAJANAGARA. Page-8

TASK MANAGEMENT SYSTEM 2024-25

Architecture Design

the architectural design of the project was developed. The MVC (Model-View-Controller)
architecture was adopted for structuring the application. Back-end services, front-end
components, and database layers were designed. APIs were mapped for communication
between client and server. Tools like Postman were used to test API endpoints. Project
structure and file organization were standardized. This foundational setup ensured smooth
development in the coming weeks.

Module Implementation

The focused on developing the project modules as per the architecture. Students started
coding front-end components using React and connecting them to backend services. REST
APIs were implemented and tested for data exchange. Spring Boot controllers, services, and
repositories were coded. Data was stored and retrieved using JPA and SQL databases. Each
team worked on assigned modules, ensuring integration compatibility. Regular reviews
helped in identifying and resolving errors early.

Testing and Output Verification

We tested the completed application modules for functionality and correctness. Unit testing,
integration testing, and basic UI testing were performed. Bugs and errors were identified and
resolved using debugging tools. Performance improvements and code optimizations were
applied. The application was checked for data validation, error handling, and
responsiveness. Final project reports and documentation were drafted. We ensured that the
application met all objectives set in the planning phase.

Final Project Demonstration

The final week involved presenting the completed Task Management System project. Each
team demonstrated their working application and explained the technical components. A
complete walkthrough of the project was given, including front-end interfaces, backend

Dept of CSE, GEC, CHAMARAJANAGARA. Page-9

TASK MANAGEMENT SYSTEM 2024-25

functionality, and database operations. Challenges faced during development and their
solutions were shared. Feedback was received from mentors and improvements were noted.
Project deployment options were discussed, and certificates were distributed. This marked
the successful conclusion of the internship.

4.1 PROBLEM STATEMENT

In today’s fast-paced world, individuals often struggle to stay organized due to inefficient
or outdated task tracking systems. While various task management applications exist, most
either lack essential features like personalized dashboards, secure access, and CRUD
capabilities or are too complex for average users. Additionally, many solutions do not
provide responsive designs that work well across devices or do not follow modern web
development practices.
There is a pressing need for a user-friendly, full-stack application that allows users to
securely manage their daily tasks, update progress, and maintain a personalized task

dashboard accessible from any device. The lack of such an accessible and efficient system
leads to missed deadlines, unorganized workflows, and reduced productivity. The proposed

Task Management System addresses this issue by delivering a feature-rich, responsive, and
secure task tracking solution built using current industry technologies.

4.2 OBJECTIVES
The primary objectives of the Task Management System are:
 To design and implement a full-stack web application for task management.
 To develop secure user registration and authentication using backend services.
 To allow users to perform CRUD (Create, Read, Update, Delete) operations on
their tasks.
 To build a responsive frontend interface using React.js for better user experience.
 To use Spring Boot to handle backend API logic and ensure modular, scalable code.
 To integrate MySQL as the backend database for persistent task and user data
storage.

Dept of CSE, GEC, CHAMARAJANAGARA. Page-10

TASK MANAGEMENT SYSTEM 2024-25

 To demonstrate clean software architecture with proper separation of concerns

between UI, business logic, and data layers.

CHAPTER 5
SYSTEM DESIGN
System design defines the architecture, modules, data flow, and interaction between system
components. For the Task Management System, this chapter presents the overall
architecture, database schema, and key design diagrams including use case, class, and
sequence diagrams.

Dept of CSE, GEC, CHAMARAJANAGARA. Page-11

TASK MANAGEMENT SYSTEM 2024-25

5.1 SYSTEM ARCHITECTURE

 User
The User is the end client who interacts with the system through a web interface. They
access the application via a browser, where they can register, log in, create tasks, view their
task list, and perform updates or deletions. The user expects a seamless experience
managed by the frontend interface and backed by robust server-side logic.
 React Frontend (Vite)
The React Frontend, built with Vite, serves as the client-side application. It provides a
dynamic and responsive user interface composed of components like Login/Register forms
Dept of CSE, GEC, CHAMARAJANAGARA. Page-12
TASK MANAGEMENT SYSTEM 2024-25

and a Task Dashboard. It uses JavaScript and JSX to handle UI rendering, form inputs, and
client-side logic. The frontend communicates with the backend via RESTful HTTP
requests, sending user credentials, task data, and retrieving information asynchronously
using fetch or axios.
 Controller Layer
The Controller Layer is the entry point of the backend application and defines the REST
API endpoints.

AuthController manages user authentication and registration logic by processing requests

such as /auth/login and /auth/register.

TaskController handles task-related operations like creating, retrieving, updating, and

deleting tasks through endpoints like /tasks.

These controllers receive incoming HTTP requests from the frontend, delegate processing
to the service layer, and return HTTP responses.

 DTOs (Data Transfer Objects)

DTOs act as containers for transferring data between layers, especially between the
frontend and backend.

LoginDTO and RegisterDTO encapsulate user credentials and registration information.

ApiResponseDTO is a structured wrapper for API responses, allowing consistent response

formatting.

DTOs ensure that only relevant data is shared, reducing security risks and improving
clarity in API interactions.

 Service Layer
The Service Layer contains the business logic of the application.

AuthService manages authentication operations such as verifying credentials and

registering new users.

TaskService handles operations like assigning tasks to users, validating task data, and
ensuring the business rules are enforced before data is passed to the repository layer.

Dept of CSE, GEC, CHAMARAJANAGARA. Page-13

TASK MANAGEMENT SYSTEM 2024-25
This layer decouples the controller from direct database interaction and provides a
centralized place for core application logic.

 Repository Layer (JPA)

The Repository Layer interacts directly with the database using Spring Data JPA.

UserRepository and TaskRepository are interfaces that extend JpaRepository, providing

prebuilt methods for common database operations (like findAll(), save(), deleteById())
without requiring boilerplate code.

This abstraction simplifies data access and keeps the logic focused on the domain model.

 Model Layer (Entities)

Entities like UserEntity and TaskEntity represent database tables through JPA annotations.

Each instance corresponds to a row in the database, and their fields map to columns.

UserEntity holds information like username, password, and role.

TaskEntity holds details like task title, description, status, and a link to its creator.

These classes enable object-relational mapping, bridging Java objects and relational data.

 Exception Handling

The Exception Handling Layer is responsible for capturing and processing application
errors.

GlobalExceptionHandler is a centralized handler that intercepts uncaught exceptions and

formats them into user-friendly HTTP responses.

ApiException is a custom exception type for domain-specific errors, such as invalid

credentials or missing task data.

This layer ensures consistent and graceful error handling throughout the system.

 Security Layer

The Security Layer configures how requests are authenticated and authorized.

Dept of CSE, GEC, CHAMARAJANAGARA. Page-14

TASK MANAGEMENT SYSTEM 2024-25

CorsConfig sets up Cross-Origin Resource Sharing policies, allowing the React frontend to
securely communicate with the backend hosted on another domain or port.

CustomUserDetails is part of Spring Security, providing user-specific information required

during the authentication process.

Although a complete JWT setup isn't confirmed, this layer lays the foundation for future
enhancements like token-based security.

 Relational Database

The Relational Database (such as MySQL or H2) stores persistent data for the system. This
includes:

User records (credentials, roles)

Task records (titles, deadlines, ownership)

Data is accessed via the repository layer and mapped from/to entity classes. The database
ensures data integrity, relationships, and efficient querying via SQL behind the scenes.

5.2 USE CASE DIAGRAM

DESCRIPTION OF USE CASES

Use Case Description

Dept of CSE, GEC, CHAMARAJANAGARA. Page-15
TASK MANAGEMENT SYSTEM 2024-25
Register A new user signs up using username and password

Login Existing user logs into the system

View Tasks User retrieves the list of tasks assigned to them

Create Task User adds a new task with title, description, due date, etc.

Update Task User edits an existing task

Delete Task User deletes a task from the list

Logout User logs out and session/token is invalidated

Dept of CSE, GEC, CHAMARAJANAGARA. Page-16

TASK MANAGEMENT SYSTEM 2024-25

5.3 WORKFLOW FLOW CHART

Dept of CSE, GEC, CHAMARAJANAGARA. Page-17

TASK MANAGEMENT SYSTEM 2024-25

WORKFLOW DESCRIPTION

User Interaction:

The user opens the frontend in a browser and performs actions like login, register, add task,
or view tasks.

Frontend Request:

React frontend captures user input (e.g., login credentials, new task).

Sends HTTP requests (fetch or axios) to the backend via defined REST APIs.

Backend Controllers:

AuthController handles login/register.

TaskController handles task-related operations.

Controllers validate incoming requests and forward them to service layer.

Service Layer:

AuthService checks credentials or saves new users.

TaskService applies business rules and ensures data is valid before storage.

Repository Layer:

Uses Spring Data JPA to interact with the database.

Executes SQL behind the scenes (e.g., findByUsername, save(task)).

Database:

Data is persisted in a relational database (e.g., user accounts, task records).

Data is retrieved, updated, or deleted as needed.

Response Back to User:

Backend returns JSON responses to the frontend.

Frontend updates UI accordingly (e.g., displays tasks, error messages, or redirects).

Dept of CSE, GEC, CHAMARAJANAGARA. Page-18

TASK MANAGEMENT SYSTEM 2024-25

5.4 DATABASE DESIGN

Main Tables:

users (id, name, email, role)

tasks (id, title, description, status_id, user_id)

status (id, name)

Fig:5.4 E-R Daigram

A User can be assigned many Tasks (1:N relationship).

A Status (like "To Do", "In Progress", "Completed") can be associated with multiple Tasks
(1:N relationship).

Task has foreign keys: user_id → User, status_id → Status.

Dept of CSE, GEC, CHAMARAJANAGARA. Page-19

TASK MANAGEMENT SYSTEM 2024-25

CHAPTER 6
IMPLEMENTATION
6.1 OVERVIEW
The Task Management System was implemented using a structured and modular approach,
with a clear separation of concerns between the backend and frontend. The development
process leveraged modern tools and technologies suited for building scalable, interactive,
and maintainable web applications.

6.2 BACKEND IMPLEMENTATION

The backend of the application was developed using Java and the Spring Boot framework.
Spring Boot was selected for its ability to simplify the development of RESTful APIs and
provide built-in support for essential enterprise features. It allowed the project to be
structured in a layered architecture, including controllers, services, and repositories.

Spring Data JPA was used to interact with the database, allowing for smooth
communication between the application and the data storage. This abstraction made it
easier to perform database operations without writing complex SQL queries.

The development of backend logic was carried out using IntelliJ IDEA, an IDE that
supports Java and Spring Boot with powerful features such as code assistance and
debugging tools. Maven was employed to handle project dependencies and build
configuration.

Security and user authentication were handled through Spring Security, with JWT (JSON
Web Tokens) integrated to implement secure access control for different user roles (Admin
and User). These tools ensured that sensitive operations like task assignment or status
updates were restricted to authorized users only.

6.3 FRONTEND IMPLEMENTATION

The frontend of the system was built using React.js, a popular JavaScript library for
building responsive user interfaces. React allowed the UI to be divided into reusable
components, improving maintainability and scalability. The frontend was developed in
Visual Studio

Dept of CSE, GEC, CHAMARAJANAGARA. Page-20

TASK MANAGEMENT SYSTEM 2024-25

Code, which offered an efficient coding environment with built-in support for JavaScript,
React, and web development tools.

HTML and CSS were used to structure and style the UI, while JavaScript controlled the
functionality and interactivity. To manage navigation between different pages, React
Router was used, enabling a seamless single-page application experience.

To install and manage JavaScript packages, Node.js and npm were used. These tools
allowed the project to include libraries and dependencies required for styling, routing, and
API communication.

6.4 INTEGRATION AND API COMMUNICATION

The integration between frontend and backend was achieved through RESTful APIs. The
React frontend sent HTTP requests to the Spring Boot backend, which processed the logic,
interacted with the database, and returned responses. This client-server model helped
separate the UI from the business logic, making the application more modular and easier to
maintain.

API endpoints were tested using Postman, which allowed developers to simulate various
scenarios and verify that each operation—such as adding a task or updating status—
functioned correctly.

6.5 DATABASE AND DATA MANAGEMENT

During the development phase, the project used the H2 in-memory database, which was
simple to configure and useful for testing purposes. It allowed developers to quickly view
and validate data without external setup. For production environments, databases like
MySQL could be easily integrated.

Spring Data JPA mapped Java objects to database tables and managed the data access layer.
This allowed developers to perform create, read, update, and delete (CRUD) operations
with minimal effort.

Dept of CSE, GEC, CHAMARAJANAGARA. Page-21

TASK MANAGEMENT SYSTEM 2024-25

6.6 DEVELOPMENT ENVIRONMENT

The Task Management System was developed using a modern full-stack environment that
integrates backend and frontend technologies efficiently to ensure scalability,
responsiveness, and maintainability.

1. Programming Languages

Java: Used for backend development, leveraging object-oriented features and strong typing
for robust API construction.

JavaScript (ES6+): Used extensively in frontend development to create interactive user

interfaces.

HTML/CSS: Used alongside JavaScript for structuring and styling the frontend.

2. Frameworks and Libraries

Spring Boot (Java): A powerful framework used for developing the RESTful backend
services. It simplifies dependency management and supports rapid application
development.

React.js: A modern JavaScript library used for building dynamic and component-based
frontend user interfaces.

Vite: A fast and lightweight development server and build tool used to serve and bundle the
React application during development and production.

3. Tools and Platforms

Maven: A build automation and dependency management tool used for the Java backend.

Node.js & NPM: Required for managing JavaScript dependencies and building the
frontend application.

Visual Studio Code: Used as the primary code editor for frontend development due to its
powerful extensions and ease of use.

IntelliJ IDEA / Eclipse: Commonly used for Java and Spring Boot development, offering
smart code assistance and integrated build tools.

Dept of CSE, GEC, CHAMARAJANAGARA. Page-22

TASK MANAGEMENT SYSTEM 2024-25

CHAPTER 7

TESTING
Software testing is a crucial phase in the development lifecycle that ensures the system
behaves as intended under various scenarios and conditions. It serves to identify defects,
measure performance, verify compliance with user requirements, and enhance the quality
of the final product. For the Task Management System project, extensive testing was
conducted to validate both frontend and backend functionalities. The system underwent
unit testing, integration testing, system testing, performance testing, and user acceptance
testing to ensure reliability and usability. This chapter outlines the testing strategies
employed, describes the types of testing performed, discusses major issues encountered
and resolved, and presents the overall results and conclusions drawn from testing.

7.1 TESTING STRATEGY

The testing strategy followed in this project was designed to cover every component of the
system in depth. Testing began with individual units or modules and gradually moved
toward full system testing. The primary aim was to ensure that the functionalities of each
component were not only individually correct but also worked together as a coherent
whole.

Initially, unit testing was performed on backend methods using JUnit to verify the logic
and correctness of each service and repository class. After unit testing, integration testing
was applied to assess how different components, such as the frontend and backend or the
backend and database, interacted with one another. Functional testing was carried out to
ensure that the features aligned with the project requirements and specifications.

The frontend of the application was subjected to UI and usability testing by manually
interacting with each interface element. This was done to verify correct behavior under
normal and boundary inputs. Security testing was done to check for unauthorized access
and secure data transmission, particularly on login and protected routes. Performance
testing focused on the application's responsiveness under normal usage conditions.

Dept of CSE, GEC, CHAMARAJANAGARA. Page-23

TASK MANAGEMENT SYSTEM 2024-25

7.2 TESTING ENVIRONMENT AND SETUP

Testing was carried out in a local development environment, configured to closely
resemble a production system. The backend server was built using Spring Boot, which ran
on a local Tomcat server. The frontend was developed using React and executed in a
browser. The system used MySQL as its relational database, with MySQL Workbench
employed for data verification. Tools such as Postman were used for API testing, and
Chrome DevTools were used for frontend testing and debugging.

Unit tests were executed using the JUnit testing framework within the IntelliJ IDEA
environment. Version control was handled through GitHub, and changes were regularly
pushed and reviewed during development to maintain code integrity.

7.3 UNIT AND INTEGRATION TESTING

In unit testing, each method in the service layer was tested independently. For example, the
addTask, getAllTasks, updateTask, and deleteTask methods were tested with a variety of
inputs, including valid and invalid data. Mock objects were used to isolate the unit being
tested from other layers, ensuring that the test results focused solely on the logic within the
method itself.

Integration testing was performed to verify the correct interaction between the layers of the
application. The React frontend was connected to the Spring Boot backend through
RESTful APIs. Test cases were designed to ensure data sent from the frontend was
received correctly by the backend and stored or retrieved appropriately from the database.
For instance, submitting a new task from the UI was checked by verifying whether it was
successfully saved to the database and whether it was retrieved and displayed correctly in
the task list.

Common integration test scenarios included submitting valid and invalid login credentials,
creating a new task with a title and description, editing existing tasks, and deleting tasks. In
each case, the application was expected to respond with the appropriate status and updated
data.

Dept of CSE, GEC, CHAMARAJANAGARA. Page-24

TASK MANAGEMENT SYSTEM 2024-25

7.4 FUNCTIONAL AND UI TESTING

Functional testing was primarily aimed at verifying that each feature of the application
performed its intended function. This included user registration, login, logout, task
creation, task modification, and deletion. Each function was executed with both valid and
invalid data inputs to ensure robustness and error handling.

For example, during testing of the task creation form, valid inputs resulted in the addition
of the task to the list, while blank input fields triggered appropriate validation error
messages. Similarly, attempts to delete a task displayed a confirmation prompt before
removing it from the interface and the database.

UI testing was done manually by interacting with each page and observing the visual
response of the application. The layout, responsiveness, and user experience were
evaluated on different screen sizes and browsers. The application was found to perform
consistently on Chrome, Firefox, and Edge, with the UI adapting well to various screen
resolutions.

7.5 VALIDATION AND ERROR HANDLING

Form validation was a key part of the application testing. Inputs were tested to ensure that
required fields were not left blank, incorrect formats were handled properly, and
meaningful error messages were displayed. For example, trying to submit an empty login
form or a task with a missing title resulted in client-side validation errors.

Server-side validation was also tested. If a malicious user attempted to bypass client-side
checks using developer tools or API testing tools like Postman, the backend still enforced
constraints and returned appropriate HTTP error codes, such as 400 Bad Request or 401
Unauthorized.

7.6 PERFORMANCE AND SECURITY TESTING

Although the scope of performance testing was limited in a local environment, the system
was monitored for any signs of lag, delay, or unresponsiveness under normal workloads.

Dept of CSE, GEC, CHAMARAJANAGARA. Page-25

TASK MANAGEMENT SYSTEM 2024-25
The application performed efficiently, with task creation, update, and deletion operations
completing in less than one second on average.

Security testing involved verifying authentication mechanisms. Unauthorized access to

protected routes was blocked, and users could not access dashboard features without
logging in. Additionally, sensitive data such as passwords were securely hashed and not
exposed in plaintext.

Cross-Site Scripting (XSS) and SQL Injection tests were also performed. Attempts to inject
JavaScript into task fields or manipulate database queries were blocked by proper input
sanitization and use of prepared statements in the backend.

7.7 USER ACCEPTANCE TESTING (UAT)

User acceptance testing was conducted with a group of sample users who interacted with
the application and provided feedback on its functionality and ease of use. These users
included students and professionals with basic technical knowledge. Each participant was
given tasks to perform, such as registering, logging in, adding and editing tasks, and
logging out.

Feedback from users was largely positive. The interface was described as clean and
intuitive, with clearly labeled buttons and smooth navigation. Minor suggestions, such as
improving alert messages or adding confirmation prompts, were implemented during final
revisions. No major issues or confusion were reported, indicating a successful UAT phase.

7.8 COMMON ISSUES AND SOLUTIONS

Several challenges were encountered during testing, which were resolved through
debugging and redesign. One recurring issue was the frontend not displaying updated task
data after performing create or update operations. This was solved by correctly managing
the application state using React's use State and use Effect hooks.

Another issue was related to Cross-Origin Resource Sharing (CORS), which initially
prevented the frontend from communicating with the backend during development. This
was resolved by configuring CORS policies in the Spring Boot application. Validation
errors and form bugs were resolved by implementing stricter frontend checks and

Dept of CSE, GEC, CHAMARAJANAGARA. Page-26

TASK MANAGEMENT SYSTEM 2024-25

incorporating error-handling logic in the backend to return informative messages to

the user interface.

CHAPTER 8
RESULTS AND DISCUSSION
The results obtained from the development and testing of the Task Management System
demonstrate that the project successfully achieved its intended goals and met the outlined
requirements. The system was designed to provide an efficient and user-friendly platform
for managing daily tasks, including creating, updating, viewing, and deleting tasks.
Throughout the implementation and subsequent testing phases, these core functionalities
were verified to work correctly and reliably. Users were able to add new tasks by providing
relevant details, and the system promptly stored and displayed these tasks. Similarly, task
editing and deletion features functioned smoothly, with immediate updates reflected in the
user interface, offering a seamless user experience. The integration between the frontend and
backend was robust, ensuring data consistency and responsiveness.

In addition to functional correctness, the system demonstrated strong performance

characteristics. Response times for task-related operations were consistently low, usually
completing within milliseconds, even under moderate workloads. This responsiveness
contributed to the overall usability and made the application suitable for real-time task
management scenarios. The backend APIs were tested extensively using tools such as
Postman, confirming that they handled requests efficiently without any noticeable lag or
errors. Furthermore, the application maintained stability throughout extended periods of
use, indicating that the architecture and resource management were well designed.

Security aspects were also an important focus during the project. The system incorporated
secure user authentication mechanisms that prevented unauthorized access. Passwords
were stored using secure hashing techniques, ensuring that sensitive information remained
protected. Attempts to breach the system through common vulnerabilities such as SQL
injection or cross-site scripting were thwarted, thanks to the implementation of input
validation, prepared statements, and sanitization routines. These security measures ensure

Dept of CSE, GEC, CHAMARAJANAGARA. Page-27

TASK MANAGEMENT SYSTEM 2024-25
that the application can be safely used in environments where data privacy and protection
are critical.

User feedback collected during the User Acceptance Testing phase was predominantly
positive. Participants found the application intuitive and easy to navigate, praising its clean
layout and straightforward workflows. Validation messages and prompts were clear,
reducing user confusion and enhancing the overall experience. Some suggestions for
improvement were noted, such as incorporating additional features like task priority
settings, deadline reminders, and multi-user collaboration options. These features were
identified as valuable future enhancements that could extend the system’s capabilities.

RESULT
SNAPSHOT

Dept of CSE, GEC, CHAMARAJANAGARA. Page-28

TASK MANAGEMENT SYSTEM 2024-25

Dept of CSE, GEC, CHAMARAJANAGARA. Page-29

TASK MANAGEMENT SYSTEM 2024-25

CHAPTER 9
CONCLUSION AND FUTURE WORK

7.1 CONCLUSION
The Task Management System was developed as a full-stack web application using Java
(Spring Boot) for the backend, React.js for the frontend, and MySQL as the database. The
primary aim of this project was to provide a platform that enables effective task
assignment, tracking, and management between users and administrators in an organization
or team setting.

Throughout the development lifecycle, we followed a modular approach to design and

implemented critical functionalities such as user registration, authentication, role-based
access control, task creation, task updates, and data persistence. The use of JWT-based
authentication and Spring Security ensured secure access, while React enabled the
development of a dynamic and responsive user interface.

The system was tested thoroughly using unit tests, integration tests, and manual user
acceptance testing. Based on these tests, the application proved to be functional, secure,
and reliable for regular use.

In conclusion, the project successfully met its objectives:

Enabled secure user login and registration

Facilitated task assignment and tracking

Ensured data consistency and access control

Delivered a smooth and responsive user interface

Dept of CSE, GEC, CHAMARAJANAGARA. Page-30

TASK MANAGEMENT SYSTEM 2024-25

7.2 FUTURE ENHANCEMENTS

To make the system more robust and feature-rich, the following improvements are
proposed for future development:

 Task Prioritization
 Add priority levels (High, Medium, Low) for better task organization.
 Notifications and Reminders
 Implement email or SMS notifications for task deadlines or assignments.
 Real-Time Updates
 Use WebSockets to update task status in real-time across multiple clients.
 Advanced Filters and Search
 Enable task filtering based on status, date, user, or priority.
 Task Comments and Attachments
 Allow users to add comments and attach files to tasks.
 Mobile App Version
 Extend the system to a mobile platform using React Native or Flutter.
 Activity Logs and Audit Trails
 Maintain logs of user actions for auditing and traceability.

7.3 FINAL THOUGHTS

The Task Management System serves as a solid foundation for building scalable and
efficient task handling applications. With minimal setup, it can be adapted for startups,
academic groups, or teams needing structured task coordination. The project showcases
the synergy of modern web technologies in solving real-world problems effectively.

Dept of CSE, GEC, CHAMARAJANAGARA. Page-31

TASK MANAGEMENT SYSTEM 2024-25

TABLE OF CONTENT
CHAPTER 1.............................................................................................................................1
EXECUTIVE SUMMARY......................................................................................................1
CHAPTER 2.............................................................................................................................3
COMPANY PROFILE..............................................................................................................3
2.2 About the Company........................................................................................................3
2.3 Services Offered by the Company..................................................................................4
2.3.1 Training Programs...................................................................................................4
2.3.2 Software and IT Services.........................................................................................4
2.3.3 Digital Marketing.....................................................................................................4
CHAPTER 3.............................................................................................................................5
WEEKLY REPORT..................................................................................................................5
3.1 WEEKLY OVERVIEW REPORT..............................................................................5
CHAPTER 4.............................................................................................................................6
TASK PERFORMED...............................................................................................................6
4.1 PROBLEM STATEMENT.......................................................................................10
4.2 OBJECTIVES...........................................................................................................10
CHAPTER 5...........................................................................................................................11
SYSTEM DESIGN.................................................................................................................11
5.1 SYSTEM ARCHITECTURE....................................................................................11
5.2 USE CASE DIAGRAM...........................................................................................15
5.3 WORKFLOW FLOW CHART................................................................................16
5.4 DATABASE DESIGN..............................................................................................18
CHAPTER 6...........................................................................................................................19
IMPLEMENTATION.............................................................................................................19
6.1 OVERVIEW.............................................................................................................19
6.2 BACKEND IMPLEMENTATION...........................................................................19
6.3 FRONTEND IMPLEMENTATION.........................................................................19
6.4 INTEGRATION AND API COMMUNICATION....................................................20
6.5 DATABASE AND DATA MANAGEMENT...........................................................20
6.6 DEVELOPMENT ENVIRONMENT.......................................................................21
CHAPTER 7...........................................................................................................................22

Dept of CSE, GEC, CHAMARAJANAGARA. Page-32

TASK MANAGEMENT SYSTEM 2024-25

TESTING................................................................................................................................22
7.1 TESTING STRATEGY............................................................................................22
7.2 TESTING ENVIRONMENT AND SETUP.............................................................23
7.3 UNIT AND INTEGRATION TESTING..................................................................23
7.4 FUNCTIONAL AND UI TESTING.........................................................................24
7.5 VALIDATION AND ERROR HANDLING.............................................................24
7.6 PERFORMANCE AND SECURITY TESTING.....................................................24
7.7 USER ACCEPTANCE TESTING (UAT)................................................................25
7.8 COMMON ISSUES AND SOLUTIONS.................................................................25
CHAPTER 8...........................................................................................................................26
RESULTS AND DISCUSSION.............................................................................................26
RESULT.................................................................................................................................27
SNAPSHOT............................................................................................................................27
CHAPTER 9...........................................................................................................................29
CONCLUSION AND FUTURE WORK...............................................................................29
7.1 CONCLUSION.........................................................................................................29
7.2 FUTURE ENHANCEMENTS.................................................................................30
7.3 FINAL THOUGHTS................................................................................................30

Dept of CSE, GEC, CHAMARAJANAGARA. Page-33