A Summer Training Report

Virtual Community Support

Submitted by

Anjali Patel
(12202110501003)

In partial fulfilment of the requirements for the Degree

of Bachelor of Technology
In

Computer Science and engineering (IOT)

G H Patel College of Engineering & Technology

The Charutar Vidya Mandal (CVM) University
Vallabh Vidyanagar

September 2025

CERTIFICATE
This is to certify that this work embodied in this report entitled, “Summer Training” was
carried out by Ms. Anjali Patel (12202110501003) at G H Patel College of Engineering &
Technology for partial fulfilment of degree of Bachelor of Technology in Computer
Science and Technology(IOT) to be awarded by The Charutar Vidya Mandal University,
Vallabh Vidyanagar. This work has been carried out under my supervision and is to the
satisfaction of department.

Dr. Nikhil Gondaliya Associate Professor, IT Department, GCET

Dr. Nikhil Gondaliya

Professor and Head, IT Department, GCET

Date:

Place: Vallabh Vidyanagar

Date:20th Jun 2025 ii

INTERNSHIP COMPLETION CERTIFICATE

This is to certify that Anjali Patel a student of GCET College has successfully
completed a 15-day internship at TatvaSoft from 26th May 2025 to 13th Jun
2025.

During the internship, Sarthak Nayankumar Patel worked on tasks related to .NET and
Angular technologies and demonstrated sincere effort and learning.

We trust the skills gained during this internship bring you success in your professional journey.
Best wishes for future endeavours.

For TatvaSoft

Authorized Signatory
Poorva Biswas
HR Dept.
Email: hr@[Link]
 Ground Floor, Tatva House, Behind Rajpath Club Road, Opp-Golf Academy,
Bodakdev, Ahmedabad-380054, Gujarat, India. Website: [Link], E-
mail: Info@[Link]; Phone: +91 9601421472.

Acknowledgement
The completion of any work depends upon cooperation, co-ordination, and combined efforts
of several sources of knowledge.

I would like to express my deepest thanks to Mr. Harsh Mehta, my industry mentor for his
valuable inputs, guidance, encouragement, and wholehearted cooperation throughout the
duration of our internship.

I would like to express our sincere thanks Head of the Department, Dr. Nikhil Gondaliya
and Principal, Dr. Kaushik Nath for providing a chance for such a wonderful internship
opportunity from the institute.
I would like to thank Dr. Nikhil Gondaliya, my Internal Guide for his support and advice to
complete the internship.

We are gratified to all faculty members of Department of Information Technology, G H

Patel College of Engineering and Technology, Vallabh Vidyanagar for their special attention
and suggestions.
ii

Ms. Anjali Patel (12202110501003)

Abstract

During my summer internship training in 2025, I participated

in a 15-day intensive program focused on full-stack web
development with a real-world project titled "Virtual
Community Support System". The objective of the project
was to design and implement a secure and scalable web
platform that enables volunteers to explore, apply for, and
manage social missions, while allowing administrators to
manage mission listings, user roles, and application data.
The project was developed using a PostgreSQL database for
backend data management, a .NET Web API for server-side
logic and RESTful endpoint creation, and Angular for
building a responsive and user-friendly frontend interface.
Key features included user authentication, role- based
authorization (Admin and User), CRUD operations for users
and missions, mission application workflows, sorting,
filtering, pagination, and profile management.
Security was handled using JWT-based token authentication,
while modular code structure and the Entity Framework
Code First approach ensured maintainability and future
scalability. The system was tested using Swagger and
deployed locally, with an introduction to AWS cloud
deployment for production readiness.
This project demonstrates the application of modern web
technologies to build a meaningful digital platform that
fosters community engagement, providing hands-on
experience in backend logic, iiifrontend design, and full-stack
integration within a professional development workflow.

List of Figures
Figure 5.4 Database Schema 22

Figure 6.6.1 Swagger Backend 25

Figure 6.6.2 Frontend 26

Table 1.2.2 Limitations of Monolithic or Static platforms 3

Table 1.4.1 Scope and Application Context 5

Table 6.2 Comparative Analysis 24

Institute Certificate ii

Company Certificate iii

Acknowledgement iv
Abstract V
List of Figures vi

List of Tables vii

1. Introduction 01
1.1 Background & Motivation 01
1.1.1 Importance of Community Support Platforms 01
1.1.2 Role of Full-Stack Development in Social
Applications 01
1.1.3 Challenges in Building Volunteer Management
Systems 02
1.2 Problem Statement 02
1.2.1 Need for Scalable Virtual Support Platforms 02
iv
1.2.2 Limitation of Monolithic or Static
Platforms 03
1.3 Objectives 03
1.3.1 Primary 04
1.3.2 Secondary 04
1.3.3 Tertiary 04
1.4 Scope and Limitations 05
1.4.1 Scope and Application Context 05
1.4.2 Time Frame covered 05
1.4.3 Project Limitations 06

2. Literature Review 07
2.1 Traditional Approaches to Community Platforms
07
2.1.1 Static Web Portals 07
2.1.2 Manual Workflows and Paper-based Tracking 07
2.2 Modern Full-Stack Development Approaches 08
2.2.1 Role-Based Web Applications 08
2.2.2 CRUD Architecture in Web Apps 08
2.3 Technologies Used in Virtual Community
Platform 09
2.3.1 PostgreSQL for Relational Data Management 09
2.3.2 .NET Web API for Backend Logic 09
2.3.3 Angular for Frontend Interaction 10

3. Methodology & Data Collection 11

3.1 Data Source and Collection 11

3.1.1 Application Data Model 11
3.1.2 Data Parameters 11
3.1.3 Data Quality Assessment 12
3.2 Data Preprocessing 12
3.2.1 Missing Value Handling 12
3.2.2 Data Normalization 13
3.3 Exploratory Data Analysis 14
iv
3.3.1 Statistical Summary 14
3.3.2 Trend Analysis 14
3.3.3 Seasonality Detection 14
3.3.4 Correlation Analysis 14

List of15
4. Time Series Analysis Tables
Stationary Testing
4.1 15
4.1.1 Checks and Validations 15
4.1.2 Data Transformation Techniques 15
4.1.3 Differencing Operations 16
4.2 Seasonal Decomposition 16
4.2.1 Trend Component Analysis 16
4.2.2 Seasonal Pattern 17
4.2.3 Residual Analysis 17
4.3 Event Dependencies and temporal Workflows 18
4.3.1 Application Workflows 18
4.3.2 Parameters Tuning and testing 18

5. Web Application Development 19

5.1 System Architecture 19
5.2 User Interface Design 20
Model Integration
5.3 20
5.4 Database Schema 22

6. Result & Analysis 23

6.1 Functional Evaluation 23

6.2 Comparative Analysis 24

6.3 System Performance Observations 25
6.4 Limitations and Areas for Improvement 25
6.5 Real-World Relevance 25
6.6 Screenshots 25
6.6.1 Swagger Backend 26
vi
6.6.2 Frontend. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
......................
27
7. Conclusion & Future Work 27
7.1 Summary of Achievements 28
Table
7.2 Future Enhancements of
29Contents
7.3 Technical Contributions 29
8. References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.................. 30
 CHAPTER 1: INTRODUCTION
1.1 BACKGROUND & MOTIVATION

1.1.1 Importance of Community Support Platforms

In today's digital-first world, the need for accessible,

organized, and role-driven community platforms has grown
rapidly. Whether in response to social causes, volunteering
missions, or local initiatives, digital tools can amplify
collaboration, streamline mission tracking, and increase user
engagement.

A well-designed virtual community support platform can:

• Enhance Participation: Allow volunteers to easily

discover, apply for, and manage missions relevant to
their interests.
• Promote Accountability: Enable administrators to

monitor and manage users, missions, and participation

records efficiently.
• Encourage Transparency: Ensure access control and

data integrity through secure user roles and authorization

flows. vii

• Bridge Technical Gaps: Provide user-friendly, scalable,

and deployable solutions for mission-driven

organizations.

The core idea behind this project is to CHAPTER

12202110501003 create1:a robust and
modular full-stack system where users (volunteers) and
INTRODUCTION

administrators can collaboratively manage and participate in

community support missions.

1.1.2 Role of Full-Stack Development

in Social Applications

Unlike traditional static websites, modern full-stack

applications can dynamically handle:

• User Role Management: Assigning and enforcing user

permissions (e.g., Admin vs. User).
 • Data-Driven Interfaces: Presenting personalized views
(e.g., “My Profile,” “My Missions”) using real-time
database queries.
• Secure Operations: Ensuring data safety and access

control with authentication and authorization.

• CRUD Automation: Empowering users to interact

directly with data (missions, themes, skills) through

intuitive interfaces.
This project leverages a powerful tech stack—PostgreSQL,
.NET Web API, and Angular—to build a responsive and
scalable platform that reflects the core needs of community
mission management.

1.1.3 Challenges in Building Volunteer Management

Systems

While there are several platforms in the social sector, most

suffer from one or more of the following issues:

• Rigid role management or absence of fine-grained access

control.
12202110501003 CHAPTER 1:
INTRODUCTION

• Lack of real-time interactivity and dynamic data handling.

• Manual backend processes for mission assignments and

approval workflows.
• Poor UI/UX for mission navigation, filtering, and

application.
• Complex or unclear deployment procedures for practical

use.

This internship project directly addresses these gaps by

implementing clean architecture, role-based access, and
deployment-ready code for real-world application.

1.2 PROBLEM STATEMENT

1.2.1 Need for Scalable Virtual Support Platforms

Community support platforms must be able to:

• Serve both admin and user roles without exposing

unintended access.
• Support CRUD operations across mission-related
entities like Theme, Skill, and
Application.
• Be scalable for future extensions like volunteer reviews,

The CVMmission
University progress tracking,
1 or chat functionality. GCE
• Be deployable to the cloud (e.g., AWS) for real-world T

usability.

Despite available tools and frameworks, beginner developers

often struggle to integrate frontend- backend-database
12202110501003 CHAPTER 1: layers
with robust security and modularity. This project bridges that
INTRODUCTION

learning curve using a structured 15-day plan.

1.2.2 Limitations of Monolithic or Static Platforms

Aspect Traditional Platforms Our Full-Stack Solution

User Hardcoded Dynamic role-based

Management access or static access control
pages

Mission Manual or Fully CRUD-

Handling spreadsheet- based enabled mission lifecycle

UI/UX Outdated forms and no Reactive Angular

interactivity frontend with filters
Experience

Minimal login Token-based

Security validation AuthN/AuthZ with
roles

Difficult to extend or Modular and API-driven

Scalability maintain architecture

Localhost Configured for AWS cloud

Deployment only or manual deployment
transfers

1.3 OBJECTIVES

1.3.1 Primary: Build Role-Based Community Platform

The core goal is to develop a secure, functional, and

intuitive Virtual Community Support
platform with two user roles:
The CVM University 1 GCE
• Admin: Can manage missions, themes, skills, and users.
T

• User (Volunteer): Can view and apply to missions, edit

profiles.

This platform was built from scratch using:

12202110501003 CHAPTER 1:
INTRODUCTION

• PostgreSQL for the database layer.

• .NET Web API for business logic and REST endpoints.

• Angular for a rich, reactive frontend.

1.3.2 Secondary: Implement Full CRUD + Filters +

Pagination

CRUD operations were developed for:

• Mission
• Theme
• Skill

• User
• Mission Applications

Advanced features like filtering, sorting, and paging were

also implemented for enhanced usability and performance.

1.3.3 Tertiary: Enable Deployment and Usability

The final objective was to:

• Build a responsive "My Profile" page for users.

• Configure and deploy the full project on AWS, making

it production-ready.
Ensure the system is modular
The •CVM University 1 enough for future GCE
T
integration (e.g., notifications, analytics).

1.4 SCOPE AND LIMITATIONS

12202110501003 CHAPTER 1:
1.4.1 Scope and Application Context INTRODUCTION

This project focuses on virtual missions for community

support, such as volunteering, event organizing, or
awareness campaigns.
Module Entities Involved Purpose

User Authentication and Role-

Management Admin, Volunteer based access

Title, CRUD operations for

Missions Description, mission listing
Theme
Skill name, Helps match users to
Skills Assigned Mission relevant missions

For filtering
Themes Mission category and mission
organization

Apply, retrieve, and manage

Applications User ↔ Mission application records

1.4.2 Time Frame Covered

This project was implemented in 15 days with structured

daily goals:

• Days 1–3: Setup PostgreSQL, Angular, and .NET Web

API foundation.
• Days 4–10: Authentication, Role-based Access, and

CRUD implementation.
• Days 11–13: Mission Apply flow, profile page, and
deployment.
The CVM University 1 GCE
• Days 14–15: Review, polish, and AWS configuration. T

1.4.3 Project Limitations

12202110501003 CHAPTER 1:
• UI Complexity: Limited time meant avoiding advanced
INTRODUCTION

UI elements like drag-drop or calendars.

• No Chat or Notifications: The system doesn’t include

real-time messaging or email alerts.

• Limited Analytics: No dashboards or metrics tracking for
now.
 • Static Data Source: Missions and applications are
inserted manually (no external APIs).

Future versions could enhance the platform with

gamification, mission progress tracking, chat, and mobile
responsiveness.

CHAPTER 2: LITERATURE REVIEW

2.1 TRADITIONAL APPROACHES TO
COMMUNITY PLATFORM
2.1.1 Static Web Portals

Earlier community platforms relied heavily on static websites

—simple HTML/CSS pages or CMS systems with little to no
interactivity. While they served the purpose of information
dissemination, they lacked user-level interactivity or backend
logic for handling dynamic tasks like user registration,
mission management, or application tracking.

Limitations of static systems include:

The CVM University 1 GCE
• No real-time updates or interactivity T

• Manual content management

• No access control or role differentiation
• Poor scalability and performance for growing
communities
12202110501003 CHAPTER 2: LITERATURE
REVIEW

2.1.2 Manual Workflows and Paper-based Tracking

Before digitization, community support tasks like volunteer

assignment, mission progress, or attendance were often
managed through spreadsheets or paperwork. This method
lacked transparency, was error-prone, and didn’t scale.

Key drawbacks:

• Limited traceability
• Data silos and fragmentation
 • Zero user personalization
• No live communication between users and organizers

These traditional methods fail to meet the demands of

modern communities that need efficient user role
management, digital collaboration, and automated
workflows.

2.2 MODERN FULL-STACK DEVELOPMENT

APPROACHES
2.2.1 Role-Based Web Applications

Role-based access control (RBAC) is a standard security

practice in modern web applications.
The CVM University 1 It restricts system
GCE
access based on users’ roles, preventing unauthorized access
T

to sensitive data or functionalities.

RBAC Benefits in Community Platforms:

12202110501003 CHAPTER 2: LITERATURE
REVIEW
• Isolates admin operations (CRUD on missions, themes,
users) from volunteer tasks (view/apply)
• Reduces security risks by minimizing data exposure

• Allows scalable permission management

• Enables personalized user experiences

Numerous studies and implementations have validated

RBAC as a core architectural principle in scalable, secure
systems (Sandhu et al., 1996).

2.2.2 CRUD Architecture in Web Apps

Create-Read-Update-Delete (CRUD) operations are the

backbone of all data-driven systems. In community support
platforms, CRUD enables:

• Admins to manage missions, themes, skills, and users

• Users to register, apply to missions, and update their
profile
The .NET Web API framework follows REST principles to
enable seamless CRUD operations, while Angular enables
reactive forms and binding for real-time frontend
interactivity.

Advantages of CRUD-centric architecture:

• Clear and maintainable backend

The CVM University 7
structure GCE
• Full lifecycle control of resources T

• Easy frontend/backend integration

• Flexible for future enhancements (e.g., reviews, ratings)

12202110501003 CHAPTER 2: LITERATURE

REVIEW

2.3 TECHNOLOGIES USED IN

VIRTUAL COMMUNITY PLATFORMS
2.3.1 PostgreSQL for Relational Data Management

PostgreSQL is an open-source, enterprise-class relational

database system known for its stability and extensibility. It
supports advanced data types, strong ACID compliance, and
powerful querying with SQL and subqueries.

Features that benefit this project:

• Relational integrity for mission-user relationships

• Joins and subqueries for mission filtering and skill
mapping
• Efficient data retrieval for search and pagination
• Schema flexibility for future expansion

According to Stonebraker et al. (2005), PostgreSQL has

become a go-to RDBMS for robust data modelling in full-
stack applications.

2.3.2 .NET Web API for Backend Logic

.NET Core Web API allows the development of RESTful

services that can handle HTTP requests for data access. It
follows a layered architecture using the Repository pattern
and Entity Framework (EF) for database interaction.
The CVM University 7 GCE
T
Notable features in this project:

• Clean separation of concerns via Controllers,

12202110501003
Services,
CHAPTER 2: LITERATURE
and Repositories REVIEW

• EF Code First approach for faster model-to-database

binding
• Use of LINQ for expressive and optimized data queries
• Integration of JWT for secure authentication/authorization

Microsoft’s .NET stack is widely adopted in enterprise-level

projects due to its maintainability and rich ecosystem.

2.3.3 Angular for Frontend Interaction

Angular, developed by Google, is a powerful framework for

building dynamic and modular single- page applications
(SPAs). It provides two-way data binding, dependency
injection, and powerful form handling capabilities.

Angular’s role in this project:

• Reactive forms for login and mission applications

• Role-aware navigation and UI rendering
• Real-time validation and data binding
• Responsive layout for better user experience

Modern community platforms need fast, interactive frontends

that load without page refreshes, which Angular delivers
efficiently (Misko Hevery, 2014).

The CVM University 7 GCE

T

CHAPTER 3: METHODOLOGY & DATA

COLLECTION
3.1 DATA SOURCE AND COLLECTION
12202110501003 CHAPTER 3: METHODOLOGY & DATA
COLLECTION
3.1.1 Application Data Model

The primary data source for this project is a PostgreSQL

relational database, which stores all application-specific
data such as user accounts, roles, missions, mission
applications, and related entities. The backend was built
using .NET Core Web API with Entity Framework (EF)
Core using the Code-First approach, where C# classes
(models) define the database schema. EF Core automatically
generates the database structure via migrations.

The database was locally hosted during development, and

tables were populated via backend API calls during testing.
All CRUD operations (Create, Read, Update, Delete) were
performed through the API endpoints, and Swagger was used
to validate and test these endpoints.

The data model includes:

• Users: Contains user credentials and role information

(Admin/User).
• Missions: Defines volunteering opportunities available on

the platform.
• Mission Applications: Tracks which users have applied
for which missions.
• Themes and Skills: Used for filtering and categorizing
missions.

All data entered through the frontend Angular application

was validated and persisted10 in PostgreSQL through GCE
The CVM University
the
backend API, making the platform fully dynamic and data-
T

driven.

3.1.2 Data Parameters

12202110501003 CHAPTER 3: METHODOLOGY & DATA

The core dataset of the system includes structured records
COLLECTION
across several tables. Key parameters collected and utilized
are:

• User Data: Username, email, encrypted password, user

 role (Admin/User), and profile details.
• Mission Data: Title, description, availability, location,

required skills, theme, and number of seats.

• Application Data: User ID, Mission ID, application

status, and timestamp of application.

• Theme/Skill Data: Custom tags that define the type and

expertise area of each mission.

These parameters form the backbone of the system and are

used across all key functionalities such as mission listings,
applications, and role-based access control.

3.1.3 Data Quality Assessment

To ensure data integrity and consistency across the

application, the following quality assessment techniques were
used during development and testing:

• Completeness Checks: Required fields in forms were

validated using Angular’s reactive form validators,
ensuring no critical field was left empty. Backend also
enforced validation using data annotations.
• Consistency Validation: Logical checks were built into

the application—for example, preventing users from

applying to the same mission
The CVM University 11
multiple times, or ensuring
GCE
an admin cannot apply for a mission. T

• Outlier Detection: While the system didn’t use numeric

forecasting, basic range checks (e.g., mission seat counts

must be > 0) and conditional constraints were enforced
to avoid invalid data.
12202110501003 CHAPTER 3: METHODOLOGY & DATA
• Temporal Consistency:COLLECTION
Date-time fields (such as
application timestamps) were stored in a standardized
format using UTC time, and were verified for
correctness during development and testing phases.

3.2 DATA PREPROCESSING

3.2.1 Missing Value Handling

Given that the application was built from scratch with

complete control over data entry and validation, missing
values were mainly handled at the frontend and API level:
 • Form Validations: Angular forms were configured to
disallow submissions unless all required fields were
completed.
• Server-side Safeguards: The .NET Web API used model

validation annotations (like

[Required], [StringLength], etc.) to ensure null or empty values were

not accepted.
• Fallback Defaults: In some tables, default values were
set for optional fields such as status or timestamps.
• Exclusion Criteria: In test scenarios, any records with

incomplete or test-dummy data were filtered out and

excluded from the production-ready environment.

3.2.2 Data Normalization

Although traditional data normalization techniques (like min-

max scaling or z-score standardization) are typically
associated with numerical analytics
The CVM University 11
or machine learning,
GCE
T
basic normalization principles were applied in this context
through:

• Relational Normalization: Database tables were

normalized to at least CHAPTER
12202110501003 3NF (Third Normal
3: METHODOLOGY Form) to
& DATA
COLLECTION
eliminate redundancy and maintain referential integrity.
• Consistent Formats: Text fields (e.g., usernames,
mission titles) were stored in standardized casing; date
formats were unified using ISO 8601.
• Foreign Key Normalization: Relationships between

users, missions, themes, and skills were maintained via

foreign keys and navigation properties, which helped
reduce duplication.

3.3 EXPLORATORY DATA ANALYSIS

3.3.1 Statistical Summary

While this project did not involve statistical analysis in the

traditional sense (like calculating mean or skewness), the
following checks and insights were derived during
development:

•User Distribution: Tracked the number of users by role

(Admin/User) to validate access control logic.
• Mission Load: Analysed the number of missions
 available vs. applications submitted to ensure the
application flow was being used correctly.

• Application Frequency: Observed common usage

patterns such as which missions were most applied for,
and peak activity times during testing.

These summaries helped identify functionality gaps and

guided UI/UX improvements.11
The CVM University GCE
T

3.3.2 Trend Analysis

Although long-term trends weren’t the focus due to the short

internship
12202110501003 duration, some workflow- CHAPTER
based 4:trends were
TIME SERIES
evaluated: ANALYSIS

• Application Flow: Sequential testing of application

submission, status update, and deletion helped refine the
logic and reveal process inefficiencies.
• User Behaviour: Repeated user actions like multiple
mission applications or profile updates were tested to
simulate real usage patterns.

Any inconsistencies observed during these test cases were

used to fix bugs and enhance stability.

3.3.3 Seasonality Detection

Since this was not a time-series or seasonal data-based

project, seasonality detection was not applicable. However,
calendar logic was implemented in features like:

• Date-Picker Validations: Ensured that mission start/end

dates are not in the past and follow a logical order.
• Deadline-Based Visibility: Placeholder logic was
explored to filter out expired missions based on current
date, simulating basic calendar awareness in the
application.

3.3.4 Correlation Analysis

While not a data science project in nature, functional

correlations were crucial in system behaviour:
 • Role vs Access Correlation: Direct correlation between
The CVMuser roles and accessible
University 11 components ensured GCE that
Admins had CRUD control while Users had view/apply T

permissions only.
• Mission-Application Linkage: Application logic
required strong relational consistency between missions
and the users applying, enforced
12202110501003
via foreign keys and
CHAPTER 4: TIME SERIES
backend logic. ANALYSIS

CHAPTER 4: TIME SERIES ANALYSIS

4.1 STATIONARITY TESTING

Although this project does not involve traditional time series

forecasting (such as ARIMA models), time-based patterns
and behaviours are critical to managing the lifecycle of
missions, applications, and user activity. Temporal
consistency and integrity are essential to ensuring that users
interact with the system as expected and that date-dependent
operations behave correctly.

Stationarity in this context refers to maintaining a

predictable and valid structure in user- and mission-related
data across time — especially for deadlines, creation
timestamps, and application windows.

4.1.1 Checks and Validations

However, application-level checks and validations were

introduced to ensure temporal consistency in user
workflows. For example:

• Mission start dates must be later than the creation date.

• Application timestamps are automatically assigned using

[Link].

• Historical data (e.g., mission listings) is filtered based on

The CVM University 17 GCE
whether missions are expired or ongoing. T

Instead of ADF tests, the system implements:

 • Logical assertions for date sequences.
12202110501003 CHAPTER 4: TIME SERIES
ANALYSIS

• Form validation for start/end date consistency.

• Query filters to sort upcoming and active missions.

These measures replace the need for statistical stationarity

tests with deterministic application logic.

4.1.2 Data Transformation Techniques

While statistical transformations like differencing or log-

scaling are unnecessary here, data normalization and
transformation are used in the context of user experience
and query optimization. Some key techniques:

• Date formatting: All timestamps are stored in UTC and

converted to readable formats on the frontend.
• Status labelling: Missions are marked as "Upcoming",

"Ongoing", or "Closed" based on current date vs.

mission end date.
• Query normalization: Incoming filter parameters are

normalized (e.g., lowercase strings, trimmed inputs) to

maintain consistency across database queries.

These application-level transformations serve a similar

purpose: preparing temporal data for consistent
consumption and decision-making.

4.1.3 Differencing Operations

Differencing is not directly used in this project. However,

analogous
The operations include:17
CVM University GCE
T

• Time gap calculations: Used to determine how long ago

a mission was created or when a user applied.
• Deadline countdowns: Frontend timers or badges show

time remaining before application

12202110501003 deadlines.
CHAPTER 4: TIME SERIES
ANALYSIS
• Duration filters: Backend queries allow users to filter

missions by duration ranges.

These operations help users and admins make timing-based

decisions, much like differencing helps in forecasting
models.
4.2 SEASONAL DECOMPOSITION

The platform does not handle seasonally recurring datasets

(e.g., monthly/quarterly financial series). However, user and
mission activity can still exhibit temporal patterns,
especially with repeated use over time (e.g., project
deployments, events, or mission cycles).

4.2.1 Trend Component Analysis

In lieu of statistical trend modelling, trend analysis in the

platform focuses on user engagement and mission creation
frequency over time. Though not visualized, some example
insights could include:

• Increasing trend: Growing number of users or mission

applications over time.
• Drop-off trend: Decrease in applications as deadlines

approach.
• Repetition pattern: Reuse of similar mission themes by

Admins across time.

Such trends help improve user

The CVM University 17
retention and platform utility
GCE
T
when analysed during testing or future audits.

12202110501003 CHAPTER 4: TIME SERIES

4.2.2 Seasonal Pattern ANALYSIS

This platform exhibits event-driven temporal behaviour,

such as:

• Monthly Events: Admins posting missions tied to

calendar months or festivals.
• End-of-semester Missions: Common during academic

cycles in community-focused deployments.

• High-activity Days: Peaks in user registrations or

applications post-announcement.

While formal seasonal decomposition isn’t performed, the

application supports features like:
 • Date filters (by month or range),
• Calendar pickers for mission planning,

• Potential analytics integration for seasonal behaviour

tracking in future versions.

4.2.3 Residual Analysis

In this platform, “residuals” are interpreted as unexpected

behaviours or anomalies in data over time. Key areas:

1. Validation Failures:
o Missions expiring prematurely due to wrong dates.

o Users applying after deadline because of time zone

The CVM University 17 GCE
mismatches. T

2. Edge Cases:
oDuplicate mission applications (resolved via unique
constraints).
o Users applying to missions
12202110501003 with
CHAPTER 5: no available seats.
WEB APPLICATION
DEVELOPMENT
3. Error Logging:
o Backend logs residual errors and failed transactions.

o Helps developers pinpoint anomalies and refine

workflows.

This residual tracking is essential for ensuring system

robustness and debugging.

4.3 EVENT DEPENDENCIES AND TEMPORAL

WORKFLOWS
Event dependencies and temporal workflows were
managed through programmatic logic.

4.3.1 Application Workflows

Application workflows established dependency chains such

as:

• Mission Creation → Application Start Time → User

 Submission → Application Status → Admin Review

These event chains simulate time-lagged interactions, with

logs and timestamps acting as proxies for time-based
correlation tracking.

In future enhancements, such plots could be used to:

• Analyse user login frequency over weeks.

• Track mission engagement lags.
The CVM University 17 GCE
T

• Detect usage patterns for platform scaling.

12202110501003 CHAPTER 5: WEB APPLICATION

DEVELOPMENT

4.3.2 Parameter Tuning and Testing

The concept of parameter tuning and testing was applied

to:

• Pagination logic: Choosing optimal page size for

frontend performance.
• Query parameters: Sorting, filtering, and search

keywords.
• Role configurations: Testing user/admin rights across

different components.

While not statistical, this reflects the same iterative trial-and-

error refinement needed to optimize system performance
and user experience.

CHAPTER 5: WEB APPLICATION

DEVELOPMENT
5.1 SYSTEM ARCHITECTURE
The Virtual Community Support web application is built on a
modular and scalable architecture that separates concerns
between the frontend, backend,
The CVM University 20
and database layers. GCE
T
The
system follows an N- tier architecture pattern consisting of
the presentation layer (Angular), business logic layer (.NET
Web API), and data access layer (Entity Framework Core
with PostgreSQL).
12202110501003 CHAPTER 5: WEB APPLICATION
DEVELOPMENT
• Backend Framework: The application backend is
developed using .NET Web API, providing a robust and
scalable environment for handling HTTP requests,
implementing business logic, and interacting with the
database via Entity Framework. The API is structured
following RESTful principles for consistent interaction.
• N-Tier Structure & Repository Pattern: The backend

follows the N-tier folder architecture, separating

concerns into Controllers, Services, Repositories, and
Models. This enhances maintainability, testability, and
modular development. The Repository Pattern
abstracts data access logic, providing a clean interface to
the application layer.
• Database Integration: The system uses PostgreSQL as

the primary relational database. Database models are

created using the Code First approach via Entity
Framework Core. Tables include Users, Missions, Themes, Skills, and
MissionApplications, with proper relationships and foreign key

constraints.
• API Design: The application exposes RESTful APIs for

each functional unit— authentication, mission

management, user profile, and application handling.
These APIs support standard operations such as GET,
POST, PUT, and DELETE, with clearly defined
request/response schemas.
• Configuration Management: Environment-specific
configurations (e.g., connection strings, JWT secrets) are
managed via the [Link] file in .NET. This enables
seamless switching between development, staging, and
production environments without altering code.
• Security Implementation: The application implements

JWT-based authentication and

The CVM University 23 GCE
Role-Based Authorization (Admin/User). Secure login
T

APIs validate user credentials and

12202110501003 CHAPTER 5: WEB APPLICATION
generate access tokens, which are required to access
DEVELOPMENT
protected routes. Admin-only actions (like mission
creation) are gated via role-check middleware.

5.2 USER INTERFACE DESIGN

The frontend of the system is developed using Angular,

focusing on a responsive and user-friendly experience for
both volunteers and administrators.

• Responsive Layout: Built with Angular and Bootstrap,

the UI supports responsive design across desktop, tablet,
and mobile devices. Components are designed to
automatically adjust layouts and grid systems based on
screen size.
• Navigation Structure: A consistent navigation bar

provides quick access to core features— Mission

Listings, My Applications, Profile Management, and
Admin Panel. Route guards ensure users only access
pages according to their role and authentication state.
• Data Presentation: Missions and user data are displayed

using Angular’s built-in data binding and reusable

components. Mission cards feature summary data like
title, description, theme, and available skills. Admin
views present editable tables for CRUD operations.
• Form Design: Angular Reactive Forms are used for login,

registration, and CRUD operations. Forms include

client-side validations (required fields, pattern checks)
and show dynamic error messages for better UX.
• Progress Indicators: Angular services display loading
The CVMspinners
University during API calls,
23 especially when performingGCE
T
backend-intensive operations like mission CRUD or user
filtering.
• Error Handling: The application handles and displays

HTTP error responses (e.g., 401 Unauthorized, 404 Not

Found, 500 Server Error) using
12202110501003 a centralized
CHAPTER 6: RESULT & error
ANALYSIS
interceptor. User- friendly messages are shown to guide
the user appropriately.
• Accessibility Features: Basic accessibility practices like

ARIA roles, keyboard navigability, and sufficient colour

contrast are followed. Further WCAG compliance could
be added in future iterations.
5.3 MODULE INTEGRATION (RENAMED FROM
“MODEL INTEGRATION”)
Since your project does not include ML/statistical models,
this section has been adapted to cover Module Integration—
how different functional modules (Users, Missions, Skills,
Applications) are tied together across backend and frontend.

• Modular Design: The system is divided into reusable

Angular components (mission-card, application-form, user-profile) and
backend services (MissionService, UserService,
AuthService). This modularity aids scalability and team
collaboration.
• Asynchronous Processing: Angular’s HttpClient and
Observables are used to perform asynchronous API
calls, enabling non-blocking UI interactions. For
example, mission listings load while the user continues
browsing other sections.
• Error Recovery: Backend API endpoints are wrapped in

try-catch blocks, and Angular interceptors provide user-

friendly error messages. If a backend process fails (e.g.,
duplicate mission entry), appropriate HTTP status and
messages are returned.
Data
The •CVM Caching: Frequently
University 23 accessed data (like logged-in GCE
user info and missions) is cached locally using Angular T

services or browser storage to minimize redundant API

calls and enhance performance.
• Validation Layer: Input data is validated both on the

client side (Angular forms) and server side (.NET model

12202110501003 CHAPTER 6: RESULT &
validation attributes). This ensures data integrity across
ANALYSIS

operations.
• Scalability Considerations: The system is designed with

separation of concerns and scalable service structure.

Future enhancements could involve microservices,
cloud-hosted databases, and load balancing.
• API Consistency: All APIs follow RESTful standards,

using consistent URL schemes (/api/users, /api/missions, etc.) and

standard HTTP methods. Responses follow a consistent
JSON structure with clear data, status, and message
fields.

5.4 DATABASE SCHEMA

 CHAPTER 6: RESULTS & ANALYSIS

6.1 FUNCTIONAL EVALUATION

The Virtual Community Support system was developed

through a progressive 15-day internship plan, integrating
PostgreSQL, Angular, and .NET Web API. The system’s core
modules include user authentication, role-based authorization
(Admin/User), mission management (CRUD), theme and
skill tagging, user profile management, and mission
application functionality.
The CVM University 27 GCE
Each implemented module was evaluated based on T its
functionality, data accuracy, and user experience:

• Authentication & Authorization: Implemented via

.NET Web API with secure login endpoints, password
12202110501003 CHAPTER 6: RESULT &
validation, and JWT-based sessionANALYSIS
management. Admins
and Users have distinct access scopes, successfully
restricting sensitive endpoints (e.g., CRUD operations)
to authorized roles.
• CRUD Operations (Users, Missions, Themes, Skills):

All entities support full Create, Read, Update, and

Delete operations. Entity Framework Core with Code
First approach streamlined schema generation. LINQ
queries enabled clean and efficient data manipulation.
• Filtering, Sorting & Pagination: Integrated on both

backend (via LINQ) and frontend (Angular table

components), improving performance and user
navigation when handling large datasets.
• Mission Application Flow: Users can view missions,

apply for them, and review their application history.

Admins can view applied users, ensuring two-way
visibility and system transparency.
• Profile Management: Basic profile update features were

added, allowing users to personalize and manage their

data.
6.2 COMPARATIVE ANALYSIS

Throughout the internship, different approaches and

technologies were explored. Key comparisons include:
Early Stage Final Stage
Feature Verdict
(Manual/Raw) (Framework/Optimized)

Database EF with LINQ

Operations Raw SQL Entity Framework + LINQ improved productivity,
queries reduced boilerplate
Routing & Final structure ensured
The CVM University Basic Angular Nested
27 components with GCE
Component better code reuse and
T
routing service integration
Handling modularity

Authentication JWT approach

Logic Static validation JWT-based secure tokens enabled scalable,
secure session
handling
Fully implemented Essential for
Role
12202110501003 None CHAPTER 6: RESULT &
(Admin/User ACLs)ANALYSIS controlling access to
Management
critical features
Swagger
API Testing Postman only Swagger + Postman documentation boosted
clarity & testing
speed

Angular form validation & Improved user

UI Feedback Console logs error messages experience and input
correctness

This evolution in architecture and methodology reflected a

clear learning curve and real-world software development
adoption.

6.3 SYSTEM PERFORMANCE OBSERVATIONS

• API Response Time: Average response time was within

200–300ms for CRUD operations over local
development. Optimization via indexed PostgreSQL
tables and asynchronous API methods improved
responsiveness.
• Frontend Performance: Angular’s reactive rendering

ensured smooth transitions, even with nested

components and multi-tab data views.
• Scalability Consideration: Though built as a basic MVP,

the modular structure and layered backend (Controllers

→ Services → Repository → DB) lays a solid
foundation for scaling in the future.
 • Security Practices: Role-based authorization and token
expiration logic reduce 27risks of unauthorized access.
The CVM University GCE
However, OAuth and password encryption
T

improvements can be considered for production

environments.

6.4 LIMITATIONS & AREAS FOR IMPROVEMENT

12202110501003 CHAPTER 7: CONCLUSION & FUTURE
WORK
While the project met most internship objectives, several
areas were identified for future enhancements:

• No Image/File Upload Support: User profile images or

mission-related documents could not be uploaded.
• No Real-Time Feedback: Lack of WebSocket integration

or refresh triggers meant users had to reload pages to see

updates (e.g., mission status or new applications).
• Simplistic UI/UX: The frontend was functional but

minimal. Styling, responsiveness, and accessibility

features were not the focus during training.
• Limited Validation Rules: Backend and frontend

validations were basic; robust error handling and form

constraints would enhance reliability.
6.5 REAL-WORLD RELEVANCE

The project provides a practical demonstration of how

modern full-stack applications are built using popular
frameworks and best practices. It simulates a real-world
platform where NGOs or social organizations could post
missions and users could volunteer — showcasing both
administrative control and user engagement through a secure
and maintainable system.

6.6 SCREENSHOTS

The CVM University 27 GCE

T

12202110501003 CHAPTER 7: CONCLUSION & FUTURE

 WORK
Fig 6.6.1 Swagger Backend

Fig 6.6.2 Frontend

CHAPTER 7: CONCLUSION & FUTURE

WORK
7.1 SUMMARY OF ACHIEVEMENTS

The Virtual Community Support project successfully

delivered a functional, secure, and modular web-based
platform to facilitate mission-based volunteering activities.
Built using PostgreSQL,
.NET Web API, and Angular, the system encapsulates key
features like user management, mission applications, and
role-based
The CVM University authorization —28 all developed throughGCE
T
a
structured 15-day internship training plan.

Technical Implementation: The backend was developed

using .NET with the Entity Framework Code First approach.
All major entities — Users, Missions,
12202110501003 CHAPTER 7: Themes,
CONCLUSION and Skills —
& FUTURE
WORK
support full CRUD operations, with secure access managed
through JWT authentication and role-based authorization for
Admin and User roles. The layered architecture and use of
LINQ ensured maintainability and clean code practices.

Frontend Development: Angular was used to build a

responsive and modular frontend, enabling users to interact
with forms, view mission listings, manage their profiles, and
perform CRUD operations where authorized. Angular
services and routing provided a smooth and dynamic single-
page experience.

Authentication & Authorization: Secure login with JWT

tokens and strict role-based access control ensured system
integrity and protection of admin functionalities.
Unauthorized actions are appropriately blocked and user
sessions managed efficiently.

Data Management & Integrity: The use of PostgreSQL as

the database ensured reliable data storage, and schema design
was aligned with relational integrity principles. LINQ queries
allowed for efficient data handling, including sorting,
filtering, pagination, and joins.

Mission Application Flow: Users can browse missions and

apply for them through a clean workflow. Admins can track
user applications, aligning with the core purpose of building
a virtual community support system.

Deployment Readiness: Initial deployment strategies and

The CVM University 28 GCE
AWS service concepts were covered on the final day ofT the
internship, ensuring the system is prepared for cloud
deployment and scaling.

7.2 FUTURE ENHANCEMENTS

12202110501003 CHAPTER 8:
REFERENCES
Though the current system fulfils the basic requirements of a
volunteering platform, several improvements and extensions
can make it more robust, user-friendly, and production-ready.

1. UI/UX Enhancements:

• Improve UI design using frameworks like Bootstrap or

Angular Material.
• Add animations, responsive design, and accessibility
features.
• Provide a better mobile experience.

2. File Upload Functionality:

 • Enable users to upload profile pictures.
• Allow mission creators (admins) to upload related

documents (e.g., posters, PDFs).

3. Real-Time Features:

• Integrate WebSockets or SignalR for real-time mission

updates and application status changes.
• Add real-time notifications for users when a mission is

posted or accepted.

4. Advanced Search & Filtering:

• Implement multi-criteria search on missions (e.g.,

The CVM University 30
31 GCE
location, skill, date, theme). T

• Add mission tags and user skill matching to recommend

relevant missions.

5. Audit & Logging System:

• Implement an activity log for admins to monitor actions

taken by users.
• Track mission status changes and failed login attempts.

6. Mobile Application Integration:

• Develop a cross-platform mobile app using Flutter or

React Native.
• Sync it with the existing backend to increase accessibility

for volunteers.

7. External Communication Features:

• Integrate basic chat or message features between

volunteers and mission creators.
• Allow notifications via email or SMS for mission status
updates.
8. Deployment & Scalability:

• Complete cloud deployment using AWS (e.g., EC2, RDS,

S3).
• Integrate CI/CD pipelines for faster and safer updates.

7.3 TECHNICAL CONTRIBUTIONS

This internship project provided practical experience in

building a scalable full-stack web application while adhering
to industry-standard development practices. Major technical
contributions include:

• End-to-End Development Workflow: Covering

everything from backend database schema creation
(PostgreSQL) to frontend development (Angular) and
secure API development (.NET).
• Authentication & Authorization: Demonstrated
implementation of JWT-based auth and role-based
access control, essential for multi-user systems.
• Modular, Scalable Architecture: Developed using a

clean N-tier structure separating concerns across

controller, service, and repository layers — making the
codebase maintainable and extensible.
• Entity Framework & LINQ: Leveraged EF Core’s Code

First approach and LINQ for clean, readable data access

logic.
• Practical Understanding of REST APIs: Built and

tested multiple endpoints with Swagger and Postman,

simulating a professional API-first development
environment.
• Cloud Readiness & CI/CD Understanding: Gained

initial exposure to AWS and deployment strategies,

preparing the system for future production-level
deployment.

REFERENCES

1. Microsoft. .NET Documentation.

2. Microsoft. [Link] Core Web API Documentation.
3. Microsoft. Entity Framework Core Documentation.
4. Angular Team. Angular Documentation.
5. PostgreSQL Global Development Group. PostgreSQL
Documentation.
6. [Link]. Introduction to JSON Web Tokens.
7. Swagger. Swagger OpenAPI Tools.

8. AWS. Amazon Web Services Documentation.

9. W3Schools. HTML, CSS, JavaScript Reference Guides.

10. Stack Overflow. Community Q&A for Web Developers.