Project Monitoring System for SSGI

Prepared by Medan Z. Senbeto (3345/14)

Haramaya University
College of Computing and Informatics
Department of Computer Science
Industrial Practice (CoSc4083) Report
Advised by Mr. Melaku Y.
Oct, 2024 GC
 I. Acknowledgement

First and foremost, I would like to thank the Almighty God for His blessings. I am sincerely
thankful to the Department of Computer Science at Haramaya University for providing us with
this invaluable internship opportunity. Special thanks to my advisor, Mr. Melaku Yilma, for his
priceless assistance and brotherly advice, which greatly contributed to the success of this project.

I extend my heartfelt appreciation to the Space Science and Geo-spatial Institute for their
welcoming environment and support for internship students. I am especially grateful to my
advisor there, Mr. Feleke Zerihun, for generously sharing his knowledge, dedicating his time,
and offering scholarly advice. Lastly, I want to thank my team members during the internship for
their collaboration and dedication, which played a crucial role in the successful completion of
this project.

i
II. List of Abbreviations

 API - Application Programming Interface

 CORS - Cross-Origin Resource Sharing
 CRUD - Create, Read, Update, Delete
 ESSS - Ethiopian Space Science Society
 ETRSS-1 - Ethiopian Remote Sensing Satellite-1
 GIS - Geographic Information Systems
 Git - Version Control System (commonly used as a version control software like
GitHub)
 HTTP - Hypertext Transfer Protocol
 HTTPS - Hypertext Transfer Protocol Secure
 IDE - Integrated Development Environment
 JWT - JSON Web Token
 KPI - Key Performance Indicator
 MERN - MongoDB, [Link], [Link], [Link]
 MVC - Model-View-Controller
 NoSQL - Not Only Structured Query Language
 PI - Principal Investigator
 QA - Quality Assurance
 RBAC - Role-Based Access Control
 RESTful - Representational State Transfer
 SDLC - Software Development Life Cycle
 SGI - Space Science and Geo-spatial Institute
 SPA - Single-Page Application
 SQL - Structured Query Language
 UI/UX - User Interface/User Experience
 VS Code - Visual Studio Code

ii
III. Table of contents

I. Acknowledgement.................................................................................................................I
II. List of Abbreviations........................................................................................................II
III. Table of contents.............................................................................................................III
IV. List of Figures.................................................................................................................VI
V. Organization of the document......................................................................................VIII
1. Chapter One: Software Development Plan..........................................................................1
1.1 Background of the Organization.......................................................................................1
1.2 Structure of the organization.............................................................................................2
1.3 About the team..................................................................................................................4
1.3.1 Workflow...................................................................................................................4
1.4 Introduction.......................................................................................................................5
1.4.1 Background................................................................................................................5
1.4.2 Statement of the problem...........................................................................................6
1.4.3 Objectives..................................................................................................................7
1.5 Project Schedule................................................................................................................7
1.6 Resources..........................................................................................................................8
1.6.1 Tools:.........................................................................................................................8
1.6.2 Place to Work:...........................................................................................................8
1.7 Risk management..............................................................................................................8
1.8 Development Methodology...............................................................................................9
1.8.1 Data Collection Methodology..................................................................................10
1.8.2 System Development Methodology........................................................................10
1.8.3 System Development Tools.....................................................................................11
1.9 Quality Assurance:..........................................................................................................12
2. Chapter Two: System Requirements..................................................................................13
2.1 Introduction.....................................................................................................................13
2.1.1 Existing System Overview......................................................................................13
2.1.2 Drawbacks of Existing System................................................................................13

iii
 2.2 Proposed system..............................................................................................................14
2.2.1 Overview..................................................................................................................14
2.2.2 Functional Requirements.........................................................................................14
2.2.3 Nonfunctional requirements....................................................................................14
3. Chapter Three: Requirements Analysis.............................................................................15
3.1 System models................................................................................................................15
3.1.1 Scenarios..................................................................................................................15
3.1.2 Use case model........................................................................................................19
3.1.3 Object model (with class and object diagrams).......................................................21
3.1.4 Dynamic model........................................................................................................26
3.1.5 Activity diagram......................................................................................................27
3.1.6 User interface navigational paths and screen mock-ups..........................................30
4. Chapter Four: System Design.............................................................................................32
4.1 Introduction.....................................................................................................................32
4.1.1 Overview of System Design....................................................................................32
4.1.2 Design Goal.............................................................................................................33
4.2 Proposed Software Architecture.....................................................................................34
4.2.1 Overview..................................................................................................................34
4.2.2 Subsystem Decomposition with Services................................................................35
4.2.3 Persistent Data management....................................................................................38
4.2.4 Access control and Security.....................................................................................39
4.2.5 Global control flow..................................................................................................39
4.2.6 Boundary Condition.................................................................................................40
4.3 Subsystem services.........................................................................................................41
4.3.1 User Management Service.......................................................................................41
4.3.2 Project Management Service...................................................................................41
4.3.3 Progress Update Service..........................................................................................42
4.3.4 Notification Service.................................................................................................42
4.3.5 Authentication and Authorization Service...............................................................43
4.4 Data Dictionary...............................................................................................................44
5. Chapter Five: Implementation............................................................................................48

iv
 5.1 Overview of Implementation..........................................................................................48
5.2 Technologies Used..........................................................................................................48
5.3 User Interface Implementation........................................................................................48
5.3.1 Frontend ([Link]) Code.........................................................................................49
5.4 Backend Implementation................................................................................................51
5.4.1 Backend ([Link]/[Link]) Code........................................................................52
5.5 Database Implementation................................................................................................54
6. Chapter Six: Overall Internship Experience.....................................................................55
6.1 Overall Internship Experience........................................................................................55
6.1.1 Benefits....................................................................................................................55
6.1.2 In Terms of Practical Skill.......................................................................................55
6.1.3 In Terms of Theoretical Knowledge........................................................................56
6.1.4 In Terms of Personal Skills......................................................................................57
6.1.5 In Terms of Work Ethic and Industrial Psychology................................................57
6.2 Challenges Faced During the Internship Program..........................................................58
6.3 Measures Taken for the Challenges Faced.....................................................................58
6.4 Conclusion and Recommendation..................................................................................58
6.4.1 Conclusion...............................................................................................................58
6.4.2 Recommendation.....................................................................................................59
6.4.3 Final Thoughts.........................................................................................................60

v
IV. List of Figures
Figure 1 Project Schedule Gantt Chart............................................................................................8
Figure 2 Use case Diagram............................................................................................................21
Figure 3 Class Diagram.................................................................................................................24
Figure 4 Object Diagram...............................................................................................................25
Figure 5 Sequence Diagram...........................................................................................................27
Figure 6 Activity Diagram.............................................................................................................29
Figure 7 SignUp Page....................................................................................................................30
Figure 8 Login Page.......................................................................................................................30
Figure 9 Update User Profile Page................................................................................................31
Figure 10 Users List Page..............................................................................................................31
Figure 11 Home Page....................................................................................................................32
Figure 12 Deployment Diagram....................................................................................................44
Figure 13 Admin Dashboard..........................................................................................................49
Figure 14 [Link].........................................................................................................................50
Figure 15 [Link]...........................................................................................................................51
Figure 16 Backend [Link]...........................................................................................................52
Figure 17 User Controller..............................................................................................................53
Figure 18 Authentication Middleware...........................................................................................54
Figure 19 Project Model................................................................................................................55

V. Organization of the document

vi
This Software Development Plan is organized as follows: Chapter One introduces the
organization, team structure, project purpose, objectives, schedule, resources, risk management,
and the development methodology. Chapter Two details the system requirements, comparing the
existing system to the proposed solution, and outlines both functional and nonfunctional
requirements. Chapter Three focuses on requirements analysis, with models such as use cases,
object diagrams, and interface mock-ups. Chapter Four covers system design, including
architecture, subsystem decomposition, data management, and security. Chapter Five addresses
implementation steps, while Chapter Six reflects on the internship experience, highlighting skill
development, challenges, and recommendations for future improvements.

vii
 1. Chapter One: Software Development Plan

1.1 Background of the Organization

The Space Science and Geo-spatial Institute (SSGI) of Ethiopia was established as part of the
Ethiopian government’s strategic efforts to harness space science and technology for the
country’s socio-economic development. Ethiopia recognized the growing importance of space
science, satellite technology, and geospatial information in driving modern economies and
improving quality of life. With this vision, the SSGI was founded by merging several institutions
and initiatives focused on space science and geospatial technologies under a unified framework.

Origins: The roots of the SSGI can be traced back to the early efforts of the Ethiopian Space
Science Society (ESSS), founded in 2004, which was a non-governmental organization dedicated
to promoting space science and astronomy in Ethiopia. Over time, the need for a more
comprehensive and governmental approach to space science led to the establishment of a
national space program

Formation: In 2019, the Ethiopian government formally established the SSGI, integrating the
activities of the ESSS and other relevant organizations. This move was part of Ethiopia’s broader
vision of becoming a significant player in space technology in Africa.

Satellite Program: One of the institute’s early milestones was the successful launch of
Ethiopia’s first satellite, the Ethiopian Remote Sensing Satellite (ETRSS-1), in December 2019.
This event marked a significant step in Ethiopia’s space journey, with the satellite providing vital
data for agriculture, climate monitoring, and environmental management.

Mission and Vision: The SSGI's mission is to develop and apply space science and geospatial
technology to support sustainable development in Ethiopia. Its vision is to make Ethiopia a
leading nation in Africa in space technology and geospatial sciences, contributing to economic
growth, environmental sustainability, and national security.

1
1.2 Structure of the organization

The SSGI is structured to efficiently manage its diverse functions, ranging from satellite
development to geospatial data analysis and research. The organizational structure is designed to
promote collaboration, innovation, and capacity building in the fields of space science and
geospatial technology.

1. Governing Board
Chairperson: Typically, a high-ranking government official, the chairperson oversees the
strategic direction of the institute.
Board Members: Comprised of representatives from various government ministries, academic
institutions, and industry experts. They provide oversight and ensure alignment with national
development goals.
2. Director-General
Role: The Director-General is the chief executive officer of the institute, responsible for the
overall management and execution of the institute’s mandate. They report directly to the
governing board.
Departments Under the Director-General: Several key departments and divisions report to the
Director-General, each focusing on specific areas of the institute's mission.
3. Departments and Divisions
1. Space Science Department:
Functions: Focuses on research and development in space science, including satellite
technology, astronomy, and space exploration.

Sub-Divisions:

- Satellite Development Division: Handles the design, construction, and operation of satellites.

- Space Research Division: Conducts research in space science and promotes international

2
1. Geospatial Information Department:

- Functions: Responsible for the collection, analysis, and dissemination of geospatial data for
various applications.

- Sub-Divisions:

- Remote Sensing Division: Specializes in processing and analyzing satellite imagery.

- Geographic Information Systems (GIS) Division: Focuses on developing and maintaining

geospatial databases and tools for national development.

2. Research and Innovation Department:

o Functions: Promotes research in space and geospatial sciences, fostering

innovation and the development of new technologies.
o Sub-Divisions:
 Innovation Hub: A platform for incubating new ideas and technologies in
space and geospatial sciences.
 Collaboration and Partnerships Division: Manages partnerships with
international space agencies, academic institutions, and the private sector.

3. Education and Capacity Building Department:

o Functions: Focuses on training and developing local expertise in space science

and geospatial technologies.
o Sub-Divisions:
 Training and Development Division: Provides educational programs,
workshops, and certifications.
 Public Outreach Division: Engages with the public and promotes space
science awareness.

4. Administration and Finance Department:

3
 o Functions: Manages the institute’s administrative and financial operations,
ensuring smooth functioning and resource allocation.
o Sub-Divisions:
 Human Resources Division: Handles recruitment, staff development, and
welfare.
 Finance Division: Manages budgeting, financial planning, and reporting.

4. Regional Offices

Role: The SSGI has regional offices that coordinate geospatial data collection and space science
activities at the regional level, ensuring that the institute’s programs reach all parts of the
country.

1.3 About the team

1.3.1 Workflow

Strategic Planning and Oversight

 Governing Board: Initiates strategic planning by setting high-level goals and objectives,
ensuring alignment with national development priorities. This includes regular meetings
to evaluate progress and provide guidance.
 Director-General: Translates strategic directives into operational plans, liaising with
department heads to ensure comprehensive execution of the institute’s mandate.
Execution and Management
Departments and Divisions: Each department and its respective sub-divisions are
responsible for executing specific tasks aligned with their functions.
 Space Science Department: Handles satellite development and space research,
coordinating with international partners for collaborative projects.
 Geospatial Information Department: Manages geospatial data processing and GIS
development, supporting national projects with precise data analysis.
 Research and Innovation Department: Encourages and manages innovation
initiatives, fostering partnerships to advance technological development.

4
  Education and Capacity Building Department: Implements training sessions,
workshops, and public outreach programs, aiming to build local expertise and engage
the community.
 Administration and Finance Department: Provides support to all other departments
through efficient management of human resources, finances, and administrative tasks.
Regional Coordination
Regional Offices: Act as the operational arms in various regions, ensuring effective
implementation of geospatial data collection and space science activities. They serve as the
local point of contact for stakeholders and facilitate regional engagement.

1.4 Introduction

In today's fast-paced organizational environment, efficient project monitoring is crucial for

achieving organizational goals and ensuring smooth operations. However the organization has
relied on manual paper-based methods to track and manage their projects. This approach is
indeed fraught with challenges such as the risk of data loss, difficulty in data retrieval, and the
inefficiency of updating and sharing project information.
To address these challenges, our web application aims to improve the way the organization
monitors its projects. The primary goal of this application is to streamline project tracking, and
improve overall efficiency within the organization. By transitioning from paper-based methods
to a centralized online system, organizations can benefit from real-time updates, easy access to
project progress, and improved collaboration within the departments.
This web application is designed to offer comprehensive project monitoring features, including
project creation, progress reporting, and sending a reminder. It caters to the specific needs of the
organization, ensuring that all project-related information is easily accessible and manageable.
The scope of this project is currently limited to the Space Science and Geospatial Institute.
However, with some fine adjustments, this application can be adapted and applied to other
various organizations that focus on software project development.
By implementing this web application, the organization will be better equipped to manage its
projects effectively, reduce administrative overhead, and focus on achieving its strategic
objectives. The transition from manual to digital project monitoring marks a significant step

5
towards enhancing operational efficiency and fostering a culture of innovation within the
organization.

1.4.1 Background

The Space Science and Geo-spatial Institute (SSGI)’s current approach to project tracking and
management is hindered by several challenges, including data loss, retrieval difficulties, and
inefficiencies in updating and sharing project information. These issues not only impede the
institute's operational efficiency but also pose a risk to the successful execution of its strategic
initiatives.

In response to these challenges, our web application project was conceived to revolutionize the
way the SSGI monitors and manages its projects. The application is designed to offer a
centralized online system that facilitates real-time updates, seamless information access, and
enhanced collaboration across departments. By digitizing project management processes, the
institute aims to eliminate administrative overhead, reduce the risk of data loss, and promote a
culture of innovation.

The scope of this project is initially focused on the SSGI, but the flexibility of the application
allows it to be adapted for use in other organizations with similar needs. This initiative represents
a crucial step towards embracing digital transformation, empowering the institute to achieve its
organizational goals more effectively and efficiently.

1.4.2 Statement of the problem

The organization has relied on manual paper-based methods to track and manage their projects.
This approach presents several significant challenges, including:
- Data Loss: Physical documents are susceptible to being misplaced, damaged, or lost, leading to
the permanent loss of critical project information.

6
- Difficulty in Data Retrieval: Searching for specific information within stacks of paper is time-
consuming and inefficient, often resulting in delays in accessing necessary data.
- Inefficiency in Updating: Manually updating project information on paper is repetitive and
prone to errors, making it difficult to maintain accurate and up-to-date records.
- Sharing Project Progress: Distributing project updates to team members is challenging, as it
requires physical copying or scanning of documents, which can be slow and unreliable.
- Storage and Space Issues: Storing large volumes of paper documents requires significant
physical space and proper organization, which is becoming unmanageable over time.
These problems highlight the need for a more efficient, reliable, and collaborative approach to
project management within the organization.

1.4.3 Objectives

[Link] General Objective

The general objective of this project is to streamline the project progress monitoring process by
digitalizing the current manual project tracking system within the organization.

[Link] Specific Objectives

The specific objective of this internship project is for the user to be able:
 To access a detailed overview of ongoing projects, including progress updates.
 To review and manage all submitted documents and project deliverables within the
system.
 To provide feedback and comments directly on the submitted progress reports to guide
the team.
 To send reminders to team members about upcoming deadlines and pending tasks.
 To easily create and define new projects, including setting goals and timelines.
 To submit progress updates and necessary documents through a streamlined interface.
 To view and respond to feedback and comments provided by the project manager on their
submitted work.

1.5 Project Schedule

7
Figure 1 Project Schedule Gantt Chart

1.6 Resources

1.6.1 Tools:

- Google Docs: For documentation and team collaboration.

- Insomnia: For testing APIs and ensuring backend functionality.
- Chrome: For testing and debugging the user interface.
- VS Code: As the primary development environment.
- Git: For version control.
- GitHub: For remote collaboration and code management.
- MongoDB Compass: For monitoring and managing the database.
- Laptop: hp core i5 for development.
- Microsoft Word: for documentation.

1.6.2 Place to Work:

- Training Room at SSGI: For in-person collaboration sessions.

- Remote Work: Team members will also work remotely, coordinating via GitHub.

1.7 Risk management

8
Technical Challenges
- Risk: Unfamiliarity with new technologies or unexpected technical issues.
- Mitigation: Provide team members with training, allocate time for research, and maintain a
flexible development schedule to accommodate learning curves.
Delays in Development
- Risk: Project timeline might extend due to unforeseen obstacles or resource constraints.
- Mitigation: Implement a buffer in the project schedule, regularly review progress, and adjust
tasks as needed to stay on track.
Resource Limitations
- Risk: Limited access to necessary tools, software, or workspace.
- Mitigation: Secure backup resources, ensure remote access to tools, and establish alternative
workspaces if needed.
Communication Breakdowns
- Risk: Miscommunication or lack of communication among team members.
- Mitigation: Schedule regular meetings, use collaboration tools effectively, and set clear
communication protocols.
Data Security Issues
- Risk: Breaches or loss of sensitive project data.
- Mitigation: Implement robust security measures, regularly back up data, and control access to
sensitive information.
Scope Creep
- Risk: Expansion of project scope beyond initial plans, leading to increased workload and
delays.
- Mitigation: Clearly define the project scope, regularly review and control scope changes, and
prioritize tasks based on their importance.

1.8 Development Methodology

For the development of the project monitoring web application, the Agile methodology was
chosen to ensure a flexible, iterative, and collaborative approach. Agile's principles of

9
adaptability and customer feedback are particularly well-suited to address the evolving needs of
the Space Science and Geo-spatial Institute (SSGI).

 Iterative Development: The project was broken down into small, manageable
increments called sprints, each lasting two to four weeks. This allowed the development
team to focus on delivering functional components of the application within short
timeframes, enabling quick adjustments based on feedback.
 Collaboration and Communication: Continuous communication was maintained with
our adviser from the SSGI. Regular sprint reviews and planning meetings ensured that all
parties were aligned on project goals, priorities, and progress. This collaborative
environment fostered transparency and trust.
 Customer Feedback and Adaptation: By involving users early in the development
process, our team could gather valuable feedback and incorporate it into subsequent
iterations. This user-centric approach ensured that the application remained aligned with
the institute's specific requirements and improved user satisfaction.
 Prioritization of Features: Features were prioritized based on their impact on solving
the identified problems and their value to the organization. This prioritization ensured
that the most critical functionalities, such as real-time updates and progress reporting,
were developed and delivered first.
 Continuous Improvement: Agile emphasizes the importance of learning and
improvement. After each sprint, retrospectives were conducted to identify successes and
areas for improvement, allowing us to refine their processes and enhance productivity.

1.8.1 Data Collection Methodology

To thoroughly understand user needs and system requirements, data will be collected using
multiple methods. A questionnaire will be distributed to gather broad, quantitative insights into
user preferences, challenges, and anticipated features. In addition, interviews with stakeholders
and subject matter experts will provide qualitative data and allow for in-depth exploration of
specific requirements and expectations. Document review will also be conducted, examining
existing reports, user manuals, and system logs to identify current workflows, known issues, and
performance benchmarks, creating a solid foundation for the new system design.

10
1.8.2 System Development Methodology

This project will employ a Procedural Programming methodology, structured around the
JavaScript language within the MERN stack (MongoDB, [Link], React, and [Link]). By
organizing code into a sequence of clearly defined functions, this approach provides direct
control over program flow and allows for step-by-step problem-solving. The use of JavaScript
across the stack enhances consistency and efficiency, enabling both front-end and back-end
development with the same language. This methodology is ideal for this project, supporting
modularity, ease of debugging, and streamlined communication between the components in the
MERN stack, from database to interface.

1.8.3 System Development Tools

For the successful development of our web application, we will use a combination of tools
tailored to different stages of the software development life cycle. These tools have been chosen
for their reliability, ease of use, and compatibility with the project requirements.
MERN Stack:
MongoDB: A NoSQL database for storing and retrieving project data. It allows for flexible and
scalable data management.
[Link]: A web application framework for [Link], providing robust features for building web
and mobile applications.
[Link]: A front-end JavaScript library for building user interfaces. It ensures a responsive and
dynamic user experience.
[Link]: A JavaScript runtime that enables server-side scripting, allowing us to build scalable
and efficient applications.
Version Control:
Git: A distributed version control system that tracks changes in source code during development.
GitHub: A web-based platform for collaborative code management, issue tracking, and project
documentation.
Development Environment:

11
Visual Studio Code (VS Code): An integrated development environment (IDE) that supports
various programming languages and frameworks, equipped with extensions for efficient
development.
API Testing:
Insomnia: A tool for testing RESTful APIs, ensuring that our backend services are functioning
correctly.
Database Management:
MongoDB Compass: A GUI for MongoDB that provides insights into the structure and contents
of the database, aiding in efficient data management.
Collaboration and Documentation:
Google Docs: Used for collaborative documentation and planning, allowing team members to
contribute in real-time.
Browser:
Google Chrome: The primary browser used for testing the web application’s user interface and
functionality across different devices.

1.9 Quality Assurance:

Quality assurance was vital to ensuring that the web application met the required standards of
functionality, performance, and user experience. Our QA process involved the following key
activities:

1. Code Reviews:
o Regular code reviews were conducted to ensure code quality, adherence to coding
standards, and early identification of potential issues during the development
process. Peer reviews were encouraged to foster a culture of continuous
improvement.
2. Testing Processes:
o Unit Testing: Each module of the application was tested individually to ensure
they worked as expected.

12
 o Integration Testing: The interaction between different modules was tested to
identify any issues that might have arisen when components were combined.
o System Testing: The complete system was tested to ensure it met the specified
requirements and performed well under various conditions.
3. Issue Tracking and Resolution:
o Issues were tracked using GitHub Issues, where they were prioritized, assigned,
and resolved systematically. Regular stand-up meetings were held to review
progress and address any blockers.

2. Chapter Two: System Requirements

2.1 Introduction

This chapter outlines the system requirements for the web application designed to transition from
a manual paper-based project monitoring system to a streamlined digital platform. By addressing
the current limitations and proposing a working solution, this chapter aims to ensure that all
functional and nonfunctional aspects of the new system are clearly defined and aligned with the
organization’s goals.

2.1.1 Existing System Overview

Current System: The organization currently relies on manual, paper-based methods for tracking
and managing projects. This approach involves recording project details, progress, and updates
on paper forms, which are then filed and retrieved as needed.
System Characteristics:
 Manual Record-Keeping: Project information is logged by hand, leading to potential
inaccuracies and data loss.
 Paper-Based Reporting: Progress reports and updates are created and distributed on
paper, making them prone to delays and miscommunication.
 Limited Accessibility: Project information is often stored in physical files, making
retrieval and sharing cumbersome and time-consuming.

13
2.1.2 Drawbacks of Existing System

Risk of Data Loss: Physical documents can be lost, damaged, or destroyed, leading to potential
loss of critical project information.
Difficulty in Data Retrieval: Searching for specific information in physical files is inefficient
and can lead to delays in accessing necessary data.
Inefficient Updating and Sharing: Updating project details and sharing information requires
manual effort, which is prone to errors and delays.
Lack of Real-Time Updates: The current system does not support real-time tracking, resulting
in outdated or incomplete information.

2.2 Proposed system

2.2.1 Overview

The proposed web application aims to modernize project monitoring by providing a centralized,
digital platform for managing projects. This system will facilitate real-time updates, improve
data accessibility, and enhance collaboration within the organization.

2.2.2 Functional Requirements

 Project Creation: Easily set up new projects with detailed specifications.

 Progress Reporting: Track and report on project milestones and tasks in real-time.
 Sending Reminders: Send notifications and reminders for deadlines, meetings, and task
updates.
 Project Creation: Users must be able to create, edit, and delete project records.
 Progress Tracking: The system must provide functionality for tracking project
milestones.
 Notifications: sending reminders and notifications for upcoming deadlines.
 User Access Control: The system should allow for different levels of access and
permissions based on user roles.

2.2.3 Nonfunctional requirements

14
 Usability
Intuitive Interface: The application must have a user-friendly interface that is easy to navigate
for all users.
Accessibility: The system should be accessible from various devices, including desktops, tablets,
and laptops within the institute's wifi range.
Reliability
Data Integrity: The application must ensure the accuracy and consistency of project data.
Availability: The system should be available as long as the institute’s server is available with
minimal downtime.
Performance
Response Time: The application provides fast response times for all user interactions and data
retrieval.
Scalability
The system is be able to handle increasing amounts of data and users without performance
degradation.

Page Load Time

This is the total time it takes for a web page to fully load. It's a critical metric for user experience,
as longer load times can lead to user frustration and abandonment.

Good Measurement: Aim for under 3 seconds for optimal user experience. Because of several
dependencies on different modules the system takes about 5 second.

3. Chapter Three: Requirements Analysis

3.1 System models

3.1.1 Scenarios

Based on your scenario, here are the use cases derived from the proposed system functionalities.
These use cases describe the interactions between different users (Admin, Project PI, and
Reviewer) and the system.

15
1. User Registration and Approval

Actors: New User, Admin

Description: A new user registers on the platform. The user is initially assigned the default role
of "User." The admin reviews and approves the user, and optionally changes the user's role to
Admin, Project PI, or Reviewer.

 Steps:
1. A new user accesses the registration page and fills in the required information.
2. The system assigns the default role of "User" to the new registration.
3. The admin is notified of the new user registration.
4. The admin reviews the user's information and approves the registration.
5. The admin changes the user's role to Admin, Project PI, or Reviewer as necessary.
6. The system sends a confirmation email to the user regarding their approval and
assigned role.
 Entry Conditions: The institute's server is online and accessible, and the new user has
access to one of the institute's wifi.
 Exit Conditions: The user is registered in the system with an approved role.

2. Create Project by Project PI

Actors: Project PI
Description: A user with the Project PI role creates a new project, specifying all necessary
details for project initiation.

 Steps:
1. The Project PI logs into the system with their credentials.
2. Navigates to the "Create New Project" page.
3. Fills in the project details, including project name, description, objectives, start
and end dates, and team members.
4. Submits the project creation form.

16
 5. The system saves the project details and notifies the admin that a new project has
been created.
 Entry Conditions: The user must be assigned the role of Project PI.
 Exit Conditions: A new project is created and saved in the system, pending assignment
of a reviewer by the admin.

3. Assign Reviewer to Project

Actors: Admin
Description: The admin assigns a reviewer to a newly created project to oversee and provide
feedback on progress.

 Steps:
1. The admin receives a notification about the new project created by the Project PI.
2. Logs into the system and navigates to the "Manage Projects" page.
3. Selects the new project and chooses a reviewer from the list of registered users
with the Reviewer role.
4. Assigns the selected reviewer to the project.
5. The system notifies the assigned reviewer of their new role and responsibilities.
 Entry Conditions: A new project has been created, and there are users with the
Reviewer role.
 Exit Conditions: The reviewer is assigned to the project and receives a notification.

4. Submit Project Progress

Actors: Project PI
Description: The Project PI submits progress updates for a project to keep the admin and
reviewers informed about the ongoing work.

 Steps:
1. The Project PI logs into the system and accesses the project dashboard.
2. Navigates to the "Submit Progress" section of the specific project.
3. Fills in the progress details, including tasks completed, milestones achieved, and
any issues encountered.

17
 4. Submits the progress update form.
5. The system saves the progress update and notifies the admin and assigned
reviewer.
 Entry Conditions: A project exists, and the Project PI has the required permissions.
 Exit Conditions: Progress updates are saved and accessible to the admin and assigned
reviewer.

5. Send Reminders for Progress Submission

Actors: Admin
Description: The admin sends reminders to the Project PI if progress updates have not been
submitted on time.

 Steps:
1. The system periodically checks for upcoming deadlines for progress submissions.
2. If a deadline is approaching or has passed without submission, the admin is
notified.
3. The admin logs into the system and navigates to the "Send Reminders" section.
4. Selects the Project PI who has not submitted progress updates.
5. Sends a reminder notification via email or in-app message.
 Entry Conditions: The system has a defined schedule for progress updates.
 Exit Conditions: The Project PI receives a reminder to submit the progress update.

6. Review and Provide Feedback on Submitted Progress

Actors: Reviewer, Admin

Description: The reviewer or admin reviews the progress submitted by the Project PI and
provides feedback or comments.

 Steps:
1. The reviewer or admin logs into the system and accesses the specific project.
2. Navigates to the "Review Progress" section.
3. Reviews the progress details submitted by the Project PI.

18
 4. Provides feedback or comments, highlighting any areas that need attention or
improvement.
5. Submits the feedback form.
6. The system sends notifications to the Project PI regarding the feedback provided.
 Entry Conditions: The Project PI has submitted a progress update.
 Exit Conditions: Feedback is recorded and communicated to the Project PI.

7. Change User Roles

Actors: Admin
Description: The admin changes the roles of users to Admin, Project PI, or Reviewer as needed
to accommodate organizational requirements.

 Steps:
1. The admin logs into the system.
2. Navigates to the "User Management" page.
3. Selects a user from the list.
4. Changes the user’s role to Admin, Project PI, or Reviewer.
5. Saves the changes, and the system updates the user's permissions accordingly.
6. The system notifies the user about their role change.
 Entry Conditions: The user is registered and has a default or existing role.
 Exit Conditions: The user’s role is updated, and their access permissions are adjusted
accordingly.

3.1.2 Use case model

The use case model for the proposed web application will visually represent the interactions
between different users (actors) and the system. The diagram will highlight various use cases that
describe the functional requirements of the system.
Actors:

19
  Admin: The primary user with the highest level of access who can approve new user
registrations, assign roles, assign reviewers, send reminders, and provide feedback on
project progress.
 Project PI (Principal Investigator): A user with permissions to create projects and
submit project progress updates.
 Reviewer: A user assigned to review and provide feedback on project progress.
 User: A new user who registers on the platform and awaits approval and role assignment
by the admin.

Use Cases:

1. Register New User: Represents the action of a new user registering on the platform.
2. Approve User Registration: Represents the admin's ability to approve new users and
assign them roles.
3. Change User Role: Allows the admin to change a user's role to Admin, Project PI, or
Reviewer.
4. Create Project: Represents the ability of the Project PI to create a new project with all
necessary details.
5. Assign Reviewer: Represents the admin’s task of assigning a reviewer to a new project
created by the Project PI.
6. Submit Project Progress: Represents the action taken by the Project PI to submit
progress updates on their projects.
7. Send Reminder for Progress Submission: Represents the admin’s ability to send
reminders to the Project PI if progress updates are not submitted on time.
8. Review and Provide Feedback on Progress: Represents the action where the Reviewer
or Admin reviews the submitted progress and provides feedback to the Project PI.

20
Figure 2 Use case Diagram

3.1.3 Object model (with class and object diagrams)

A class diagram is a static structure diagram that shows the classes, their attributes, methods, and
the relationships between them within a system.

Key Classes in the System

1. User

21
 o Attributes:
 userID: String
 first name: String
 last name: String
 gender: String
 phoneNumber: String
 email: String
 country: String
 role: UserRole (enum: Admin, ProjectPI, Reviewer, User)
o Methods:
 register()
 login()
 update()
2. Admin (inherits from User)
o Methods:
 changeUserRole(user: User, newRole: UserRole)
 assignReviewer(project: Project, reviewer: Reviewer)
 sendReminder(projectPI: ProjectPI)
 provideFeedback(project: Project, feedback: String)
3. ProjectPI (inherits from User)
o Methods:
 createProject(details: ProjectDetails)
 submitProgress(project: Project, progress: ProgressUpdate)
 editProject(project: Project)
4. Reviewer (inherits from User)
o Methods:
 reviewProgress(project: Project, progress: ProgressUpdate)
 provideFeedback(project: Project, feedback: String)
5. Project
o Attributes:
 projectID: String

22
  title: String
 description: String
 startDate: Date
 endDate: Date
 status: ProjectStatus (enum: Active, Inactive, Expired)
 projectPI: ProjectPI
 reviewer: Reviewer
 progressUpdates: List<ProgressUpdate>
o Methods:
 addProgressUpdate(update: ProgressUpdate)
 setStatus(status: ProjectStatus)
6. Notification
o Attributes:
 notificationID: String
 recipient: User
 message: String
 dateSent: Date
o Methods:
 sendNotification()

Relationships

 Inheritance:
o Admin, ProjectPI, and Reviewer inherit from User.
 Associations:
o User can be associated with multiple Project objects (via ProjectPI role).
o Project has one ProjectPI and one Reviewer.
o Project has multiple ProgressUpdate objects.
o Admin interacts with User, Project, and ProgressUpdate for various tasks.
o Notification is associated with User (recipient).

23
Figure 3 Class Diagram

24
Figure 4 Object Diagram

25
3.1.4 Dynamic model

The SSGI Project Monitoring System: Login Sequence Diagram outlines the process of user
authentication in the system. Here's a step-by-step description:

1. Enter Login Credentials (User):

o The user inputs their login credentials on the front end, built with [Link].
2. Send Login Request ([Link]):
o [Link] sends the login request to the backend server, which is managed by
[Link] using [Link].
3. Query User Credentials (Node/[Link] to MongoDB):
o The server queries the MongoDB database to verify the user's credentials.
4. Return User Data (MongoDB to Node/[Link]):
o MongoDB returns the user data to the server if the credentials are valid.
5. Generate JWT Token (Node/[Link]):
o The server generates a JSON Web Token (JWT) for the authenticated user using
the JWT Auth Service.
6. Return JWT Token (JWT Auth Service):
o The JWT Auth Service returns the generated token to the server.
7. Return JSON Format Token (Node/[Link] to [Link]):
o The server sends the JWT token back to the client in JSON format.
8. Store JWT Token ([Link]):
o The client stores the JWT token locally, marking the user as logged in.
9. Home Page (User):
o The user is redirected to the home page, gaining access to the system with their
authenticated session.

26
Figure 5 Sequence Diagram

3.1.5 Activity diagram

This activity diagram illustrates the workflow for managing projects within the Space Science
and Geo-spatial Institute (SSGI). The diagram is divided into three main roles: Project PI
(Principal Investigator), Admin, and Reviewer.

1. Create Project (Project PI):

o The process begins with the Project PI creating a new project. This initiates the
workflow and sets the project into the system.

27
2. Approve Project (Admin):

o Once the project is created, it moves to the Admin for approval. The Admin
reviews the project details and approves it for further actions.
3. Assign Reviewer (Admin):
o After approval, the Admin assigns a Reviewer to the project. This ensures that
there is a designated person responsible for evaluating the project’s progress.
4. Submit Progress (Project PI):
o The Project PI submits progress updates on the project. This keeps the project’s
status current and allows the Reviewer to assess its development.
5. Send Reminder (Reviewer):
o If necessary, the Reviewer can send reminders to the Project PI for progress
updates or additional information. This step ensures continuous communication
and accountability.
6. Suspend/End Project:
o Once the project reaches completion or if it needs to be suspended, the final step
involves officially ending or suspending the project. This marks the closure of the
project’s lifecycle.

28
Figure 6 Activity Diagram

29
3.1.6 User interface navigational paths and screen mock-ups

Figure 7 SignUp Page

Figure 8 Login Page

30
Figure 9 Update User Profile Page

Figure 10 Users List Page

31
Figure 11 Home Page

4. Chapter Four: System Design

4.1 Introduction

The system design phase is critical in translating the requirements and functional specifications
into a coherent system architecture that can be implemented and deployed. This chapter outlines
the architectural design, the key components of the system, and the interactions between these
components. The design is guided by the need to meet the functional requirements while
ensuring that the system is scalable, maintainable, and efficient.

4.1.1 Overview of System Design

System design involves creating a blueprint for the development of the system. This blueprint
covers both high-level architecture and detailed design considerations. The system is broken
down into various components or modules, each responsible for specific functionality. The

32
design process includes defining the system architecture, data models, user interfaces, and the
relationships between different system components.

4.1.2 Design Goal

The design phase is guided by several goals that ensure the system meets its intended purpose
while being robust and scalable. The primary design goals for this system include:

Modularity

The system is designed to be modular, with each module handling a specific part of the
functionality. This modularity allows for easier maintenance, testing, and future enhancements.

Scalability

The design ensures that the system can scale to accommodate an increasing number of users,
data, and transactions. This is achieved through a scalable architecture that can be expanded as
needed.

Performance

The system is designed to perform efficiently under normal and peak loads. Performance
considerations include optimizing algorithms, minimizing response times, and ensuring that the
system can handle concurrent users effectively.

Security

Security is a critical design goal. The system includes measures to protect sensitive data, ensure
secure communication, and prevent unauthorized access. Security considerations include
authentication, authorization, encryption, and auditing.

Maintainability

The system is designed with maintainability in mind. This includes writing clean, well-
documented code, using standard design patterns, and ensuring that the system is easy to update
and modify.

33
Usability

The system design emphasizes user experience and usability. The user interface is intuitive and
easy to navigate, ensuring that users can perform tasks efficiently without a steep learning curve.

4.2 Proposed Software Architecture

High-Level Architectural Design

We implemented a hybrid architecture combining Client-Server and Model-View-Controller

(MVC) patterns to optimize the system's performance and scalability.

1. Client-Server Architecture:
o The system is divided into two main components: the client and the server.
o Client Side: Utilizes [Link] to create a dynamic and responsive user interface. It
communicates with the backend via HTTP requests, using the CORS module to
handle cross-origin resource sharing securely.
2. Model-View-Controller (MVC) Architecture:
o Backend ([Link]/[Link]):
 Model: Manages data logic and interacts with the MongoDB database to
perform CRUD operations.
 Controller: Handles incoming requests, processes data with the model,
and returns responses to the client.
o This separation of concerns ensures maintainability and scalability, allowing for
efficient handling of user requests and data management.

4.2.1 Overview

The SSGI Project Monitoring System is designed as a modular application that comprises several
subsystems, each responsible for a specific function within the project monitoring process. The
system’s architecture ensures that various roles within the organization (such as Admins, Project
PIs, Reviewers, and Users) can interact seamlessly with the system to achieve their respective

34
tasks. The subsystems are integrated via well-defined interfaces, enabling efficient
communication and data flow across the system.

4.2.2 Subsystem Decomposition with Services

Subsystems and Core Services:

1. User Management Subsystem:

o Purpose: Handles user registration, authentication, profile management, and
access control.
o Core Services:
 Register: Allows new users to create accounts within the system.
 Login: Authenticates users and provides access based on their roles
(Admin, Project PI, Reviewer).
 Update Profile: Enables users to update their personal information.
o Relationships: This subsystem is foundational as it interacts with all other
subsystems to manage user access and roles.
2. Project Management Subsystem:
o Purpose: Enables the creation, update, and management of projects.
o Core Services:
 Create Project: Allows Project PIs to create new projects by providing
necessary details such as title, description, start date, and end date.
 Edit Project: Allows Project PIs to modify project details.
 Assign Reviewer: Admins can assign Reviewers to specific projects for
monitoring and feedback.
o Relationships: Closely interacts with the Progress Reporting and Notification
subsystems to track and manage project progress.
3. Progress Reporting Subsystem:
o Purpose: Facilitates the submission and tracking of project progress reports.
o Core Services:

35
  Submit Progress: Allows Project PIs or team members to report on the
current status of the project, including uploading relevant files and
documenting challenges.
 Review Progress: Enables Reviewers to review submitted progress
reports and provide feedback.
o Relationships: This subsystem is linked with the Project Management subsystem
for updating project statuses and the Notification subsystem for sending
reminders.
4. Notification Subsystem:
o Purpose: Manages the notification and reminder system within the application.
o Core Services:
 Send Notification: Automatically sends notifications to users regarding
project updates, reminders, or feedback.
 Send Reminder: Allows Admins to manually send reminders to users
about upcoming deadlines or required actions.
o Relationships: Interacts with all other subsystems to ensure that users are kept
informed about relevant activities within the project monitoring system.
5. Access Control and Security Subsystem:
o Purpose: Ensures that only authorized users can access specific features and data
within the system.
o Core Services:
 Change User Role: Admins can assign or change user roles to define their
level of access within the system.
 Authorization: Verifies that users have the appropriate permissions to
perform specific actions, such as creating projects or reviewing progress.
o Relationships: This subsystem works in conjunction with the User Management
subsystem to enforce security policies across the application.

Subsystem Interactions:

The subsystems within the SSGI Project Monitoring System are designed to interact seamlessly
through well-defined APIs and data flows. For example:

36
  The Project Management Subsystem relies on the User Management Subsystem to
validate user roles before allowing project creation or modification.
 The Notification Subsystem is triggered by events in the Project Management and
Progress Reporting Subsystems to send alerts or reminders to users.
 The Access Control and Security Subsystem ensures that all operations across
subsystems are performed by authorized users only.
1. Hardware / Software mapping
The system architecture defines how the software components are mapped to the hardware
infrastructure and how they interact to form a cohesive system. The system uses the MERN stack
(MongoDB, [Link], React, [Link]), with all components hosted on the institute’s internal
servers. The system is designed to operate within the institute’s local network, providing secure
access and efficient data management.

Server Infrastructure

The system is hosted entirely on the institute’s secure internal servers, which are assigned a local
IP address. The server setup includes:

 Application Server: The backend application is implemented in [Link] using the

Express framework. This server handles all API requests, business logic, and
communication with the database.
 Database Server: MongoDB (a NoSQL database) is hosted on the same server as the
[Link] application. This database stores all persistent data related to user accounts,
project management, notifications, and progress updates.
 Local IP Address: The server is assigned a local IP address, ensuring that the system is
only accessible within the institute’s internal network.

Client Devices

Client devices, such as desktops and laptops within the institute, access the system via a web
browser. The system is not accessible from outside the institute’s network, providing an
additional layer of security.

37
  Desktop and Laptop Clients: Users interact with the system through standard web
browsers (e.g., Chrome, Firefox, Edge). The client-side application is built using React,
providing a dynamic and user-friendly interface.
 Browser-Based Access: The React-based frontend allows users to access the system
through any modern browser within the institute’s WiFi network.

Software Components Mapping

The software components are mapped to the hardware as follows:

 Frontend (React): The React-based client application runs on the users’ desktops and
laptops and interacts with the backend via HTTP/HTTPS requests. The client-side is
responsible for rendering the user interface and making API calls to retrieve or send data.
 Backend ([Link] with Express): The backend is implemented in [Link] and uses the
[Link] framework to handle HTTP requests, route API calls, and enforce business
logic. The backend connects to MongoDB for data storage and retrieval.
 Database (MongoDB): MongoDB stores all persistent data, including user information,
project details, notifications, and progress updates. The database is hosted on the same
server as the backend for efficient data access.

4.2.3 Persistent Data management

The system uses MongoDB for persistent data storage. MongoDB, being a NoSQL database,
provides flexibility in how data is structured and is well-suited for handling the system’s
dynamic and hierarchical data, such as project updates and user notifications.

Data Storage: The key data entities include users, projects, progress updates, and notifications.
Each entity is stored in a MongoDB collection:

Users Collection: Stores user information, including role-based access control (Admin, Project
PI, Reviewer).

Projects Collection: Stores project details, including project title, description, start/end dates,
and reviewers.

38
Progress Updates Collection: Stores progress reports, which are linked to specific projects.

Notifications Collection: Stores notifications sent to users regarding project updates or role
changes.

Data Integrity: Data integrity is maintained through proper validation at the backend. Data
consistency is ensured by enforcing required fields and valid data types at both the application
and database levels.

Backup and Recovery: Regular database backups are performed to ensure that data can be
restored in case of failure or corruption. The backup schedule is managed by the institute’s server
administration team.

4.2.4 Access control and Security

The system is designed with strong access control mechanisms and security features to protect
sensitive data and ensure that only authorized users can access the system.

 User Authentication: Authentication is handled using JWT (JSON Web Tokens), which
securely identifies users once they log in. Each user is assigned a specific role (Admin,
Project PI, Reviewer) that determines their access rights within the system.
 Role-Based Access Control (RBAC): Access to different system functionalities is
controlled based on user roles. Admins have full access to the system, while Project PIs
and Reviewers have restricted access based on their responsibilities.
 Network Security: The system is only accessible within the institute’s internal network.
Users must be connected to the institute’s WiFi to interact with the system, ensuring that
the system is not exposed to the public internet.
 Data Encryption: Sensitive data, such as passwords, is encrypted before storage.
Additionally, secure communication is enforced through HTTPS to protect data
transmitted between the client and server.

4.2.5 Global control flow

39
The global control flow of the system is managed through a series of interactions between the
frontend, backend, and database. The following describes the general flow of user interactions
and data processing:

User Requests: When a user interacts with the system (e.g., logs in, submits a project update),
the React frontend generates an HTTP request. This request is routed to the backend for
processing.

Backend Processing: The backend ([Link] with Express) receives the request, applies the
necessary business logic, and interacts with the MongoDB database to retrieve or store data.

Data Response: Once the backend processes the request, it sends a response back to the
frontend, which updates the user interface accordingly.

Error Handling: Global error handling is implemented at both the client and server levels. If an
error occurs (e.g., invalid input), appropriate error messages are displayed to the user, and failed
requests are logged for further investigation.

4.2.6 Boundary Condition

Boundary conditions define how the system manages exceptional or unexpected situations, such
as system failures, user errors, or external constraints.

 System Failures: In the case of server failure, the system is designed to handle crashes
gracefully. Regular backups ensure that data can be restored, and failover mechanisms
are in place to minimize downtime.
 User Errors: The frontend and backend both include validation mechanisms to handle
user errors. For example, if a user submits invalid data (e.g., missing required fields), the
system will display clear error messages and guide the user in correcting the input.
 Resource Limits: The system is designed to handle a reasonable number of concurrent
users, given the internal nature of the deployment. However, if resource limits are
reached (e.g., server capacity), the system will queue requests or return appropriate error
responses indicating that the system is temporarily overloaded.

40
  Data Consistency: In situations where multiple users are updating the same project or
submitting progress updates at the same time, the system ensures data consistency
through proper transaction management and optimistic concurrency control at the
database level.

4.3 Subsystem services

The Subsystem Services section explains the individual modules or services that compose the
system. Each service is responsible for handling specific functionality and interacts with other
services to ensure the system works as a cohesive whole. Below is a detailed breakdown of the
different subsystems in your MERN-based project management system.

4.3.1 User Management Service

This service handles all user-related functionality, including registration, login, profile
management, and role assignment. It is responsible for ensuring that users are authenticated and
authorized appropriately based on their roles (Admin, Project PI, Reviewer).

 Responsibilities:
o User registration and login.
o Role-based access control (RBAC).
o Profile management (updating user details such as name, email, etc.).
o Password management and secure storage.
 Endpoints:
o POST /api/users/register: Register a new user.
o POST /api/users/login: Authenticate a user.
o PUT /api/users/profile: Update user profile.
o GET /api/users/roles: Retrieve user roles and permissions.

4.3.2 Project Management Service

This service allows users to create and manage projects. It is primarily used by Project PIs and
Admins to track the progress of various projects and assign tasks to different users.

41
  Responsibilities:
o Project creation, modification, and deletion.
o Assigning reviewers to a project.
o Tracking project status and updates.
o Managing project timelines and deadlines.
 Endpoints:
o POST /api/projects: Create a new project.
o PUT /api/projects/:id: Update an existing project.
o GET /api/projects: Retrieve a list of projects.
o DELETE /api/projects/:id: Delete a project.

4.3.3 Progress Update Service

This service manages the progress reports for each project. Users (typically Project PIs) can
submit progress updates, and Reviewers can provide feedback on the progress.

 Responsibilities:
o Submitting progress updates for ongoing projects.
o Tracking the status of submitted progress reports.
o Providing feedback on progress updates.
 Endpoints:
o POST /api/progress/project/:projectId: Submit a progress update for a project.
o GET /api/progress/project/:projectId: Retrieve progress updates for a specific
project.
o PUT /api/progress/:updateId: Update a previously submitted progress report.

4.3.4 Notification Service

This subsystem handles all notifications within the system. Notifications are triggered when a
user performs an action such as submitting a progress update or when Admin assigns a new
reviewer to a project.

 Responsibilities:

42
 o Sending notifications to users upon specific events (e.g., project updates, role
changes).
o Tracking notification delivery status.
o Managing notification history for audit purposes.
 Endpoints:
o POST /api/notifications: Send a new notification.
o GET /api/notifications/user/:userId: Retrieve notifications for a specific user.
o DELETE /api/notifications/:id: Remove a notification from the system.

4.3.5 Authentication and Authorization Service

This service provides the security backbone of the system by handling user authentication (via
JWT) and authorization (by verifying user roles before accessing resources).

 Responsibilities:
o Handling secure user login and logout.
o Issuing and validating JSON Web Tokens (JWT).
o Enforcing access control based on user roles.
 Endpoints:
o POST /api/auth/login: Authenticate a user and issue a JWT.
o POST /api/auth/logout: Invalidate a user's session.
o Middleware to protect routes by checking token validity.

43
Figure 12 Deployment Diagram

4.4 Data Dictionary

The Data Dictionary is a structured collection of data elements used in the system. It defines the
types of data stored, their formats, and relationships between different data entities.

Entity Attribute Type Description

User userId String Unique identifier for each user.

name String Full name of the user.

44
 email String User's email address.

password String Encrypted password for login.

role String Role of the user (Admin, Project PI,

Reviewer).

phoneNumber String User's contact number.

gender String Gender of the user.

country String User's country of residence.

Project projectId String Unique project identifier.

title String Title of the project.

description String Detailed description of the project.

startDate Date Start date of the project.

45
 endDate Date End date of the project.

projectPI userId Reference to the Project PI managing the

project.

reviewer userId Reference to the Reviewer assigned to the

project.

Progress updateId String Unique identifier for each progress update.

Update

projectId String Reference to the project the update belongs

to.

dateSubmitted Date Date the progress update was submitted.

description String Detailed description of the progress made.

progressPercentag Number Percentage of the project completed.

e

46
 issuesEncountered String Description of any issues encountered.

filesUploaded Array List of files uploaded as part of the update.

Notification notificationId String Unique identifier for each notification.

recipient userId Reference to the user receiving the

notification.

message String The notification message.

dateSent Date Date the notification was sent.

Auth Token tokenId String Unique identifier for each JWT token.

userId String Reference to the user associated with the

token.

issuedAt Date Timestamp when the token was issued.

expiresAt Date Expiration time of the token.

47
5. Chapter Five: Implementation

5.1 Overview of Implementation

The Project Monitoring System was developed using modern web technologies to digitize and
streamline project management. The system enables admins, Project PIs, and reviewers to
manage projects, submit progress reports, assign reviewers, and provide feedback. The
implementation is based on the MERN stack (MongoDB, [Link], [Link], and [Link]),
ensuring scalability, flexibility, and security.

5.2 Technologies Used

 Frontend: The user interface was implemented using [Link], a powerful JavaScript
library for building responsive, component-based UIs. React was chosen for its ability to
provide a smooth user experience and its strong support for building single-page
applications (SPA).
 Backend: The server-side logic was developed using [Link] and [Link]. This setup
ensures efficient handling of requests, routing, and API management.
 Database: MongoDB, a NoSQL database, was used to store user information, project
details, and progress reports. MongoDB was chosen for its flexibility in handling
unstructured data and its scalability.
 Version Control: Git and GitHub were used to track code changes, manage collaboration,
and maintain the integrity of the project across development stages.

5.3 User Interface Implementation

The user interface (UI) was designed with a focus on simplicity and ease of navigation. The
system’s UI consists of multiple components such as:

48
  Login and Registration: Allow users to register and log into the system. Input validation
ensures that all necessary information is provided.
 Dashboard: Displays the current projects and their status to the user. For Project PIs, it
includes options to create new projects or submit progress updates. For Admins, it
provides tools to assign reviewers and manage users.
 Project Creation Form: Allows Project PIs to input project details (title, description, start
and end dates) and submit them to the system.
 Progress Submission Page: Project PIs can submit detailed progress reports, including
task completion status, milestones, and issues encountered.

Figure 13 Admin Dashboard

5.3.1 Frontend ([Link]) Code

1. Component Structure:
o The React frontend is organized into reusable components, each responsible for a
specific part of the user interface. This modularity allows for easy updates and
maintenance.
2. State Management:

49
 o State is managed using React's built-in hooks like useState and useEffect,
ensuring efficient data handling and component re-renders.
3. API Integration:
o The frontend communicates with the backend via Axios for making HTTP
requests. This is where CORS comes into play to handle cross-origin requests
securely.
4. User Interface:
o The UI is styled using CSS modules or styled-components, providing a clean and
responsive design that adapts to different devices.

Figure 14 [Link]

50
Figure 15 [Link]

5.4 Backend Implementation

The backend API was implemented using [Link] to manage incoming requests from the
frontend. Key modules include:

 User Management: Handles user registration, authentication (using JWT tokens), and
role-based access control.
 Project Management: Allows Project PIs to create and manage projects. Admins can
assign reviewers to projects and monitor progress.

51
  Progress Reporting: Allows Project PIs to submit progress reports. Reviewers can
provide feedback on these reports, and Admins can monitor all activities.
 Security: Passwords are hashed before storing in the database using bcrypt, and all
sensitive actions are protected by JWT-based authentication, ensuring that only
authorized users can access certain features.

5.4.1 Backend ([Link]/[Link]) Code

[Link] Routing:

o [Link] is used to handle routing, defining endpoints that correspond to

different features of the application, such as user authentication and project
management.

Figure 16 Backend [Link]

[Link] Controllers:

52
  Controllers process the incoming requests, interact with the model layer, and send
appropriate responses back to the client, following the MVC pattern.

Figure 17 User Controller

[Link] Middleware:

 Middleware functions are employed for tasks such as logging, parsing request bodies, and
handling authentication using JWTs.

53
Figure 18 Authentication Middleware

5.5 Database Implementation

The MongoDB database was designed to handle the system’s dynamic data needs. Key
collections include:

 Users Collection: Stores user data, including roles (Admin, Project PI, Reviewer) and
authentication tokens.
 Projects Collection: Stores all project-related data, including project title, description,
status (Active, Completed), and the associated Project PI and Reviewer.
 Progress Updates Collection: Stores progress reports, including submission dates,
descriptions, percentage completed, and any issues faced.

54
Figure 19 Project Model

6. Chapter Six: Overall Internship Experience

6.1 Overall Internship Experience

This chapter highlights my overall experience during the internship program, focusing on the
skills I developed, the challenges I faced, and the lessons I learned. It encapsulates practical
skills, theoretical knowledge, personal development, work ethic, and insights into the industry.

6.1.1 Benefits

The internship provided me with the opportunity to grow both professionally and personally.
Here’s a breakdown of the benefits I gained:

6.1.2 In Terms of Practical Skill

55
During the internship, I had the opportunity to work with modern technologies and frameworks
that significantly enhanced my practical skills:

 Familiarity with the MERN Stack: This experience allowed me to dive deeply into
MongoDB, [Link], React, and [Link]. I gained hands-on experience building full-
stack applications, which solidified my understanding of how frontend and backend
components interact in a real-world environment.
 Version Control with GitHub: I became proficient in using GitHub for version control,
collaboration, and project management. I learned how to manage repositories, contribute
to codebases, resolve merge conflicts, and collaborate efficiently with team members in
remote settings.
 Agile Software Development: One of the most valuable lessons was applying the Agile
methodology. I learned how iterative development, daily stand-ups, and sprint planning
play a critical role in managing complex software projects. Agile not only improved my
workflow but also showed me the importance of flexibility and constant feedback in the
development process.

6.1.3 In Terms of Theoretical Knowledge

While practical skills are crucial, the internship also deepened my theoretical understanding of
software development:

 The Ever-Evolving Nature of Technology: One key takeaway is that the tech field is
constantly changing. I realized that staying relevant in this industry requires continuous
learning and adaptation. Technologies I learned today could be outdated tomorrow, so a
daily commitment to self-improvement is necessary.
 Software Development Life Cycle (SDLC): I now have a much clearer perspective on
the entire SDLC, from requirement gathering to deployment. Each phase plays a vital
role in ensuring the success of a project, and I learned how these stages are
interdependent.
 NoSQL Databases and MongoDB: Before this internship, most of my academic
experience revolved around SQL and structured databases. However, working with
MongoDB gave me a deeper understanding of NoSQL databases, particularly how they
56
 offer faster performance for read-heavy applications. I now appreciate how the flexibility
of NoSQL databases can contribute to the scalability of modern web applications.

6.1.4 In Terms of Personal Skills

Beyond technical skills, the internship also provided many opportunities for personal growth:

 Effective Communication: I learned the importance of sharing ideas and experiences

openly with my colleagues. Whether it was through team meetings, code reviews, or
informal discussions, I improved my ability to articulate my thoughts and collaborate
effectively.
 Taking Initiative: One of the most important lessons was learning not to wait for
opportunities but to create them. I realized that in a fast-paced environment, waiting for
instructions is not always feasible. I learned to be proactive, seek out work, and take
ownership of my tasks.

6.1.5 In Terms of Work Ethic and Industrial Psychology

Work Ethic: One of the major lessons I learned during the internship is the importance of work
ethic. It’s not just about completing tasks but about doing them with a sense of responsibility,
diligence, and attention to detail. Consistently meeting deadlines, being punctual, and going the
extra mile were vital components of my work ethic development.

Industrial Psychology: Industrial psychology, in this context, refers to understanding the

workplace environment, employee behaviors, and organizational dynamics. After reflecting on
my experience and the broader industry, I recognized that many professionals, including myself,
are products of an educational system designed to train individuals for specific roles. We are
deployed into the workforce with a narrow focus on success, often defined by external metrics
like salary or job title.

However, I’ve come to realize that true success may require deviating from conventional paths.
The phrase “Higher risk, higher reward” resonates deeply with me. Sometimes, pursuing

57
unconventional routes or challenging the status quo can lead to greater personal and professional
fulfillment, even if it involves more risk.

6.2 Challenges Faced During the Internship Program

Despite the invaluable benefits, the internship was not without its challenges. These challenges
tested my problem-solving skills and adaptability:

 Bureau Permission Revoked: One of the more significant challenges was when an
unexpected administrative decision led to the revocation of bureau permissions, hindering
our project’s progress temporarily. This created delays in accessing certain resources
necessary for the system’s development.
 Collaboration Difficulties: Initially, collaborating on GitHub with a distributed team
posed challenges. There were issues with version control, merge conflicts, and ensuring
that everyone was on the same page, especially when working remotely.

6.3 Measures Taken for the Challenges Faced

 GitHub Collaboration: To overcome the challenges associated with GitHub

collaboration, I took the initiative to learn advanced Git features such as branching, pull
requests, and resolving merge conflicts. We also adopted a more structured workflow,
including reviewing code before merging, which helped reduce errors and improve
collaboration.
 Adaptability: When bureau permission was revoked, I learned the importance of staying
adaptable. We used the downtime to focus on refining other parts of the project, such as
documentation and testing, while waiting for the issue to be resolved.

6.4 Conclusion and Recommendation

6.4.1 Conclusion

The internship experience has been an incredible learning journey for me. I gained practical,
theoretical, and personal skills that have significantly enhanced my professional profile. From

58
mastering full-stack development with the MERN stack to better understanding the Software
Development Life Cycle (SDLC), I feel more prepared to tackle real-world challenges in the
tech industry.

I also learned the importance of continual learning and adaptability in a fast-growing field like
technology. The challenges I faced, such as GitHub collaboration and bureaucratic delays,
provided invaluable lessons in problem-solving and teamwork.

6.4.2 Recommendation

[Link] For the Organization

For the organization, I recommend the following:

 Enhance Communication Channels: While the team collaboration was good, I believe
that having more structured communication channels, such as regular check-ins or
weekly stand-ups, could have improved the collaboration process, especially in remote
work settings.
 Support for Interns: Creating a more defined support system for interns would be
beneficial. This could include mentorship programs, additional training in specific tools
(like GitHub), and more structured feedback sessions to help interns grow faster.

[Link] About an Internship Program

For future internship programs, I recommend:

 More Exposure to Real-World Challenges: I appreciated the real-world tasks I was

assigned, but I believe that exposing interns to even more challenging tasks or larger
projects would accelerate their learning. Working on projects with real deadlines and
clients can provide invaluable experience.
 Encouraging Risk-Taking and Innovation: While it's important to stick to established
processes, I think encouraging interns to take calculated risks and experiment with new
technologies or methods could foster a more innovative mindset. This would prepare
them better for the dynamic nature of the tech industry.

59
6.4.3 Final Thoughts

My internship experience has been one of growth, learning, and development. I leave this
chapter of my life with not only practical technical skills but also a deeper understanding of how
to navigate the complexities of the professional world. The combination of theoretical
knowledge and hands-on experience has prepared me well for the next stage of my career.

60