Group Report
Group Report
ON
ROLE BASED EMPLOYEE MANAGEMENT SYSTEM
USING MERN STACK
Submitted in partial fulfilment of the requirements for the degree of
BACHELOR OF TECHNOLOGY
IN
COMPUTER SCIENCE AND ENGINEERING
BY
K. PRAVALLIKA (2101337011)
AKASH BEHERA(2221337001)
L. DINESH FANINDRA(2101337016)
CERTIFICATE
Date:
This is to certify that the project report entitled “ROLE BASED
EMPLOYEE MANAGEMENT SYSTEM USING MERN STACK” being
submitted by Prabin Ballav Panigrahi (2101337018), Ritesh Kumar Panda
(2101337020), [Link] (2101337011), Akash Behera(2221337001), Rajiv
Lochan Chatara (2221337004), KL Ganesh Sai Bhanu (2101337012), Rupesh
Singh Thakur (2101337024), L. Dinesh Fanindra (2101337016) in partial
fulfilment if the requirement of the award of the degree Bachelor of
Technology in Computer Science and Engineering is Bonafide work carried out
at Vikash Institute of Technology, Bargarh, Odisha under my supervision.
The matter embodied in this thesis is original and has not been submitted
for award of any other degree.
Supervisor HOD
Ms. Alina Kumari Swain Dr. Girish Padhan
Assistant Professor, CSE Dept. of CSE
External Examiner
Principal ,VIT
Dr. Purnendu Mishra
DECLARATION
We hereby declare that the project entitled “ROLE BASED EMPLOYEE
MANAGEMENT SYSTEM USING MERN STACK” is a sterling project
report which is submitted by us, the student of 8th Semester B. Tech of
Computer Science and Engineering, Bargarh of Vikash Institute of Technology,
Bargarh under the guidance of Ms. Alina Kumari Swain, Assistant Professor,
CSE, Vikash Institute Of Technology, Bargarh is original and this has not been
submitted to anywhere else for the award of any other degree.
I
ACKNOWLEDGEMENT
Last but not the least; we want to acknowledge the contribution of our family
members and friends, for their constant, never-ending motivation and valuable
help directly or indirectly in the completion of our project work.
II
ABSTRACT
Employees are the backbone of any company. Often employee data such as
personal details of employees, salary, leaves, and work allocations are managed
using manual methods. These manual methods generate a lot of paperwork and
make it complex to effectively manage the tasks. Most of the computerized
systems proposed for employee management mainly focuses only on attendance
management, leave management and salary management. This paper proposes a
web-based Employee Management System solution to address the difficulties
faced.
The system will address the shortcomings of the existing systems and provide
functions to manage employee data effectively. It will use trending technologies
such as React JS, Node JS, Express JS, and MongoDB as the database which
are faster and more user friendly compared to the technologies proposed in the
literature.
The system will use the concepts of distributed systems, client server
architecture and show features of 3-tier architecture. The paper concludes that
the proposed system addresses the shortcomings of the similar systems
proposed in the literature but should be further improved by studying the subject
area. Further research should be done to provide more features related to
managing employee data and to provide a responsive design that can be
accessed through mobile devices as well.
III
TABLE OF CONTENTS
DECLARATION …………………………………………………………………………....I
ACKNOWLEDGEMENT …………………………………………………….
…………...II
ABSTRACT …………………………………………………………………………...…..III
TABLE OF CONTENTS ……………………………………………………………...
…..IV
LIST OF FIGURES ……………………………………………………..……………...…VI
CHAPTER 1 : INTRODUCTION ……………………………………..
………………......1
1.1 INTRODUCTION ………………………………………..………………...
….1
1.2 PROJECT BACKGROUND ……………………………..……………..
…….2
1.3 OBJECTIVES OF THE PROJECT …………………………………...….
…..3
1.4 SCOPE AND LIMITATIONS ………………………..….……………..
……..4
1.5 SIGNIFICANCE OF THE PROJECT ………………………………...…..…
10
CHAPTER 2 : LITERATURE REVIEW
………………………………………………...11
2.1 OVERVIEW OF RELEVANT
WORK…………………………………….....11
2.2 RELATED STUDIES AND
PROJECT……………………………………...12
2.3 KEY CONCEPTS AND TECHNOLOGIES
………………………………...13
CHAPTER 3 : PROJECT PLANNING
…………………………………………………..16
3.1 PROBLEM IN EXIXTING SYSTEM
………………………………………..16
3.2 KEY MODULES AND FUNCTIONALITIES ………………………..…….16
3.3 TARGET AUDIENCE ………………………………………………...
……..17
CHAPTER 4 : SYSTEM ARCHITECTURE ……………………………………...
……..18
4.1 FRONTEND SYSTEM ARCHITECTURE…………………………..
……….18
4.2 SERVER SIDE ARCHITECTURE ……………………………………….
….25
4.3 DATABASE DESIGN ARCHITECTURE………..……………………….
….31
4.4 ERROR HANDLING AND LOGGING …………..…………………….
…...32
4.5 SECURITY AND DEPLOYMENT ……………………………………….…
33
IV
V
LIST OF FIGURES
CHAPTER 1
VI
INTRODUCTION
1.1 Introduction
In today’s fast-paced digital era, managing employee data efficiently is crucial for
organizational success. The Employee Management System (EMS) is designed to simplify
employee data handling, improve record-keeping, and enhance workflow efficiency.
Traditional management methods involve manual record-keeping, spreadsheets, and paper
files, which are prone to human error, redundancy, and inefficiencies. A modern, web-based
EMS offers a centralized platform where administrators, HR personnel, and employees can
manage records, monitor performance, and streamline administrative tasks.
The EMS is developed using the MERN (MongoDB, [Link], [Link], [Link]) stack, a
powerful combination of technologies that provides a full-stack JavaScript-based solution.[1]
This system leverages the flexibility of MongoDB for efficient data storage, [Link] and
[Link] for handling backend logic, and [Link] for building an interactive user interface.
The system enables secure authentication, real-time data updates, and easy access to
employee details, ensuring an optimal user experience.
The MERN stack is an ideal choice for developing a modern EMS due to its robust
capabilities and seamless integration across components. The system operates as a single-
page application (SPA), where [Link] dynamically updates the UI based on user actions
without requiring full-page reloads. The backend, powered by [Link] and [Link],
handles business logic and ensures smooth communication with the MongoDB database. This
technology stack provides real-time, efficient, and scalable solutions for employee
management.
With the rise of cloud computing and web-based applications, businesses have begun
adopting software solutions that allow remote access to employee records. Many existing
systems are either expensive or lack customization options, leading to the need for a cost-
effective and scalable employee management solution.
The EMS project outlined in this report was initiated in response to these challenges. It is
aimed at replacing outdated manual processes with a modern software solution that can
streamline HR operations, reduce administrative overhead, and enhance the overall employee
experience. By incorporating secure data management practices and providing real-time
reporting capabilities, the system empowers HR professionals to make informed decisions
quickly.
2
Key Points in the Background:
Implementing Secure Authentication: Ensuring that only authorized users have access
to sensitive employee information through role-based authentication mechanisms
using JWT (JSON Web Tokens).
By achieving these objectives, the EMS will provide a comprehensive and flexible solution to
modern organizations looking to improve employee data management.
The EMS will implement role-based access control (RBAC) to ensure that different users
have appropriate access levels based on their roles. The system will support the following
user roles:
Administrators: Have full access to the system, including the ability to add, update, or
delete employee records, configure system settings, and manage user roles.
HR Personnel: Can manage employee data, approve leave requests, and generate
reports but do not have access to system configuration.
Employees: Can view their personal information, mark attendance, apply for leave,
and access performance reviews. They have limited access to the system.
4
2. Employee Database
The system will provide a centralized and secure database for storing and managing
employee information. Key features include:
Search and Filter: HR personnel can search and filter employee records based on
various criteria (e.g., department, job role).
The database will be designed to handle large volumes of data while ensuring data integrity
and security.
3. Leave Management
The EMS will include robust features for tracking employee attendance and managing leave
requests:
Attendance Tracking: Employees can mark their attendance daily using a simple
interface. Managers can view real-time attendance reports.
Leave Management: Employees can apply for leave (e.g., sick leave, vacation)
through the system. Managers can approve or reject leave requests, and employees
can track their leave balances.
4. Performance Reports 5
The system will provide tools for evaluating and analysing employee performance:
Analytics: The system will generate monthly and yearly performance reports,
including visualizations such as charts and graphs.
Employee Access: Employees can view their performance reviews and track their
progress over time.
This feature will enable organizations to make data-driven decisions and improve employee
performance.
5. API Integration
The EMS will include a secure RESTful API for seamless communication between the
frontend and backend. Key features of the API include:
CRUD Operations: APIs for creating, reading, updating, and deleting employee
records.
Authentication: Secure APIs for user login and role-based access control.
Scalability: The API will be designed to handle increasing numbers of users and
requests.
The API will ensure that the system is modular and can be extended or integrated with other
systems in the future.
6
6. Responsive UI
The system will feature a user-friendly and mobile-responsive design to ensure accessibility
across devices:
Intuitive Navigation: Easy-to-use menus and interfaces for all user roles.
Mobile Compatibility: The system will be fully functional on smartphones and tablets,
allowing employees and managers to access it on the go.
Customizable Themes: Users can choose from different themes to personalize their
experience.
7. Security Features
Authentication: Secure login using JWT (JSON Web Tokens) and password
encryption using B crypt.
Data Encryption: Sensitive data will be encrypted both in transit and at rest.
These features will ensure that the system complies with data protection regulations and
safeguards employee information.
While the EMS provides a robust set of features, it has certain limitations that should be
acknowledged. These limitations highlight areas for future improvement and expansion:
The current version of the EMS does not include functionality for managing employee
salaries or payroll processing. This means:
2. No Offline Functionality
The EMS is a web-based application that requires an active internet connection to function.
This limitation includes:
Employees and managers cannot access the system or perform tasks without an
internet connection.
Future Enhancement: Developing an offline mode with local data storage and
synchronization capabilities would improve accessibility.
At present, the EMS does not integrate with third-party tools or software, such as:
Future Enhancement: Adding APIs or plugins for third-party integrations would enhance the
system's functionality and interoperability
Users who are unfamiliar with web-based systems or technology may face challenges in
adopting the EMS. This includes:
Employees and managers may require training to use the system effectively.
While the EMS is designed to handle moderate numbers of users, it may face scalability
issues in larger organizations with thousands of employees. This includes:
6. Limited Customization
The current version of the EMS offers limited customization options for organizations with
unique requirements. This includes:
Future Enhancement: Adding customizable workflows, templates, and reporting tools would
make the system more adaptable to diverse organizational needs.
The EMS relies on external services for hosting, database management, and deployment. This
includes:
Organizations adopting this EMS will benefit from a streamlined workflow, better data
management, and increased operational efficiency. The use of the MERN stack ensures a
high-performing, modern, and scalable web application that meets the evolving needs of
businesses in the digital age.
10
CHAPTER 2
LITERATURE REVIEW
Employee Management Systems (EMS) have evolved significantly over the years,
transitioning from traditional paper-based record-keeping to sophisticated digital solutions.
The demand for efficient, secure, and scalable employee management solutions has led to the
adoption of web-based applications that offer real-time data access, automation, and
integration capabilities.
Another major advantage of modern EMS solutions is their ability to integrate with third-
party applications, including payroll systems, attendance tracking, and performance
evaluation tools. Research shows that integrating these functionalities into a single platform
reduces administrative burden and enhances productivity. Moreover, AI-powered analytics in
EMS solutions provide predictive insights into employee performance, turnover trends, and
workforce planning.
12
2.3 Key Concepts and Technologies
The development of a MERN-based EMS involves several key concepts and technologies,
including:
2.3.1 MongoDB
MongoDB is a popular open-source NoSQL database designed for flexibility, scalability, and
high performance. Unlike traditional relational databases that store data in tables with fixed
schemas, MongoDB uses a document-oriented model where data is stored in JSON-like
BSON (Binary JSON) format. This allows developers to store complex and varying data
structures in a single collection without predefined schemas. Collections in MongoDB are
analogous to tables in SQL, and documents are similar to rows, but much more dynamic.
MongoDB is well-suited for modern applications that require rapid development, handling of
large volumes of unstructured or semi-structured data, and easy horizontal scaling. Features
like automatic sharding, replication, and indexing make MongoDB a powerful choice for
building scalable and resilient applications. It is widely used in web and mobile development,
especially in full-stack environments like the MERN (MongoDB, Express, React, [Link])
stack.
2.3.2 [Link]
[Link] is a minimal and flexible [Link] web application framework that provides a
robust set of features for building web and mobile applications. It simplifies the process of
handling HTTP requests, routing, middleware integration, and server-side logic, making it a
popular choice for backend development. Express acts as a lightweight layer on top of
[Link], helping developers create APIs and web servers efficiently. It supports various
middleware functions that can be used to process requests, authenticate users, handle errors,
and more. Express is also unopinionated, meaning it gives developers the freedom to
structure their applications however they like. Because of its simplicity, speed, and
scalability, [Link] is widely used in modern web development and serves as the backend
framework in the popular MERN (MongoDB, Express, React, [Link]) stack. Middleware
support in [Link] enhances authentication, request validation, and error handling. Its
13
ability to manage multiple HTTP requests makes it ideal for large-scale applications like an
EMS.
2.3.3 [Link]
[Link] is a powerful and widely-used JavaScript library for building user interfaces,
particularly single-page applications (SPAs). Developed and maintained by Facebook, React
allows developers to create fast, interactive, and dynamic web applications using a
component-based architecture. Each component in React represents a reusable piece of the
UI, making the development process more efficient and organized. One of its core features is
the Virtual DOM, which optimizes updates to the real DOM, resulting in better performance
and smoother user experiences. React also supports the use of hooks, which allow developers
to manage state and side effects in functional components more easily. Its ecosystem is vast,
with tools like React Router for navigation and libraries like Redux or Context API for state
management. React is an essential part of the MERN stack (MongoDB, Express, React,
[Link]), and is favored by developers for its speed, modularity, and developer-friendly
features.
2.3.4 [Link]
[Link] is a JavaScript runtime that enables server-side execution of code. It provides a non-
blocking, event-driven architecture that improves application scalability. Using [Link] for
EMS development ensures seamless integration between frontend and backend. The event-
driven model is particularly useful for real-time features such as notifications, attendance
tracking, and live chat [Link] is particularly well-suited for real-time applications,
such as chat applications and streaming services, due to its event-driven, non-blocking I/O
model. This architecture allows it to handle multiple requests concurrently, making it efficient
and scalable. While primarily used for backend development. Its package manager, npm
(Node Package Manager), provides access to a massive ecosystem of libraries and tools that
speed up development. [Link] is also known for its speed, efficiency, and ability to handle
large volumes of data with minimal overhead.
14
RBAC is a security model that restricts access based on user roles and permissions.
Implementing RBAC in EMS ensures that only authorized personnel can modify sensitive
employee records, enhancing data security. For example, HR managers can edit employee
details, while general employees can only view their personal information. RBAC also plays
a critical role in audit logging and compliance with data protection regulations.
RESTful APIs facilitate communication between different system components. Secure API
endpoints enable data retrieval, authentication, and interaction with third-party applications
such as payroll systems and attendance tracking tools. The modularity of APIs in a MERN-
based EMS ensures flexibility, allowing organizations to integrate external HR tools without
modifying core functionalities.
Secure authentication mechanisms, such as JWT (JSON Web Tokens), ensure that only
verified users can access the EMS. Multi-factor authentication (MFA) and OAuth integrations
further enhance security. Implementing secure authentication mechanisms prevents
unauthorized access and protects sensitive employee information.
CHAPTER 3
15
PROJECT PLANNING
Employees face difficulties in accessing their own data or applying for leave.
The goal of this project is to develop a modern, web-based Employee Management System
(EMS) using the MERN stack. The system will automate and streamline HR processes,
providing a centralized platform for managing employee data, tracking attendance, handling
leave requests, and evaluating performance.
Leave Management
Employees can apply for leave (sick leave, vacation, etc.).
Department management
16
Admin can add department and also assign the department to employee.
Admin can change the description of the department.
Salary Management
Admin can assign salary to the employee with details like basic salary, bonus ,
deduction and pay date.
Employee can only see the salary history in their dashboard
HR Managers
Employees
Need to view their profiles, mark attendance, and apply for leave.
Administrators
The system will be designed to cater to the needs of these user groups, ensuring a seamless
and intuitive user experience.
17
CHAPTER 4
SYSTEM ARCHITECTURE
4.1.1 Objective
The frontend system is designed to:
Deliver an interactive and dynamic user experience.
Support modern web application standards such as single-page application (SPA)
architecture.
Optimize developer productivity through hot module replacement, modular code
organization, and reusable components.
Ensure visual consistency and responsiveness across all devices using Tailwind CSS.
Maintain high standards for code quality, readability, and maintainability using
ESLint.
Vite: A modern frontend build tool that offers instant server start, lightning-fast HMR
(Hot Module Replacement), and optimized builds using native ES modules.
Consistency and Quality: Code linting and formatting rules are enforced project-wide
to maintain a consistent codebase and improve collaboration among developers.
+--------------------+
19
| Browser |
+--------------------+
|
| HTTP Requests / HMR
v
+-----------------------------+
| React Components & JSX |
| ([Link], Pages, UI) |
+-----------------------------+
|
| Built using Vite + Plugins
v
+-----------------------------+
| Vite Dev Server / Build |
| (HMR, Fast Refresh, |
| ES Module Optimization) |
+-----------------------------+
|
| Injected Tailwind CSS
v
+-----------------------------+
| Styled HTML/CSS/JS Output |
| (Optimized Static Assets) |
+-----------------------------+
|
| Hosted via CDN or Server
v
+--------------------+
| End User Device |
+--------------------+
Production Build:
o Using npm run build, Vite bundles the application into highly optimized static
assets.
o The final output in the dist/ folder is ready to be served by a web server or
deployed to platforms like Vercel or Netlify.
Key Interactions:
React Components are the building blocks of the UI.
Vite handles real-time code transformation and bundling.
Tailwind CSS applies scoped and responsive styles efficiently.
ESLint and optional formatters ensure code correctness and consistency.
21
4.1.7 File Structure and Project Layout
The structure of the frontend codebase follows a modular design pattern, enabling separation
of concerns and scalability. Below is the primary layout:
├── public/
│ └── [Link] # Root HTML template
├── src/
│ ├── assets/ # Static files like images or icons
│ ├── components/ # Reusable UI components (e.g., Button, Card)
│ ├── pages/ # Page-level components (e.g., Home, Dashboard)
│ ├── [Link] # Root React component
│ ├── [Link] # App entry point
│ └── [Link] # Tailwind base styles
├── .eslintrc # ESLint configuration
├── [Link] # Tailwind CSS config
├── [Link] # Vite configuration file
├── [Link] # Project metadata and dependencies
└── [Link] # Project documentation
Component Classification
Atomic Components: The smallest reusable UI pieces (e.g., Button, Input, Avatar).
Molecular Components: Combinations of atomic components (e.g., FormField,
CardHeader).
Organisms: More complex UI sections composed of molecular/atomic components
(e.g., UserCard, Sidebar).
Pages: Top-level layouts tied to routes (e.g., HomePage, DashboardPage).
State Management
Components primarily use React Hooks (useState, useEffect, useContext) for internal
state.
Shared state is passed down via props or managed through context providers if
needed.
src/
├── components/
│ ├── ui/
│ │ ├── [Link]
│ │ └── [Link]
│ ├── layout/
│ │ ├── [Link]
│ │ └── [Link]
├── pages/
│ ├── [Link]
│ └── [Link]
Tailwind CSS powers the styling system of this frontend, promoting utility-first and
responsive design principles.
Tailwind Features Utilized
Utility Classes: Each element is styled using predefined classes like bg-blue-500, text-
xl, p-4, etc.
Responsive Design: Built-in breakpoints such as sm, md, lg enable mobile-first
development.
Dark Mode Support: Tailwind’s dark mode configuration enables themes using the
dark: prefix.
Custom Themes: [Link] can be extended to define brand-specific colors,
fonts, and spacing.
Example
<button className="bg-blue-500 text-white rounded-lg px-4 py-2 hover:bg-blue-600">
Submit
</button>
Global Styles
The [Link] includes base Tailwind directives:
@tailwind base;
@tailwind components;
@tailwind utilities;
These allow Tailwind to inject normalized styles, reusable components, and utility helpers
into the project.
Styling Strategy
Consistency: Common UI patterns use consistent Tailwind classes.
Scalability: Component styles are predictable and adaptable with minimal overhead.
Theming: Easily supports light/dark modes and can extend with design tokens.
4.2.1 Introduction
This document outlines the system architecture of the backend server for an employee
management system. The backend is developed using [Link] and [Link], and it provides
a comprehensive set of RESTful API endpoints to support administrative and employee-
centric functionalities. These include user registration and login, managing employee records,
handling departmental structures, tracking leave applications, and managing salary records.
The backend is designed to serve as a reliable and scalable data service that communicates
with a frontend application and performs business logic operations.
The backend uses MongoDB as its primary data store, with Mongoose acting as the Object
Data Modeling (ODM) library. MongoDB's flexibility in schema design allows for rapid
development and easy scaling of features without significant structural changes.
The system is built using a modular three-tier architecture that ensures separation of concerns
and improves maintainability. The three tiers are:
1. Client Layer: This is typically a web or mobile frontend that interacts with the
backend through HTTP requests. It handles the user interface and user experience
aspects, such as form submissions and data visualization.
2. Server Layer (Business Logic Layer): Implemented using [Link] and [Link], this
layer processes client requests, enforces business rules, performs data validation, and
25
manages session or token-based authentication. It serves as the core processing unit
that connects the user-facing client to the underlying database.
Technologies Used:
JWT (JSON Web Tokens): Used for securing routes and user authentication.
server/
Folder Purposes:
models/: Defines data structures (schemas) and methods for database interaction.
Authentication (/auth):
Dashboard (/dashboard):
Employee (/employee):
Department (/department):
Salary (/salary):
Each route is defined in the routes/ directory and linked to its respective controller.
28
Authentication middleware is used on protected routes to ensure only authorized users have
access.
Routing is centralized in [Link], where all route modules are imported and registered with
the Express app. This design ensures clarity and separation of responsibilities.
Security is a critical part of the system architecture. The backend implements authentication
using JWT (JSON Web Tokens) and role-based access control to ensure secure operations.
Authentication Flow:
1. A user submits their credentials (username/email and password) via the login
endpoint.
2. The credentials are validated against stored hashed passwords (bcrypt used for
hashing).
4. The client includes this token in the Authorization header for protected routes.
Authorization:
JWT middleware parses and validates tokens for each incoming request.
Routes are protected using role-based access logic (e.g., only admins can add
employees).
Unauthorized requests return proper status codes (401 or 403).
Token Structure:
Libraries Used:
Middleware Functions:
Error Handling Middleware: Captures and logs server errors, returns readable
messages.
File Upload Middleware: Multer processes uploaded files and attaches them to
request objects.
Database Relationships:
Mongoose handles validations, type enforcement, and virtual fields for derived data.
All uncaught exceptions return a JSON object with a status code and message.
Example Response:
"status": 500,
Logging:
Application events, errors, and warnings are logged using [Link]() or a logging
library such as winston or morgan.
Ensuring data protection and securing user interactions is vital in any application dealing with
personal and employment data. This backend system incorporates several security measures
to mitigate risks such as unauthorized access, data breaches, and injection attacks.
o Use of JWT ensures that only authenticated users can access protected
resources.
o All incoming request data is validated using built-in checks and external
libraries like express-validator.
3. Password Protection:
o Passwords are never stored in plain text. bcryptjs is used to hash passwords
before storage.
o Salt rounds are used to strengthen password security.
4. HTTPS (SSL/TLS):
o Though not implemented at the backend level, it's recommended that the
deployment server enforces HTTPS to protect data in transit.
5. Environment Variables:
o Sensitive credentials (e.g., DB URIs, JWT secrets) are stored in the .env file
and accessed securely using dotenv.
o Limits are enforced on file size and type via Multer configuration.
Recommendations:
To ensure this backend system can scale and operate efficiently in production, deployment
strategies and scalability considerations have been addressed.
Deployment Setup:
Reverse Proxy: Use Nginx or Apache as a reverse proxy for load balancing and SSL
termination.
Environment Configuration: .env is used for secure, environment-specific settings
(e.g., DB URIs, ports).
Database Hosting:
MongoDB can be hosted on MongoDB Atlas or other cloud providers for scalability
and redundancy.
34
Horizontal and Vertical Scaling:
Horizontal: Spin up multiple instances of the backend server with a load balancer
(e.g., AWS ELB).
CI/CD Recommendations:
Automate testing and deployment using platforms like GitHub Actions, GitLab
CI/CD, or Jenkins.
5.1.1 Introduction
In modern organizations, managing employees, their roles, departments, and compensation is
an essential administrative task. By Ning, K. C., Ahmad, A well-structured employee
management system helps streamline HR operations, enhance transparency, and improve
productivity. [3]This presents a detailed exploration of the use cases and practical
applications of a React + Vite based Role-Based Employee Management System (RBEMS).
This system is designed to support two primary user roles: Admins and Employees. Admins
can manage the entire system, while Employees have restricted access relevant to their
individual profiles.
Admin
o Add, edit, and remove departments
o Manage employee records
o Assign salaries and review payroll information
o Access and analyze administrative dashboards and summaries
Employee
o View personal information
o Access salary slips
o Review departmental details
o Use self-service features (e.g., updating contact info)
Key Functionalities:
o Add new departments
o Modify existing departments
o Delete departments
o View department lists
Benefits:
o Enhanced organizational clarity
o Simplified employee assignment
o Improved administrative control
Key Functionalities:
o Add/Edit/View employee records
o Assign employees to departments
o Change employment status
Benefits:
o Centralized employee data
o Easy staff onboarding and updates
o Streamlined HR operations
Key Functionalities:
o Define salary structures
o Update salary records
Benefits:
o Transparent payroll processing38
o Secure access to financial data
o Reduces manual errors
Government agencies use EMS for workforce planning, payroll processing, and compliance
management. The system ensures transparency, accountability, and efficiency in public sector
employment management.
Hospitals and healthcare organizations use EMS to manage doctor shifts, nursing staff, and
administrative employees. Integration with medical record systems ensures seamless
coordination between HR and patient care services.
Universities and schools use EMS to manage faculty, administrative staff, and support
personnel. The system tracks employee performance, payroll, and training programs,
enhancing institutional efficiency.
Real-Time Data Processing: Enables instant access to employee records and analytics.
Enhanced Security: Implements encryption, authentication, and RBAC for data
protection.
40
CHAPTER 6
The Employee Management System (EMS) developed using the MERN stack provides a
comprehensive platform to manage employee data, track attendance, handle payroll, and
facilitate internal communication. The MERN stack consists of:
41
6.3 Visual Overview Of The Project
42
Above image displays the Admin Dashboard of the Role-Based Employee Management
System. After a successful login, users with admin privileges are directed to this dashboard,
which serves as the central control panel for managing the entire system. The interface
features a clean and organized layout, designed to provide the admin with easy access to key
functionalities. On the left side, there is a vertical navigation bar that includes options such as
Users, Departments, Roles, and Leave Management, enabling smooth navigation between
various modules. The main content area of the dashboard presents an overview of important
metrics and data visualizations, such as the number of users, departments, or leave requests,
giving the admin a quick snapshot of system activity. This centralized dashboard empowers
administrators to efficiently manage users, assign roles, create departments, approve or reject
leave applications, and maintain the organizational structure.
43
This image presents the Add User interface to the System, a crucial feature accessible from
the Admin Dashboard. This interface allows administrators to create new user accounts by
filling out a structured form. The form captures essential user information, including fields
such as Name, Email, Password, Department, and Role, ensuring that each new employee is
properly categorized within the organizational framework. The admin selects the department
from a dropdown list, which reflects the existing departments in the system, ensuring
consistency in employee categorization. Similarly, the role is assigned based on predefined
role types, which may include designations such as Manager or Employee. This form helps
enforce role-based access control by ensuring that each user is granted permissions
appropriate to their role. Once the form is submitted, the user is added to the system and can
log in using the provided credentials. This feature is essential for scaling the organization,
maintaining user structure, and ensuring smooth onboarding of new employees. The design is
user-friendly and promotes data accuracy through its organized layout and controlled input
fields.
44
This image illustrates the Leave Requests Management Page from the admin’s perspective
within the Role-Based Employee Management System. This section is dedicated to handling
and reviewing employee leave applications. The layout features a structured table that lists all
submitted leave requests, providing key details such as the Employee’s Name, Start Date
(From Date), End Date (To Date), Reason for Leave, and the current Status of the request.
Each row in the table represents an individual leave request, allowing the administrator to
quickly scan and evaluate multiple entries at once. The status column typically shows
whether the leave is pending, approved, or rejected, which helps in tracking the progress of
each application. Admins are provided with action buttons to approve or reject these requests
directly from this interface, streamlining the decision-making process. This page plays a
critical role in managing employee availability, ensuring that leave records are kept accurate
and up to date while maintaining operational efficiency.
45
The screenshot displays the "Manage Departments" section .Each row contains the serial
number, department name, and action buttons for editing or deleting the department. In this
example, two departments are listed: "Maintenance" and "Inspection." For each entry, there
are two action buttons — a green "Edit" button and a red "Delete" button — enabling the
admin to modify or remove a department as needed. To the right of the interface is a
prominent "Add New Department" button, allowing the admin to create a new department
entry. At the bottom of the table, there is a pagination control showing that two entries are
currently being displayed, with options to adjust the number of rows per page and navigate
between pages. Overall, the layout is clean, responsive, and user-friendly, designed to help
the admin efficiently manage departmental data.
46
The central focus of the screen is a form titled “Add Salary,” which allows the admin to input
salary-related details for an employee. The form includes multiple input fields organized in a
two-column layout. The first dropdown allows the admin to select a department, while the
adjacent one enables selection of an employee from that department. Below these are fields to
enter the Basic Salary, Allowances, and Deductions. Additionally, a date picker is provided to
specify the Pay Date in the format dd-mm-yyyy. Once the necessary details are filled in, the
admin can submit the form using the prominent “Update Employee” button at the bottom.
The design is intuitive, user-friendly, and aimed at ensuring accurate and efficient salary
management for employees.
47
This image is of employee dashboard . This screen have a vertical sidebar serves as the
primary navigation panel. It includes several menu options such as Dashboard, My Profile,
Leaves, and Salary, with the Dashboard option currently selected and highlighted in teal to
indicate active status. The main content area of the page simply displays a personalized
welcome message: “Welcome Back, Sujal,” accompanied by a user icon. This provides a
warm and straightforward introduction to the user experience.
48
This image showcases all the personal details of the employee. In the main content area, a
neatly designed card titled "Employee Details" displays the employee's personal information.
At the center of the card is a circular profile photo of the employee standing outdoors,
dressed casually. To the right of the image, key details are listed in a clean and structured
format:
Name: Sujal
Employee ID: sujal12
Date of Birth: 6/17/2004
Gender: Male
Department: Development
Marital Status: Single
The overall design is visually appealing and user-friendly, using consistent fonts, spacing, and
a professional color palette. This type of UI is suitable for HR systems, internal employee
portals, or company intranet dashboards, providing a smooth and personalized user
experience.
49
The main content area is titled "Manage Leaves" in bold, clear typography. Below the title,
there is a search bar labelled “Search for Leave,” allowing users to filter their leave records
conveniently. To the right of this bar, there's a green "Add New Leave" button, indicating a
form-based feature for submitting new leave requests. The central element is a table
displaying the user’s leave history. The columns include:
Overall, the interface is clean, intuitive, and user-friendly, streamlining the process of
managing leaves while offering visual feedback on approval statuses. It's well-suited for
internal employee management systems or HR software platforms.
50
This image presents the "Request for Leave" form section from an Employee Dashboard web
application, specifically designed to allow employees to apply for leave.
Leave Type: A dropdown menu prompting the user to "Select Leave", likely offering
options such as Casual Leave, Sick Leave, and more.
From Date and To Date: These fields include calendar picker icons for selecting the
desired date range in the format “dd-mm-yyyy”.
Description: A multi-line input field where the employee can provide a reason or any
additional details for the leave request.
At the bottom of the form, there is a prominent Add Leave button in teal that spans the full
width of the form, making it easy for users to submit their request with a single click.
Overall, the form is thoughtfully designed with clarity, accessibility, and user experience in
mind. It simplifies the process of submitting a leave request while maintaining a modern and
consistent interface, ideal for employee self-service portals.
51
The image showcases the "Salary History" section of an Employee Dashboard web
application, specifically tailored for employee self-service regarding payroll information.
Each row in the table represents a salary record and includes the following columns:
Overall, the layout is clean and user-friendly, designed to ensure that employees can quickly
view and understand their salary breakdown, including allowances, deductions, and final
payout—all in a well-structured and aesthetically appealing manner.
52
The MERN stack is highly performant for building scalable web applications. By Md
Iftekhar, The [Link] back-end ensures fast, non-blocking I/O operations, ideal for managing
large datasets such as employee records. The use of MongoDB allows the system to handle
complex data types like nested documents (e.g., employee roles, departments, and
performance data) efficiently.
Scalability: The system can scale horizontally by adding more servers or partitions to
handle larger datasets.
Response Time: API calls (for adding, updating, and retrieving data) are executed
within milliseconds, providing a smooth user experience. This is especially critical in
real-time applications like attendance tracking.
Real-Time Updates: [Link] or similar technologies could be integrated to allow
real-time updates, especially for features like employee status or alerts.
The front-end, built with [Link], offers a dynamic and responsive user interface. The
component-based architecture ensures a modular design, making it easy to maintain and
scale. Key points to note:
Responsiveness: The interface adapts to different screen sizes, ensuring employees
and managers can interact with the system on desktop or mobile devices.
User Interaction: The system allows for smooth navigation between different sections
(employee data, payroll, reports). Employees can view their own data, while
managers and administrators have more control over the system's backend operations.
Usability: Features like search, filter, and sorting make it easy to manage large
amounts of employee data. The use of React Hooks and Redux (if applicable) ensures
that the UI updates seamlessly without page reloads.
Several challenges were encountered during the development of the EMS using the MERN
stack:
The MERN stack provides high efficiency, but there are some trade-offs:
Backend Performance: [Link] ensures that the back-end operations are quick.
However, handling very high-volume requests simultaneously could lead to server
resource consumption; this can be mitigated using load balancing and microservices.
Database Queries: MongoDB performs well for most employee management queries.
However, more complex queries (e.g., large-scale reports or aggregations) can be
slower than a traditional SQL-based approach, depending on the data structure.
Cloud Integration: To ensure scalability and data availability, integrating the system
with cloud services like AWS or Google Cloud would be beneficial.
AI Integration: Incorporating machine learning for performance predictions,
employee retention analysis, or automated payroll optimizations could further
enhance the system's capabilities.
Mobile App: Building a mobile app (using React Native) could enhance the
accessibility for employees, making the system available anywhere, anytime.
CHAPTER
54 7
CONCLUSION AND FUTURE WORK
7.1 Summary
It has been the attempt of this paper to propose a computer-based system to manage employee
data in the workplace as manual methods used are outdated and produces a large amount of
paperwork. By Aribisala A.,A web-based Employee Management System is proposed to
develop using the distributed system concepts. Trending technologies such as React JS, Node
JS, and Express JS has been proposed to use as the development tools and MongoDB has
been proposed as the database. The system will be built as a distributed web-based
application. The clients will be able to access the application through a web browser. The web
browser with the React JS frontend will forward the requests to the Node JS backend and the
backend will communicate with the MongoDB database to fetch the data. The system will
overcome the shortcomings of the similar systems that have been proposed in the literature.
[8] The system is proposed to have functions such as managing company assets assigned to
employees, tracking the work progress of employees and broadcasting information to
employees as announcements in addition to attendance and leave management whereas
existing systems focus mainly on attendance and leave management only. Even though the
system is proposed to have a good set of feature the system can be further improved by
developing more features to add even more functionalities. Features such as email
notifications can be added. And the system can be made available for mobile devices by
making the application responsive. Further research could be conducted to improve the
system by identifying different kinds of employee data that should be effectively managed in
the workplace and developing the system to include functions to manage them. The subject
area should be further studied, and system should be further developed to address any
shortcomings.
55
Blockchain for Security: Blockchain technology can be used to enhance data security,
ensuring that employee records are tamper-proof and transparent.
IoT for Employee Monitoring: Integrating IoT devices, such as biometric attendance
systems, can automate time tracking and improve workforce management.
Gamification for Employee Engagement: Implementing gamification elements in
performance tracking can boost employee motivation and engagement.
Integration with Payroll and Compliance Systems: Further integrations with financial
and compliance tools will enhance automation in payroll processing and legal
reporting.
APPENDIX
56
Source Code:
[Link]
YUvbkeerilG902N?usp=drive_link
Online Sources:
[Link]
A_Web_Based_Employee_Management_System
[Link]
use-mern-stack-in employee management system/
JOURNAL ARTICLES:
REFERENCES
57
[1] Sahni V. et al. "Mern (mongodb, express-js, react-js, node-js) stack web-based themefied
education platform for placement preparation." Educational Administration: Theory and
Practice 30.5 (2024): 1918-1928.
[3] Ning K. C., Ahmad J. Zakaria, N. H., & Yuen, S. C. K. (2024). Employee Management
System for Enterprise Company. International Journal of Innovative Computing, 14(1), 57-
61.
[4] Deshpande, V., Bhujade, R., Amin, S., Agarwal, R., & Untawale, S. (2021, June).
Development of employee performance management system using web based application.
In 2021 International Conference on Intelligent Technologies (CONIT) (pp. 1-5). IEEE.
[5] Bartram, T. (2011). Employee management systems and organizational contexts: a
population ecology approach. Management Research Review, 34(6), 663-677.
[6] Nanayakkara, S., Ekanayake, U., Subasinghe, G., Jayasena, C., De Silva, D. I., &
Cooray, D. (2022). A web based employee management system. International Journal Of
Engineering And Management Research, 12(5), 82-89.
[8] Aribisala A., & Olusuyi K. (2014). Design of an employee management system (a case
study of National iron Ore mining company, Itakpe). International Journal of Mechanical
Engineering and Information Technology, 2(11), 832-841.
[12] Le, Duy. "Developing a User Management Dashboard with Fullstack Javascript." (2019).
[13] Sumathy G., et al. "StudentsConnect: A Web Application to Track Library Permissions
and Leave Requests in Hostels Using MERN." 2024 International Conference on Innovative
Computing, Intelligent Communication and Smart Electrical Systems (ICSES). IEEE, 2024.
59