Camp Education Society’s

Dr. Arvind B. Telang Senior College

Nigdi, Pune – 411 044

A
PROJECT REPORT
ON

“ Serverless Web Application for

Student Data Management using
AWS”

Submitted to

Savitribai Phule Pune University

In Fulfillment Of

[Link]. (Computer Science) Sem-IV

Academic Year
2024-25
1
2
3
 ACKNOWLEDGMENT

I would like to express my gratitude and sincere regards to

the following people to whom I am grateful for the support and

help. Without guidance I have been not able to do this project

“Serverless Web Application for Student Data Management

using AWS”.

I would like to thanks my Project In-charge

and H.O.D. ([Link].) Department Prof. Midgule Vinayak for

providing her/his guidance during development of this project .

I sincerely thanks to all the faculty members of Computer

Science department for their guidance and support throughout the

Project.

Nikita Somnath Dargude

4
 INDEX
Sr. No. Content Page No
1. Abstract 6
2. Introduction 7
2.1 motivation 8
2.2 problem statement 9
2.3 purpose/objective and goals 10 to 11
2.4 literature survey 12 to 13
2.5 project scope and limitations 14 to 16
3. System analysis 17
3.1 Comparative study of Existing systems 18 to 20
3.2 scope and limitations of existing systems 20 to 21
3.3 project perspective 21 to 22
3.4 features 22 to 25
3.5 stakeholders 25 to 26
3.6 Requirement analysis - Functional requirements, 26 to 28
performance requirements, security requirements
etc.
4. System Design 29 to 31
4.1 Design constraints 31 to 32
4.2 E-R Diagram 33
4.3 UML diagrams
Class Diagram
Object Diagram 33 to 35
Use Case Diagram
Activity Diagram
Component Diagram
Deployment Diagram
4.4 Data Model 36
4.5 User interfaces 36 to 38
5. Implementation details 39 to 42
5.1 Software/hardware specifications 43
6. Input and Output Screens 44
7. Reports 45 to 46
8. Testing 47
8.1 Test Plan, Black Box Testing or Data Validation Test
Cases, White Box Testing or Functional Validation 47 to 49
Test cases and results
9. Conclusion and Recommendations 50 to 51
10. Future Scope 52 to 53
11. Bibliography and References 54 to 55

5
 [Link]
A chatbot is a computer program that simulates and processes human conversation

allowing humans to interact with digital devices as if they were communicating with a

real person. Chatbots can be as simple as rudimentary programs that answer a simple

query with a single-line response, or as sophisticated as digital assistants that learn

and evolve to deliver increasing levels of personalization as they gather and process

information.

Chatbots help in customer support, generating information, user navigation etc.,

Organizations looking to increase sales or service productivity may adopt chatbots for

time savings and efficiency, as artificial intelligence (AI) chatbots can converse with

users and answer recurring questions. As consumers move away from traditional

forms of communication, many experts expect chat-based communication methods to

rise. Organizations increasingly use chatbot-based virtual assistants to handle simple

tasks, allowing human agents to focus on other responsibilities.

In this project we will use Python to build a simple chatbot that can interact with users.

Here we make use of AI and Natural Language Processing in Python to create and

train a chatbot to respond appropriately to an user requests.

Natural Language Processing (NLP) makes it possible for computers to understand

the human language. Behind the scenes, NLP analyzes the grammatical structure of

sentences and the individual meaning of words, then uses algorithms to extract

meaning and deliver outputs. In other words, it makes sense of human language so

that it can automatically perform different tasks. A well-known application of NLP is

chatbots. They help support teams solve issues by understanding common language

requests and responding automatically.

6
 [Link]
With the rise of modern digital platforms, organizations and institutions
increasingly rely on technology to streamline their operations. Web
applications play a critical role in enabling access to information anytime,
anywhere. However, traditional approaches to web development often
involve complexities such as managing servers, provisioning
infrastructure, and scaling resources manually. These challenges can
become a barrier, especially for small organizations or academic
institutions that may lack dedicated IT staff or a high budget.
To address this, cloud computing — particularly serverless architecture
— offers a revolutionary shift. Serverless computing allows developers to
focus purely on code and logic while leaving the infrastructure
management to cloud providers like Amazon Web Services (AWS). This
project takes advantage of AWS’s robust serverless ecosystem to
develop a fully functional, cost-effective Student Data Management Web
Application that is scalable, secure, and easy to maintain.
Serverless computing has revolutionized how web applications are
developed and deployed in the modern digital landscape. Unlike
traditional server-based applications, serverless architectures allow
developers to focus solely on application logic while the infrastructure
and scalability concerns are managed by cloud providers like Amazon
Web Services (AWS). This shift leads to faster development cycles,
lower operational overhead, and better alignment with cloud-native
development principles.
In this project, we leverage a suite of AWS services—Amazon S3,
Lambda, API Gateway, DynamoDB, and IAM—to build a cloud-native,
serverless student data management system. This application serves as
a practical implementation of theoretical knowledge, aiming to provide
hands-on experience in cloud infrastructure, backend development, and
API management.
The frontend of the application is hosted on Amazon S3 as a static
website, enabling users to interact through intuitive web pages. These
interactions trigger backend AWS Lambda functions via Amazon API
Gateway, which in turn perform CRUD operations on the student records

7
2.1 Motivation
The motivation for this project stemmed from observing how student
records are often maintained manually or in outdated systems. These
methods are time-consuming, prone to errors, and lack real-time
accessibility. Institutions require a digital solution that is both easy to use
and flexible enough to evolve with their needs. AWS serverless
technology enables such solutions by offering
ready-to-use cloud services that scale automatically and operate under a
pay-as-you-go pricing model.
This project aims to utilize AWS services like S3, Lambda, API Gateway,
DynamoDB, and IAM to develop a lightweight student data management
system. This system will provide a simple yet powerful platform for users
to input and retrieve student information without the need to manage
servers or install complex software.
In recent years, cloud computing has revolutionized how software
applications are designed, deployed, and maintained. The advent of
serverless computing has further advanced this evolution by abstracting
away infrastructure management, allowing developers to focus purely on
code and functionality. Educational institutions and training organizations
increasingly rely on digital systems for data management, particularly for
storing and accessing student records. The motivation behind this
project is to design a cost-effective, scalable, and secure serverless
application using AWS that can efficiently manage student data while
minimizing infrastructure overhead.
Traditional monolithic applications often require significant investment in
server hardware, software licenses, and human resources to manage
them. This approach does not scale well for organizations with limited
budgets and rapidly changing needs. Educational institutions, in
particular, face challenges maintaining digital infrastructure that meets
modern demands such as real-time data access, cloud storage, and
remote usability.
The emergence of serverless computing—where backend code runs in
managed, event-driven environments—presents a transformative
solution. The motivation behind this project stems from the need to

8
simplify application development and deployment while ensuring
performance, scalability, and cost control.

2.2 Problem Statement

In conventional application deployments, managing servers, configuring
databases, and ensuring secure access are tasks that require time,
expertise, and financial resources. These barriers often hinder small
organizations or educational teams from deploying reliable and scalable
applications. The absence of scalability and automation in legacy
systems makes them susceptible to downtime, performance bottlenecks,
and security issues.
This project addresses these problems by creating a completely
serverless application that avoids traditional infrastructure pitfalls. By
using AWS Lambda, API Gateway, and DynamoDB, the backend
automatically scales based on demand and eliminates idle resource
costs. S3 provides a highly durable and available platform for frontend
hosting. This setup removes the complexity of traditional server
management while maintaining enterprise-level performance, reliability,
and security.
Traditional web application development poses several
challenges:
 Infrastructure Setup: Requires provisioning of servers, storage,
and network components
 Maintenance: Needs regular updates, monitoring, and security
patching
 Scaling: Manual scaling leads to service disruption during high
demand
 Cost: High initial investment in hardware and software
 These issues are especially burdensome for smaller organizations.
This project attempts to solve these challenges by building
an application that:
 Does not require manual server management
 Automatically scales based on traffic
 Stores data flexibly using NoSQL structure
 Provides access via a static web frontend

9
  Using AWS serverless components, this project reduces
infrastructure complexity and enables a fully cloud-native web
solution tailored for academic use.

2.3 Purpose/Objective and Goals

 PURPOSE
The purpose of this project is to implement a serverless student
data management system using AWS.
The primary purpose of this project is to design, develop, and deploy a
scalable and cost-effective serverless web application using Amazon
Web Services (AWS) for managing student data. The project aims to
demonstrate how modern cloud technologies can simplify web
application development by eliminating the need for traditional server
infrastructure.
This project serves both educational and practical objectives, offering
students the opportunity to gain hands-on experience with cloud-native
tools and practices. By building a serverless solution, the project
highlights the advantages of using event-driven architecture, stateless
computation, and NoSQL data storage in a real-world context.

Specifically, the project intends to:

 Replace traditional server-based systems with a serverless
architecture to reduce complexity and maintenance.
 Utilize AWS Lambda for executing backend logic in Python without
provisioning servers.
 Employ Amazon API Gateway to manage and route HTTP
requests between the frontend and backend.
 Host a static frontend on Amazon S3 to enable user interaction via
web browsers.
 Store and manage student records using Amazon DynamoDB, a
highly scalable NoSQL database.
 Secure application components through fine-grained IAM roles and
policies.
 In doing so, the project fulfills its educational goal by applying
classroom concepts in a cloud environment while also

10
demonstrating the effectiveness of serverless computing for real-
world applications.

 OBJECTIVES:

1. To design a cloud-native web application using AWS services that

follows a serverless model.
2. To host a static frontend website using Amazon S3 for collecting
and displaying student data.
3. To develop backend logic with AWS Lambda functions written in
Python for handling data operations (insert and retrieve).

4. To use Amazon API Gateway for routing HTTP requests from the
frontend to the appropriate Lambda functions.

5. To store and retrieve student records using Amazon DynamoDB,

a fast and flexible NoSQL database.

6. To implement secure access control using AWS IAM roles and

policies for all integrated services.

7. To gain hands-on experience with key AWS services and cloud

concepts.

8. To demonstrate the scalability and flexibility of serverless

computing.

9. To ensure minimal cost and maintenance overhead through pay-

as-you-go service usage.

10. To test and validate application behavior using sample data and
API responses.

 GOALS OF THE PROJECT :

The main goals of this project are to conceptualize, develop, and

deploy a fully functional serverless web application using Amazon
Web Services (AWS) and to demonstrate how such a model can

11
 provide a scalable, cost-effective, and easy-to-maintain solution for
data management tasks—in this case, student data.

Technical Goals:

1. Eliminate server management by leveraging AWS Lambda for

executing backend logic without provisioning or managing
infrastructure.

2. Achieve high availability and scalability by using fully managed

services like API Gateway and DynamoDB.
3. Build a responsive and accessible frontend using static website
hosting on Amazon S3.
4. Establish secure and controlled access to cloud services using
IAM roles and policies.

5. Ensure fast data operations through efficient Lambda-

DynamoDB integration.

Educational Goals:
1. Apply theoretical knowledge of cloud computing in a real-world
project scenario.
2. Understand serverless application design patterns, including
event-driven architecture and stateless computing.
3. Gain practical experience in using AWS services such as S3,
Lambda, API Gateway, DynamoDB, and IAM.
4. Learn to deploy and monitor a complete cloud application using
the AWS Management Console.
5. Prepare comprehensive documentation and testing artifacts
suitable for academic evaluation and future reference.

2.4 Literature Survey

12
Serverless architecture has been widely adopted for building cloud-
native applications. Literature and case studies suggest that platforms
like AWS provide robust services (Lambda, API Gateway,
DynamoDB) that can significantly reduce operational burden and
cost. Educational institutions and startups have successfully used
these tools to deploy lightweight applications, proving the
architecture's efficiency and scalability.

The concept of serverless architecture has gained significant traction

in recent years, with growing interest from academia, industry
professionals, and cloud service providers. Serverless computing
represents a shift from traditional server-based infrastructure to a
model where the cloud provider dynamically manages the allocation
of machine resources. This paradigm has been enabled by
technologies such as Function-as-a-Service (FaaS) and Backend-as-
a-Service (BaaS).

A variety of scholarly articles and technical whitepapers

highlight the benefits of serverless computing, including:

 Scalability: Applications automatically scale up and down in

response to demand, which is particularly useful for applications
with unpredictable or variable workloads.

 Cost-efficiency: Serverless architectures follow a pay-per-use

billing model, which significantly reduces costs compared to
always-on server models.
 Reduced Operational Overhead: Developers do not need to
provision, scale, or maintain servers. This leads to faster
development cycles and reduced DevOps responsibilities.

Amazon Web Services (AWS) is one of the most comprehensive

and widely adopted platforms offering serverless capabilities
through services like:

 AWS Lambda: Executes backend logic in response to events.

13
  Amazon S3: Hosts static frontend files.

 Amazon DynamoDB: A NoSQL database that scales

automatically with application demands.

 Amazon API Gateway: Serves as a front door for APIs, routing

client requests to Lambda functions.

Previous academic projects and industry use cases demonstrate

how serverless solutions are particularly effective in building
small to medium-sized applications with dynamic workloads.
For example:

 Educational platforms have used serverless systems to collect

and analyze student activity data.
 E-commerce websites use Lambda and DynamoDB to handle
product catalogs and user sessions with minimal latency.
 Startups benefit from reduced infrastructure management,
allowing them to focus on core product development.

Moreover, documentation and tutorials provided by AWS and the

developer community support quick learning and experimentation.
The availability of these resources has made it easier for new
developers and students to build end-to-end applications with real-
world utility.
In the context of this project, the serverless architecture was adopted
to simplify application deployment, reduce infrastructure costs, and
achieve scalability and security. The model closely aligns with the
best practices suggested in literature, validating its practical
effectiveness and academic relevance.

2.5 Project Scope and Limitations

Project Scope
14
This project involves the development of a cloud-native serverless
web application hosted entirely on Amazon Web Services (AWS).
The scope includes all the necessary components required to build
a complete application that collects, stores, and retrieves student
data.

Key features within scope include:

 Designing a static frontend using HTML, CSS, and
JavaScript and hosting it using Amazon S3.

 Implementing backend logic using AWS Lambda

functions coded in Python to handle HTTP POST and
GET requests.

 Creating and configuring an API Gateway to route

client-side requests to Lambda functions.

 Creating a DynamoDB table to store student

information in a NoSQL format, allowing fast and
flexible access to data.

 Securing cloud resources with appropriate IAM roles

and bucket policies to enforce the principle of least
privilege.

 Integrating all components to form a fully functional

serverless web application.

 Testing the complete system with real-time inputs and

outputs.

 Documenting all aspects of the application for

academic review and future enhancement.

15
Project Limitations
While the project demonstrates the power and flexibility of
serverless architecture, it also has certain limitations due to
resource, time, and complexity constraints:

 Frontend Design Limitations: The user interface is basic

and does not include responsive or mobile-first design
principles. Advanced frameworks like React or Angular are
not used.

 Authentication and Authorization: The application does

not implement user-based login or secure authentication
mechanisms such as AWS Cognito or OAuth2.

 Data Validation and Error Handling: While basic input

validation is present, comprehensive backend data
validation, sanitization, and error logging are limited.

 Single Table Structure: The DynamoDB model uses a

single table, which may not scale well if more complex
relationships or multiple entity types are introduced.

 Scalability Testing: Although the application is built using

scalable technologies, extensive load and performance
testing is not included in this version.

 Limited Analytics and Monitoring: Advanced logging,

metrics, and monitoring tools like AWS CloudWatch
dashboards and X-Ray tracing are not deeply integrated.

16
 These limitations can be addressed in future versions of the
application as it evolves into a more feature-rich and production-
ready system.

[Link] analysis

System analysis is the process of examining a business situation with

the intent of improving it through improved procedures and methods. In
the context of this serverless application project, system analysis
involves studying the current practices of web application development
and contrasting them with the advantages offered by a serverless model
implemented on AWS.
System analysis is a critical phase in the software development lifecycle,
aimed at understanding, evaluating, and planning how a proposed
system will function in comparison to existing systems. It involves
identifying system requirements, analyzing existing problems, and
proposing effective technological solutions.
In the context of this project, the system analysis phase focuses on
understanding how traditional web application architectures compare to
serverless models. The goal is to assess the benefits and challenges
associated with shifting from monolithic or client-server-based
infrastructures to serverless platforms like AWS. This analysis provides
insight into how AWS services—such as Lambda, S3, API Gateway, and
DynamoDB—interact to form a fully functional, scalable, and cost-
effective student data management system.
The system is designed with specific stakeholders in mind, such as
students and administrators, and aims to deliver features like real-time
data storage, retrieval, and web access through secure, serverless
components. Functional, performance, and security requirements are
also identified to ensure the system meets modern cloud application
standards.

17
3.1 Comparative study of Existing systems

Existing student management systems typically rely on traditional

server-based infrastructures. These systems require continuous
maintenance, provisioning, and manual scaling. Popular setups include
LAMP (Linux, Apache, MySQL, PHP) stacks hosted on VPS or
dedicated servers, which involve high operating costs and complex
deployment cycles.
Compared to traditional systems, the proposed serverless model
provides several advantages:

18
  No server management required.
 Automatic scaling and fault tolerance.
 Reduced operational costs with pay-as-you-go pricing.
 Simplified deployment and maintenance.
Before the adoption of cloud-native serverless architectures, most
educational platforms and web-based applications were built using
traditional client-server models.
These systems typically involved:
 On-Premise Servers or Virtual Machines: Applications were
hosted on physical hardware or virtual servers that required
manual configuration, provisioning, and continuous maintenance.

 Relational Databases (RDBMS): Data storage relied on MySQL,

PostgreSQL, or Oracle databases, which enforced strict
schemas and normalized data structures.

 Backend Frameworks and Web Servers: Developers used

server-side frameworks like PHP, [Link], or Java Spring Boot
and deployed them on web servers such as Apache or Nginx.

 Manual Scaling and Deployment: Scaling the infrastructure

based on traffic demands required manual intervention or the
implementation of autoscaling groups, which increased complexity.

 DevOps and CI/CD Pipelines: These systems depended on

sophisticated deployment pipelines involving Jenkins, GitLab
CI/CD, and container orchestration tools like Docker and
Kubernetes.
Challenges Faced by Traditional Systems:
 High cost of ownership due to hardware, licensing, and human
resources.
 Complexity in managing infrastructure and deployment processes.
 Delays in scaling, patching, and performing maintenance tasks.
 Higher risk of downtime during server failures or peak traffic.

19
  Difficulties in implementing granular security policies without
specialized teams.
In contrast, modern serverless systems abstract away all
infrastructure management responsibilities. Developers can focus
solely on writing business logic while AWS handles scaling,
availability, and execution:

 No Infrastructure Management: AWS Lambda runs code in

response to events without requiring server provisioning.

 Flexible and Schema-less Storage: Amazon DynamoDB allows

storage of varying record structures with high availability.

 Event-Driven Architecture: API Gateway routes requests to

Lambda functions based on user actions.

 Cost Efficiency: Charges are based on actual usage (execution

time and resource consumption), eliminating idle costs.

 Security Built-in: I AM provides fine-grained access controls

across all services.

This comparison highlights how serverless computing resolves

many limitations inherent in traditional systems, making it a
superior choice for agile development and scalable applications.

3.2 Scope and limitations of existing systems

Scope of Traditional Systems: Traditional client-server systems and

monolithic architectures were suitable and widely adopted for various
large-scale enterprise and institutional applications, especially before the
rise of cloud and serverless computing. Their scope included:
Full Control Over Infrastructure: Organizations had granular control
over physical or virtual servers, storage, and networking.
20
Customization: Applications could be tailored with fine-tuned
configurations for performance, memory, and processing.
Persistent and Stateful Processing: Systems could maintain long-
running background tasks, sessions, and complex data transactions.
Comprehensive Monitoring and Logging: Local or third-party tools
enabled deep analysis of performance, usage, and system health.

Support for Legacy Systems: Easily integrated with older enterprise

software, databases, and APIs.

Limitations of Traditional Systems:

Despite the initial benefits, traditional systems pose a number of
significant drawbacks in the current fast-paced, cloud-first era:
High Operational Costs: Setting up and maintaining infrastructure
requires capital investment and dedicated IT staff.
Scalability Issues: Scaling up for high demand involves provisioning
new hardware or virtual machines, leading to delays and increased
costs.
Resource Underutilization: Often, servers remain underused during
off-peak times, leading to wasteful expenditure.
Complex Deployment Pipelines: CI/CD and system updates require
additional software and workflows, increasing complexity.
Security Risks: Without centralized security policies and automatic
patching, systems are more vulnerable to breaches.
Maintenance Overhead: Requires continuous maintenance of
operating systems, software libraries, and hardware.
In contrast, the serverless approach used in this project eliminates most
of these issues. It reduces cost, enhances scalability, simplifies
deployment, and improves security through AWS-managed services.
However, traditional systems still remain relevant for highly specialized,
compute-intensive applications that require persistent connections or
custom infrastructure configurations.

21
3.3 project perspective
This project is designed from the perspective of building a scalable,
modern, and cost-effective cloud application that embraces the
serverless computing paradigm. The adoption of AWS services allows
for a modular, event-driven architecture where each component is
independently managed and triggered by specific events or user
interactions.
The project takes a holistic view of application development in the cloud
era, aiming to eliminate traditional limitations such as infrastructure
complexity, server maintenance, and high deployment costs. The chosen
architecture aligns well with industry standards and best practices for
rapid application development, particularly in educational or
administrative use cases where budget and agility are top priorities.

Key Aspects of the Project Perspective:

Cloud-First and Serverless Mindset: All components—frontend,
backend, database, and security—are handled by AWS services. This
shifts the focus from hardware and server management to application
logic and user experience.
Separation of Concerns: Each AWS service handles a distinct layer
of the application:
 Amazon S3 manages static file hosting.
 API Gateway routes API calls and handles traffic management.
 Lambda executes backend business logic using Python.
 DynamoDB stores and retrieves data in a highly available, low-
latency environment.
 I AM enforces permissions and access control.

 Stateless Design: Functions do not store any state or session

data locally. This promotes fault tolerance and horizontal
scalability.

22
  Event-Driven Execution: Lambda functions are triggered based
on specific HTTP methods received via API Gateway, ensuring
precise and efficient task execution.
 Security and Compliance Focus: IAM roles are configured to
restrict access to only those operations that are necessary for
each component, enhancing the security posture of the
application.
 Cost-Awareness: By utilizing AWS's pay-as-you-go model, the
application minimizes idle costs and avoids the overhead of server
provisioning and underutilization.

This perspective allows the project to serve as both a functional

application and a learning model for students and developers aiming to
build robust applications on cloud platforms without managing servers. It
proves that powerful applications can be created with minimal
infrastructure if designed smartly using serverless technologies.

3.4 Features
The serverless student data management application integrates multiple
AWS services to deliver a secure, scalable, and user-friendly platform.
The following are the key features offered by the system:

1. Static Web Hosting with Amazon S3

The application frontend, including HTML, CSS, and JavaScript files, is

hosted using Amazon S3.
The bucket is configured for static website hosting with public read
access to necessary files.
Users can access the interface through a standard browser without
requiring server-side rendering.

2. Dynamic Data Handling with AWS Lambda

All backend logic is implemented using AWS Lambda in Python.

Lambda functions are designed for specific tasks such as inserting and
retrieving student data.

23
The serverless nature allows for auto-scaling based on demand without
manual provisioning.

3. API Integration via Amazon API Gateway

API Gateway handles HTTP request routing and connects client-side

input to Lambda backend.
Routes are defined for operations like POST (add student) and GET
(view all students).
4. NoSQL Data Storage with Amazon DynamoDB

Student records are stored in a table named student-data.

The schema-less nature allows flexibility in adding new attributes without
modifying the structure.
Fast read and write operations support real-time interactions.

5. User Interaction through Forms

Users can submit student details using the [Link] form.

Data is validated on the client side before submission.
A second interface, [Link], retrieves and displays the list of all
students.

6. Role-Based Access with IAM

Identity and Access Management (IAM) roles are created to control

access to Lambda, DynamoDB, and S3.
Least privilege principle is enforced to enhance security.

7. Lightweight and Modular Design

Each component (frontend, API, logic, and storage) is developed

independently.
The modular approach supports easier debugging, maintenance, and
future enhancements.

8. Real-Time Data Flow

All operations are performed in real-time.

Users receive instant confirmation messages after submitting or
retrieving data.

24
9. Cost-Efficient and Scalable Infrastructure

All services are used on-demand, with no idle cost.

AWS automatically handles scaling of Lambda and DynamoDB based
on traffic.

10. Educational Value

Provides hands-on experience with serverless application development.

Demonstrates practical use of AWS services in a project setting.

These features make the system highly adaptable, secure, and capable
of delivering reliable performance in real-time educational data
scenarios.

3.5 stakeholders
Stakeholders are individuals or entities who have a direct or indirect
interest in the development, functionality, and outcomes of the
application. Identifying stakeholders is critical to ensuring that the project
meets the expectations of all users and contributors.

1. Students

Role: End users who interact with the application to add and view
student records.

Interest: Expect a simple, intuitive, and fast interface that reliably stores
their data.

2. Project Developer

Role: Designer, coder, and integrator of all system components.

Interest: Gain practical knowledge, meet academic objectives, and

implement a functioning serverless system using AWS.

3. Project Supervisor/Trainer

Role: Guides the project through training and evaluation.

Interest: Ensure that the project aligns with educational standards and
learning outcomes.

25
4. AWS Cloud Services

Role: Provide infrastructure components like S3, Lambda, API Gateway,

DynamoDB, and IAM.

Interest: Operate efficiently to support application performance,

availability, and scalability.

5. Educational Institutions

Role: May use the application to manage student data or serve as a

reference model for coursework.

Interest: Seek reliable, scalable, and low-maintenance solutions for data

handling.

6. Administrators (Optional)

Role: May oversee system usage, manage policies, and monitor data
access.

Interest: Require secure and auditable systems with minimal downtime.

Understanding the needs and roles of each stakeholder helps ensure

the application is user-centric, functional, and aligned with the broader
goals of learning and system efficiency.

3.6 Requirement analysis –

Functional requirements, performance requirements,
security requirements etc.

Requirement Analysis

Requirement analysis is a fundamental step in system design. It involves

identifying and documenting the functional, performance, and security
needs of the application. This ensures that the developed solution aligns
with user expectations and system constraints.

26
Functional Requirements

These define what the system should do and the services it must
provide to users:

1. User Data Input:

Users must be able to submit student details through a web form.
Fields include student ID, name, age, email, and course.

2. Data Storage:
The submitted data must be stored in a DynamoDB table named
student-data.

3. Data Retrieval:
The system must provide a view option for users to retrieve and display
all stored records.

4. Form Validation:
Frontend should validate inputs for required fields and valid formats.

5. API Integration:
The application should use API Gateway to route HTTP requests (GET,
POST) to the correct Lambda functions.

6. Lambda Execution:
Lambda functions must process incoming data, interact with DynamoDB,
and return responses.

7. Frontend-Backend Communication:
All communication between frontend and backend must occur via
securely configured HTTP endpoints.

Performance Requirements

These define how well the system must perform under certain
conditions:

1. Low Latency API Responses: Lambda functions should respond

within 200–500 milliseconds under normal conditions.

2. Scalability: The system should scale automatically with an increasing

number of users and requests using AWS’s auto-scaling capabilities.

27
3. Availability: Application services (S3, Lambda, API Gateway,
DynamoDB) should maintain 99.9% uptime based on AWS SLA.

4. Fast Data Access: DynamoDB must deliver query results within

milliseconds, suitable for real-time data retrieval.

5. Minimal Cold Start Time: Optimize Lambda configurations to reduce

cold start delays, especially for infrequently used functions.

Security Requirements

These ensure data integrity, confidentiality, and controlled access to

system components:

1. I AM Role-based Access Control: All Lambda functions must run

under IAM roles with minimum required permissions.

2. S3 Bucket Policy Restrictions: Public access should be granted

only for required frontend files.
Backend files and sensitive data must remain private.

3. API Gateway CORS Configuration: CORS should be enabled to

allow frontend access while blocking unauthorized origins.

4. No Direct Database Access: Users should never interact with

DynamoDB directly. All actions must go through authenticated Lambda
functions.

5. Input Validation and Error Handling: Inputs must be sanitized

before being stored.
Error messages must not expose sensitive system details.

These requirements collectively ensure the application is functional,

responsive, secure, and scalable across different usage scenarios.

28
 [Link] Design

Figure 1: System Architecture Diagram

Illustrates the interaction between the user interface (client), AWS S3, API Gateway,
Lambda, DynamoDB, and IAM roles.

The diagram illustrates the serverless architecture used in this project,

showcasing how different AWS services interact to enable a cloud-based
student data management application. The system is composed of five
primary components: User Client, Amazon S3, AWS Lambda, Amazon
DynamoDB, and IAM Roles.

1. User Client
The user client is a web browser or device through which users interact
with the application.
Users perform actions like:
 Submitting new student data
 Viewing stored student information
These interactions are carried out through the static website hosted on
Amazon S3.
2. Amazon S3 (Static Hosting)
Amazon S3 hosts the frontend HTML, CSS, and JavaScript files. It acts
as the public-facing layer of the application.

29
Key responsibilities include:
 Serving the static web pages to users
 Accepting user inputs through forms
 Triggering API calls (via HTTP GET and POST) to API Gateway
This allows users to interact with the backend without the need for a
traditional web server.
3. AWS Lambda (Backend Logic)
AWS Lambda functions contain the business logic of the application,
written in Python. These are event-driven functions that are triggered by
HTTP requests routed through API Gateway. There are typically two
main Lambda functions in this project:
POST function: Accepts new student data and writes it to DynamoDB.
GET function: Retrieves all student records from DynamoDB.
Lambda scales automatically based on the number of incoming requests
and requires no server provisioning or maintenance.
4. Amazon DynamoDB (Database Layer)
DynamoDB is a fully managed NoSQL database used to store the
student data. Each student record is stored as a key-value pair with
fields like: studentID
name
age
email
course
DynamoDB supports fast read/write operations and can automatically
scale to handle large volumes of data.
5. IAM Roles (Security Layer)
IAM (Identity and Access Management) is used to enforce fine-grained
permissions across AWS services. Roles are assigned to Lambda
functions to define what actions they are permitted to perform, such as:
Read/write access to DynamoDB

30
Invocation permission via API Gateway

Figure2: API Gateway

integration with AWS Lambda Figure3: System Architecture of
for GET & POST Requests Serverless Web Applica on using
AWS Services

4.1 Design constraints

Design constraints refer to the limitations and rules that define how a
system should be implemented. These constraints guide developers and
architects in selecting the technologies and approaches used in the
project. In this serverless application, several key design constraints
were observed due to the nature of AWS services and the project
requirements:

1. Serverless Architecture

The entire application must be built using serverless components. No

EC2 instances, containers, or traditional servers are allowed.
Backend processing is restricted to AWS Lambda functions only.

2. Stateless Execution

Lambda functions are stateless and do not retain data between

invocations.
All state or session data must be passed explicitly via parameters or
stored externally (e.g., DynamoDB).

3. Storage Constraints

The application uses Amazon S3 for static file hosting and DynamoDB
for backend data storage.

31
No file system storage is available for Lambda functions beyond
temporary memory (e.g., /tmp directory)

4. Execution Time and Memory Limits

Lambda functions have a maximum execution time of 15 minutes.

Memory is limited to 10 GB per function invocation, requiring efficient
logic design.

5. Schema Flexibility

DynamoDB is schema-less and cannot enforce relational constraints.

Developers must ensure data consistency and validation through
application logic.

6. API Gateway Constraints

All HTTP methods (GET, POST) must be explicitly defined in API

Gateway.
CORS policies must be configured correctly to allow frontend requests.

7. IAM Policy Restrictions

IAM roles must follow the principle of least privilege.

Overly permissive policies are prohibited, and cross-service permissions
must be clearly defined.

8. Security and Access Control

Only specific files in the S3 bucket can be made publicly accessible.

API endpoints must be protected to prevent unauthorized access.

9. Regional Service Availability

All services (S3, Lambda, DynamoDB, API Gateway) must be available

in the same AWS region (e.g., us-east-1).

These constraints help ensure that the application is secure,

maintainable, and scalable within the capabilities provided by AWS
serverless architecture.

32
4.2 E-R Diagram

Figure 1: Entity-Relationship (E-R) Diagram

Depicts the logical structure of student data, showing entities and relationships.

4.3 UML Diagrams

Figure 2: UML Diagram

 Class Diagram

Figure 3: Class Diagram

33
 Represents the static structure of classes used in backend logic.

 Object Diagram

Figure 4: Object Diagram

Shows an instance of the class structure.

 Use Case Diagram

Figure 5: Use Case Diagram

Illustrates user interactions with the system (e.g., Add Student, View Students).

 Activity Diagram

Figure 6: Activity Diagram

34
 Shows the flow of actions like adding or retrieving student data.

 Component Diagram

Figure 7: Component Diagram

Visualizes how each AWS service is a component of the system.

 Deployment Diagram

Figure 8: Deployment Diagram

Displays how software components are deployed on cloud infrastructure.

35
 4.4 Data Model
The data model of this project is based on a NoSQL schema
implemented using Amazon DynamoDB. Since DynamoDB is
schema-less, it allows storing flexible, unstructured, or semi-
structured data using key-value pairs. The system uses a single
table design optimized for scalability and simplicity.
Table Name: student-data
Primary Key (Partition Key):
studentID (String): A unique identifier for each student record.
Attributes:
name (String): Full name of the student.
age (Number): Age of the student.
email (String): Contact email address.
course (String): Enrolled course or department.
Example Record (JSON Format):
{
"studentID": "STU101",
"name": "Amit Sharma",
"age": 21,
"email": "[Link]@[Link]",
"course": "Computer Science"
}
Data Characteristics:
 Schema-less: Attributes can vary by record, supporting flexibility.
 Optimized for speed: DynamoDB ensures millisecond response
times.
 Auto-scalable: Can handle any volume of records with no manual
scaling.
 No relational constraints: Normalization is not required.
This simple and flat data model supports quick data entry and
retrieval while aligning with DynamoDB’s best practices for
serverless architecture.

4.5 User interfaces

The application provides a simple and responsive web-based
interface to allow users to submit and view student data. The entire

36
frontend is hosted using Amazon S3 with public access to the
HTML, CSS, and JavaScript files required for interaction.

1. Add Student Interface

Purpose:
Allows users to enter new student data and submit it to the
backend.

Components:
HTML form with input fields: Student ID, Name, Age, Email, and
Course.
Submit button triggers a POST request to API Gateway.

Technologies Used:
HTML, CSS, JavaScript (AJAX fetch)
API Integration via JavaScript

2. View Students Interface

Purpose:
Displays all existing student records fetched from DynamoDB via
the Lambda function.

Components:
A table layout dynamically populated using JavaScript
Triggered by a GET request through API Gateway

37
Technologies Used:
HTML for layout
JavaScript for data fetching and rendering

3. Hosting Environment (Amazon S3)

Purpose:
Stores and serves all static files of the frontend securely.
Key Actions Taken:

Enabled static website hosting on S3 bucket myschool21.

Configured bucket policies and ACLs for public read access to
HTML/JS files.
Set [Link] as the landing page.

38
 5. Implementation details
The final project involves deploying a serverless application using
AWS services including DynamoDB, Lambda functions, API
Gateway, S3, and IAM roles. The implementation focuses on
creating a scalable, secure, and efficient backend for managing
student data with a static frontend hosted on S3.

1. DynamoDB Setup

 Service: DynamoDB is used as the NoSQL database.

 Table Creation: A table named student-data was created

with student-ID as the partition key.

 Capacity Mode: On-demand mode is chosen for flexible

scaling without managing read/write capacity units.

 Advantages: DynamoDB offers a flexible schema allowing

dynamic data structure, high speed, infinite scaling, and built-
in security.

39
 2. Lambda Functions

Purpose: Lambda functions handle the backend logic.

Languages: Python is used for Lambda functions.
Functions Created:
 insert_student_data: Handles inserting student records into
DynamoDB.

 get_student_data: Retrieves students data form DynamoDB.

Roles: Each Lambda function is assigned an IAM role granting full

Lambda and DynamoDB access.

40
3. API Gateway Configuration

Role: Acts as the entry point routing HTTP requests to Lambda

functions.

Routing: POST requests are routed to insert_student_data

Lambda function.
GET requests are routed to get_student_data Lambda function.

Deployment: The API Gateway is deployed to production to

enable client applications to interact with the backend.

4. S3 Bucket for Frontend Hosting

Bucket Name: my school
Usage: Hosts static frontend files including HTML, CSS, and JavaScript
for the student data application.
Public Access: Enabled public read access with proper bucket policies
to allow users to load the website.
Bucket Policy: Configured permissions such as GetObject, PutObject,
DeleteObject, and PostObject to control access.
Frontend Features: The interface supports adding new student data
and viewing existing records.

41
5. I AM Roles and Security
I AM roles are used for secure access management:
Lambda functions have permissions to interact with DynamoDB.
S3 bucket policies ensure safe and controlled access to static resources.
API Gateway permissions manage request routing securely.

42
5.1 Software/hardware specifications

o Software Specification

Software Version / Type Purpose

Python 3.8 or higher Backend logic for AWS

Lambda functions

Visual Studio code Latest Code editor used to write

(VS Code) and manage project files

AWS Console Web-based Used to configure and

monitor AWS resources
(S3,
Lambda,DynamoDB,etc.)

Web Browser Chrome / Firefox For accessing and testing

the fronted (hosted on S3)

Postman (optional) Latest For testing API requests

(GET, POST)

AWS CLI (optional) Latest Command-line

deployment and
configuration(advanced
users)

o Hardware Specification

Hardware Minimum Recommended

Component Requirement

Processor Intel i3 / AMD Ryzen 3 Intel i5 or above

4GB 8 GB or more
RAM
Storage 2 GB free disk space SSD with 10+ GB free

Windows 10 /11, Linux, Any modern OS

Operating System
Or macOS

Internet Required Broadband

Connection recommended for stable
AWS access

43
 6. Input and Output Screens
1. Input Screen – Add Student Form

Purpose: Shows the form where users enter student details.

2. Output Screen – View Students Page

Purpose: Shows the list of students retrieved from DynamoDB.

44
 [Link]
This section outlines the types of reports generated by the
application and how data retrieved from DynamoDB is presented to end
users through the web interface. Since the project uses dynamic data
fetching and rendering via JavaScript, report generation is mostly real-
time and presented on the frontend.

7.1 Student Data Report (Dynamic Table View)

Upon clicking the "View Students" button on the [Link]
page, a GET request is sent to the API Gateway. The response from the
backend Lambda function (which scans the DynamoDB table) includes
student records in JSON format. These records are then rendered
dynamically in a tabular report.
Example Table Output:

Student Id Name Email Course Year

101 arrav@[Link] Computer Science 2025
102 sneha@[Link] IT Engineering 2024
103 ravi@[Link] Electronics 2025

7.2 Exporting or Printing Reports (Optional

Enhancements)
While not implemented in the current version, additional enhancements
could include:
Export to PDF using JavaScript libraries like jsPDF
Export to Excel (CSV) using SheetJS or plain text manipulation
Printable Views with dedicated CSS stylesheets
These can be useful in academic institutions for generating
attendance logs, student records, or academic performance sheets from
the system.

45
7.3 Admin Insights (Optional Scope)
If extended in the future, the application could include admin-only
dashboards showing:
Total number of students
Year-wise distribution
Course-wise categorization
Most recent entries (using the timestamp field)

These insights could be extracted by writing Lambda functions that

filter or aggregate DynamoDB data and return customized reports.

7.4 Security and Access Logging

Although reports focus on user-visible data, AWS also

provides backend reports such as:

CloudWatch Logs: Automatically logs Lambda function execution

results, errors, and metrics.

IAM Access Logs: Tracks who accessed what resources and

when.
API Gateway Logs: Monitors request and response metadata
including IP, path, and status code.

46
 8. Testing
Testing plays a critical role in verifying the functionality, security,
and performance of the serverless application. This section outlines the
testing strategy, including the test plan, test cases, and results for both
black-box and white-box testing methods.

8.1 Test Plan

 Features to Be Tested

Feature Description

Add Student Form submission and data

insertion via POST API

View Student Fetching and displaying data

via GET API

S3 Static Hosting Accessibility of Frontend files

Lambda Logic Backend code for add/ view

functionality

API Gateway Correct routing of HTTP

requests

DynamoDB Data storage, retrieval, and

consistency

IAM Roles Secure, restricted access

enforcement

47
  Test Environment
Component Description

Frontend HTML, CSS, JS hosted on Amazon S3

Backend Python Lambda function on AWS

Database Amazon DynamoDB table

(student-data)

API API Gateway routes for

POST and GET

Access Control IAM policies assigned to Lambda roles

8.2 Black Box Testing (Data Validation)

Test Case ID Test Description Input Expected Output

TC01 Submit valid student All fields filled Success message

data

TC02 Submit with missing Missing ‘name’ Error or validation

name field alert

TC03 View student data Click ‘View Display list of students

Students’

TC04 Invalid email format student@com Input rejected or alert

TC05 API response test GET /view- JSON array of records

students

48
8.3 White Box Testing (Lambda Logic)

Component Internal Logic Tested

Insert_student.py JSON parsing, DynamoDB put_item,

return status code

get_student.py Table scan, data formatting, response

Error Handling Missing keys, invalid JSON body

Security IAM permissions enforced correctly

Logging Events and outputs logged to CloudWatch

8.4 Functional Validation

The entire application was tested in the browser through actual

user actions:
Adding data via the form triggers a POST Lambda call.
Viewing data sends a GET request and renders the result.
All actions logged in CloudWatch, ensuring observability and
traceability.

49
 [Link] and Recommendations
9.1 Conclusion
This project successfully demonstrates the design, implementation, and
deployment of a serverless web application using Amazon Web Services
(AWS). By integrating core AWS components such as S3, Lambda, API
Gateway, DynamoDB, and IAM, the system provides a secure, scalable,
and cost-efficient platform for student data management.

Key accomplishments include:

Hosting a fully functional static frontend on Amazon S3

Developing backend Lambda functions in Python for data handling

Routing requests securely and efficiently using API Gateway

Storing and retrieving student data with DynamoDB

Implementing IAM policies for controlled and secure access

Conducting comprehensive testing to ensure functional correctness

This serverless solution eliminates the need for manual server

management, reduces infrastructure costs, and improves scalability. The
real-time, event-driven architecture is well-suited to dynamic use cases
like academic record management, making the system both practical
and extensible.

Through this project, learners gained hands-on experience with modern

cloud computing paradigms, AWS tools, and software engineering best
practices in a real-world context.

50
9.2 Recommendations
While the system is functional and efficient, several improvements
and enhancements could be considered for future iterations:

1. Form Validation Enhancements:

Add client-side and server-side validation for improved data accuracy.

2. Advanced Security:
Use Cognito for user authentication and implement SSL certificates via
AWS Certificate Manager.

3. UI/UX Improvements:
Redesign the frontend with responsive design, CSS frameworks like
Bootstrap or TailwindCSS, and animations for better user experience.

4. Logging and Monitoring:

Expand the use of CloudWatch Metrics and Alarms for error tracking and
performance monitoring.

5. Role-Based Access Control (RBAC):

Add admin and student roles to control data access and operations.

6. Data Export Features:

Implement options to export student data as PDF, Excel, or CSV.

7. API Optimization:
Introduce pagination and filtering in GET requests to manage large
datasets efficiently.

8. Frontend Framework Integration:

Use [Link] or [Link] for a more dynamic and scalable frontend
architecture.

These recommendations align with current trends in cloud-based

application development and could further enhance the system's
usability, security, and performance.

51
 10. Future Scope
The implementation of this AWS-based serverless application opens up
several promising avenues for future development, both in terms of
functionality and technology integration. As the demand for scalable and
low-maintenance applications grows, the serverless model is expected
to dominate numerous domains beyond academic data management.

10.1 Functional Expansion

Role-Based Access and Authentication
Future versions can incorporate AWS Cognito to manage user identities,
providing authentication and authorization for both students and
administrators.

Edit and Delete Operations

Currently, the system supports inserting and retrieving student data.
Adding update and delete features would make it a complete CRUD
application.

Search and Filter Functionality

Enable searching by student ID, name, or course for easier data
retrieval, especially as the dataset grows.

Notifications and Alerts

Integration with Amazon SNS or SES can help send email or SMS
notifications to users upon successful data submission or modification.

10.2 Technical Enhancements

Serverless Framework or AWS SAM
Use Infrastructure as Code (IaC) tools to automate deployments,
manage resources, and version control the entire system configuration.

Real-Time Features
Incorporate WebSocket APIs via API Gateway to enable real-time data
updates and notifications.

Analytics and Dashboards

52
Utilize Amazon QuickSight or third-party tools to build dashboards
showing statistics like student distribution by course, year, etc.

Data Backup and Restore

Integrate periodic backups of the DynamoDB table using AWS Backup,
ensuring data durability and recovery options.

10.3 Educational Applications

Multi-Department Usage
Expand the scope to include multiple departments or faculties, each
managing its own student records through a unified system.

Integration with Learning Management Systems (LMS)

Link with existing LMS platforms like Moodle or Blackboard to sync
student profiles and academic data.

Mobile App Development

Develop a mobile interface using Flutter or React Native that interacts
with the same backend for broader accessibility.

10.4 Research and Innovation Opportunities

AI-Driven Features
Implement basic AI services from AWS (e.g., Comprehend, Lex,
Rekognition) to auto-analyze student input, enable chatbots, or enhance
accessibility.

Multilingual Support
Provide language options (e.g., English, Marathi, Hindi) to improve
usability in regional institutions.

IoT Integration
For institutions using smart ID cards or biometric attendance, the system
can be extended to log and report such data automatically.
The project, though simple in its current version, is a robust foundation
for a much larger, intelligent, and connected education platform. By
leveraging the full suite of AWS tools, future versions can become
powerful tools for academic institutions aiming for digital transformation.

53
 11. Bibliography and References
This section includes references to the tools, services, academic
sources, and documentation consulted during the design and
development of this project.

Academic References

1. Baldini, I., Castro, P., Chang, K., Cheng, P., Fink, S., Ishakian, V., ... &
Suter, P. (2017). Serverless Computing: Current Trends and Open
Problems. arXiv preprint arXiv:1706.03178.

2. Jonas, E., Schleier-Smith, J., Sreekanti, V., Tsai, C.-C., Khandelwal,

A., Pu, Q., ... & Stoica, I. (2019). Cloud Programming Simplified: A
Berkeley View on Serverless Computing. University of California,
Berkeley.

AWS Official Documentation

 Amazon Web Services. (2024). Getting Started with AWS

Lambda. Retrieved from:
[Link]
[Link]

 Amazon Web Services. (2024). Amazon S3 Static Website

Hosting. Retrieved from:
[Link]
[Link]

 Amazon Web Services. (2024). Using Amazon API Gateway.

Retrieved from:
[Link]
[Link]

 Amazon Web Services. (2024). Amazon DynamoDB Developer

Guide. Retrieved from:

54
 [Link]
guide/[Link]

 Amazon Web Services. (2024). AWS IAM Documentation.

Retrieved from:
[Link]
tml

Tools and Platforms

 8. Visual Studio Code – Code editor for Lambda functions.

[Link]

 9. Postman – API testing tool.[Link]

 10. GitHub – Version control and project management.

[Link]

55