VISAKHA INSTITUTE OF ENGINEERING & TECHNOLOGY

COMPUTER SCIENCE AND ENGINEERING

Name: NITTA SATISH

Year: IV B-tech
Semester: II
Roll No: 21NT1A0556
Internship: FULL STACK JAVA
 AN INTERNSHIP PROJECT REPORT ON

FULLSTACK JAVA
Carried out by EXCELR
A report submitted

In the partial full fill of the requirements under internship

project for the award of
BACHELOR OF TECHNOLOGY IN COMPUTER SCIENCE ENGINEERING

DEPARTMENT OF COMPUTER SCIENCE ENGINEERING

(2021–2025)
VISAKHA INSTITUTE OF ENGINEERING AND TECHNOLOGY
(Approved by AICTE New Delhi & Recognized by JNTUG, VIZINAGARAM)
88th Division, NARAVA, GVMC Visakhapatnam -530027)
 INTERNSHIP 16-WEEKS REPORT 2025

INTERNSHIP PERIOD
DURING 2025
 CERTIFICATE OF INTERNSHIP

This is to certify that the “FULL STACK JAVA’’ submitted by NAME: Nitta Satish (Regd.
No: 21NT1A0556) is work done by her/his and submitted during 2024 – 2025 for 16 weeks
in this academic year, in partial fulfilment of the requirements for the award of the degree of
BACHELOR OF TECHNOLOGY in COMPUTER SCIENCE AND ENGINEERING, at
EXCELR, APSCHE.

[Link] [Link] KONE

Department Internship Coordinator Head of the Department
Department of CSE Department of CSE

EXTERNAL SIGNATURE
CERTIFICATE FROM EXCERL ORGANIZATION
 DECLARATION

We hereby declare that work entitled “Internship Program 2024” submitted towards

completion training 4th year of BTech (CSE) At EXCELR comprises of our original work

pursue under the guidance of DEPARTMENT OF CSE.

NITTA SATISH

21NT1A0556
 ACKNOWLEDGMENT

A project is a golden opportunity for learning and self-development. I consider myself very
lucky and Honor to have so many wonderful people, lead me through, in completing of this
project.

Our grateful thanks to DEPARTMENT OF CSE, in spite of being extraordinarily busy

with their duties, took time out to hear, guide and keep us on the correct path. A humble
‘Thank you’.

We would like to thank Mrs. A.S.C Tejaswini Kone Madam Head Of The Department for all
the help rendered. Thank you, Dear Madam we would like to thank you for your efforts and
help provided to me to get such an excellent opportunity. Last but not the least there were so
many who shared valuable information that helped in the successful completion of this
project.

NITTA SATISH

21NT1A0556
FULL STACK JAVA 16-WEEKS INTERNSHIP EXCELR
 ABSTRACT

FULL STACK JAVA Development is an end-to-end framework that combines JAVA simplicity with
efficient tools for building dynamic web applications. At the front end, popular libraries like React, Vue,
or even SPRINGBOOT Templates are utilized to create responsive and modular UIs. State management
with Redux or Vuex enhances data handling across components, while styling frameworks such as
Tailwind or Bootstrap provide a cohesive, responsive look. This front- end setup supports user
interactivity, ensuring applications are fast, flexible, and user-centric.

On the backend, JAVA frameworks such as SPRINGBOOT and servelts are used to create a robust
server-side environment., SPRINGBOOT known for its "batteries-included" philosophy, simplifies many
development tasks with built-in tools for ORM, form handling, and authentication. Flask, on the other
hand, offers a lightweight option that pairs well with libraries like SQL Alchemy for data persistence.
These frameworks support RESTful API development and integrate easily with relational databases like
PostgreSQL and MySQL or NoSQL databases like MongoDB. For added security, JWT-based
authentication and data validation are common practices to protect user data and ensure accurate input.

Full Stack JAVA is designed for efficient development and scalability. With Docker containerization,
developers can maintain consistent environments across stages, while CI/CD pipelines automate testing
and deployment using GitHub Actions or Jenkins. This setup minimizes manual errors and accelerates
the release cycle. Full Stack JAVA is favored for its versatility, balancing ease of use with robust
capabilities, making it ideal for both small projects and complex applications needing efficient, scalable
solutions.
 ACTIVITY LOG FOR THE 1st WEEK

Week Day Content

Day-1
ORIENTATION

Day-2
INSTALLING JDK, VS CODE, GIT AND POSTMAN

Day-3
Week-1 HTML AND CSS FUNDAMENTALS

Day-4
HTML TAGS, FORMS, TABLES, SEMANTIC
ELEMENTS

Day-5
CSS STYLING, FLEXBOX BASICS
 1stWEEK REPORT

Week 1: Introduction and Setup

first week of the internship focused on understanding the basics of full stack development and setting up the
necessary tools and environments required for the upcoming work. On the first day, we attended an
orientation session that introduced us to the overall internship structure, expected outcomes, and the
technologies we would be working with. We were given a brief overview of front-end, back-end, and database
technologies, along with an introduction to version control systems and deployment.

On the second day, we focused on setting up our development environment. This included installing the Java
Development Kit (JDK), an integrated development environment (IDE) like IntelliJ IDEA or Visual Studio
Code, Git for version control, and Postman for API testing. We also created GitHub accounts to manage our
code repositories and to learn collaborative development practices. This setup laid the foundation for efficient
coding, testing, and project management throughout the internship.

The third and fourth days were dedicated to learning the basics of HTML. We explored various HTML tags,
the structure of a webpage, and how to create simple static web pages. We also learned how to create HTML
forms, include images and videos, and build tables. Semantic HTML elements were introduced to encourage
clean and accessible web design. By practicing these concepts through hands-on exercises, we gained
confidence in structuring web pages.

On the fifth day, we were introduced to CSS (Cascading Style Sheets), which is used to style and design
HTML pages. We learned how to apply styles using inline, internal, and external CSS. Topics like font
styling, background colors, m

By the end of the first week, we were well-acquainted with the fundamental building blocks of front-end web
development. We had set up our development tools and practiced building simple web pages using HTML and
CSS. This foundational knowledge prepared us for the upcoming weeks, where we would dive deeper into
JavaScript, Java programming, and full-stack integration.

Argins, padding, and box models were covered. We also explored Flexbox, which helps in creating responsive
layouts. CSS added visual appeal to our basic HTML pages, making them more attractive and user-friendly.

.
 ACTIVITY LOG FOR THE 2ndWEEK

S. Week Day Content

no

Day-1
1 RESPONSIVE DESIGN, CSS GRID

2 Day-2
INTRODUCTION TO JAVA SCRIPT

3 Day-3
Week-2 JS DATA TYPES, VARIABLES, OPERATORS

4 Day-4 JS CONDITIONS, LOOPS

Day-5 JS FUNCTIONS AND EVENTS

5
Week 2: Frontend Development – HTML, CSS & JavaScript Basics

In the second week of the internship, we continued our journey in front-end development by diving deeper
into HTML and CSS and began our introduction to JavaScript. We started the week by learning about
responsive design principles and how to make websites look good on different screen sizes. CSS Grid and
Flexbox were emphasized for building flexible layouts. We practiced designing web pages that could adjust
their structure based on the device being used, which is a crucial skill in modern web development.

Following this, we were introduced to JavaScript – the programming language used to make web pages
interactive. We began with the fundamentals, such as variables, data types, and basic syntax. We learned how
JavaScript can be embedded into HTML using the <script> tag and how it executes in the browser. This
marked the beginning of bringing dynamic behavior to the static pages we built during Week 1. It was
interesting to see how JavaScript could manipulate elements on a web page.

As the week progressed, we explored JavaScript control structures, including if-else conditions, switch
statements, loops (for, while, and do-while), and the use of logical operators. These constructs helped us build
logic into our code, enabling the pages to respond to user inputs and decisions. We practiced writing scripts
that could perform calculations, validate inputs, and control the flow of programs based on different
conditions.

Later in the week, we started working with JavaScript functions and events. Functions helped us organize
reusable pieces of code, making our scripts cleaner and more efficient. Event handling was a particularly
engaging topic, as it allowed us to respond to user interactions such as clicks, form submissions, and mouse
movements. We used functions to trigger responses when users interacted with elements on the page, which
added life to our designs.

By the end of Week 2, we had built a solid understanding of how to create interactive websites using HTML,
CSS, and JavaScript. We could now build a page, style it using CSS, and then make it dynamic using
JavaScript. This week was crucial in bridging the gap between design and functionality, and it laid the
groundwork for more advanced topics like DOM manipulation and backend integration in the coming weeks.
 ACTIVITY LOG FOR THE 3rdWEEK

Week
S.n Day Content
o

1 Day-1 ARRAYS, OBJECTS IN JS

2
Day-2 DOM MANIPULATION

3 Day-3 EVENT HANDLING

Week-3

4 Day-4 FORM VALIDATION USING JS

5 Day-5
MINI JS PROJECT
 3rdWEEKREPORT

Week 3: JavaScript Advanced & DOM Manipulation

In the third week of the internship, we focused on listings. These skills are crucial for real-world
projects, especially when dealing with backend APIs and JSON data.

The core part of the week was dedicated to DOM manipulation. We learned how the DOM
represents the structure of an HTML document as a tree of nodes. JavaScript allows us to access,
modify, and delete these nodes in real time. We practiced using methods like get Element By Id,
query Selector, inner HTML, set Attribute, and create Element to dynamically modify the webpage.
This gave us the power to change content, add or remove elements, and respond to user actions
without reloading the page.

Additionally, we implemented various event listeners to trigger JavaScript functions based on user
interaction. We handled click, mouseover, keydown, and submit events to build dynamic web
applications. A key concept we covered was form validation using JavaScript, where we checked
user inputs before submission. This ensured a better user experience and prevented incorrect data
from reaching the backend.

To reinforce our learning, we built a mini-project at the end of the week – a To-Do List Web App.
This project allowed us to apply everything we had learned: creating elements dynamically, updating
the DOM, handling user input, and managing data using arrays and objects. It was a rewarding
experience that showed how JavaScript can bring real interactivity and usefulness to a website. This
week gave us the confidence to move forward toward more advanced frontend frameworks and
backend development.
 ACTIVITYLOGFORTHE4thWEEK

S.n Week Day Content

o

1 Day-1 GIT BASICS, GITHUB REPO CREATION

2 GIT PUSH, PULL, BRANCHING

Day-2

3 Week-4 Day-3 INTRODUCTION TO BOOTSTRAP

4 Day-4 BOOTSTRAP GRID SYSTEM,

COMPONENSTS

4 Day-5
FRONTEND MINI PROJECT USING
BOOTSTRAP
 4thWEEKREPORT

Week 4: Version Control & Bootstrap

In the fourth week of the internship, we shifted focus from core JavaScript to essential tools that support
development and collaboration in real-world environments. The first topic introduced was version control,
with Git and GitHub being the primary tools. We learned about the importance of source control in software
projects — how it helps track changes, enables collaboration, and prevents code loss. We installed Git on our
systems and practiced basic commands like git init, git add, git commit, git status, and git log.

On the second day, we worked on remote repositories using GitHub. We created repositories, pushed local
code to GitHub, and explored concepts like cloning, branching, and merging. We also learned about resolving
merge conflicts, an important aspect of team collaboration. Using Git in conjunction with GitHub gave us a
deeper understanding of how developers work in teams and manage codebases effectively.

In the second half of the week, we began working with Bootstrap, a popular front-end CSS framework that
simplifies the process of designing responsive and visually appealing web pages. We explored the Bootstrap
grid system, which made layout design much easier and more consistent. Bootstrap’s predefined classes and
components, such as navbars, buttons, forms, and modals, helped us quickly build stylish UI without writing
extensive custom CSS.

We created sample webpages using Bootstrap, focusing on responsiveness and design consistency across
devices. This included hands-on practice in creating navigation bars, cards, input groups, alerts, and carousels.
By applying Bootstrap alongside our HTML and CSS knowledge, we were able to build pages that looked
modern and professional with minimal effort.

By the end of Week 4, we had a strong grasp of version control using Git and GitHub, as well as a solid
introduction to using Bootstrap for front-end design. These skills are vital in any full stack project, ensuring
both collaboration and user interface design are efficient and effective. This week bridged the gap between
development and deployment, preparing. fidently toward backend programming with Java in the coming
weeks.
 ACTIVITY LOG WEEK 5

Week Day Content

JAVA INSTALLATION, FIRST PROGRAM

1 Day-1

DATA TYPES, OPERATORS, CONTROL

2 STATEMENTS
Day-2

ARRAYS AND STRINGS

3 Day-3

Week-5
OOPS CONCEPTS
4 Day-4

5 Day-5 INHERITENCE, POLYMORPHSIM

Week 5: Java Basics

In the fifth week of the internship, we transitioned from front-end development to back-end programming by
starting with the fundamentals of Java. The week began with setting up the Java Development Kit (JDK) and
familiarizing ourselves with an Integrated Development Environment (IDE), such as IntelliJ IDEA or Eclipse.
We wrote our first basic Java program, understood the structure of a Java application (class, main method),
and executed simple outputs using [Link]. This gave us a basic comfort level with the Java
environment and syntax.

The next focus was on Java’s core building blocks. We learned about primitive data types (int, float, boolean,
char), variables, and operators (arithmetic, relational, logical). We explored how to take input from users
using the Scanner class and perform basic operations. We also practiced using conditional statements like if,
else-if, and switch-case to add decision-making capabilities to our programs. This helped us write logic that
could respond differently based on inputs or conditions.

As the week progressed, we covered loops such as for, while, and do-while, which allowed us to write
programs that repeated tasks based on conditions. We created simple programs like number patterns,
calculators, and sum of series using loops and conditions. Understanding loops is vital in any programming
language, and this practice helped strengthen our logical thinking and problem-solving skills.

Later in the week, we explored arrays and strings. Arrays introduced us to storing and processing collections
of data, while string operations showed us how to manipulate and compare text. We practiced writing
programs that involved sorting arrays, finding maximum or minimum values, and reversing strings. We also
learned about string methods like length(), charAt(), substring(), equals(), and concat(), which are commonly
used in both frontend validation and backend processing.

By the end of Week 5, we had established a solid foundation in core Java programming. We were now able to
write simple to moderately complex programs involving input/output, control structures, arrays, and strings.
This week was an important milestone in our full stack journey, as Java is the language we’ll use for
developing the backend in Spring Boot in the upcoming weeks. The hands-on exercises and mini challenges
helped boost our coding confidence and prepare us for advanced Java topics.
 ACTIVITY LOG WEEK 6

S. Week Day Content

no

ABSTRACTION, INTERFACES
Day-1

EXCEPTION HANDLING
2
Day-2

FILE HANDLING
Week-6 Day-3
3

4 Day-4 COLLECTIONS

5 Day-5 JAVA MINI PROJECT

Week 6: Java Advanced Concepts

In Week 6 of the internship, we built on our foundational knowledge of Java by

exploring its advanced features and object-oriented programming (OOP) concepts in
greater depth. We began with a detailed understanding of classes and objects, followed
by core principles of OOP such as inheritance, polymorphism, encapsulation, and
abstraction. These concepts are essential for designing modular, maintainable, and
reusable code, which is the backbone of real-world software development.

We then explored inheritance in Java, where one class can acquire the properties and
behavior of another class. We practiced using the extends keyword and understood
how method overriding works in child classes. Polymorphism was introduced next,
showing us how the same method name can behave differently depending on the
object calling it — through both method overloading (compile-time) and method
overriding (runtime). This gave us powerful tools for writing flexible and extensible
programs.

Another key topic was abstraction, which allows developers to focus on essential
features while hiding the implementation details. We learned how to create abstract
classes and interfaces, and we understood how they help enforce rules and contracts in
code. Interfaces became especially important because they support multiple
inheritance in Java, and are widely used in frameworks like Spring. We implemented
real-world examples such as shape and vehicle classes to practice abstraction and
interface-based design.

We also studied exception handling, an essential part of writing robust applications. We

explored the try-catch-finally blocks, and how to handle common exceptions like
ArithmeticException, NullPointerException, and ArrayIndexOutOfBoundsException. We
also learned how to create our own custom exceptions. Proper exception handling not
only prevents applications from crashing but also helps in providing meaningful error
messages to users or logs for developers.
 ACTIVITY LOG WEEK 7

Week
1 Day-1 Introduction to SQL

2
Day-2 SQL QUERIES

3 Day-3 Database Connection

Week-7

4 Day-4 CRUD Operations

5 Day-5
SQL MINI PROJECT
Week 7: File Handling & Java Collections

In Week 7 of the internship, we focused on two important aspects of Java programming:

file handling and the Java Collections Framework. We began the week with file
handling, which is essential for reading from and writing data to files. We learned how
to use Java’s [Link] package, including classes such as File, File Reader, File Writer,
Buffered Reader, and Buffered Writer. Through hands-on practice, we created programs
to read text files line by line, write content to files, and append data without overwriting
existing content.

We also learned how to handle exceptions during file operations, such as File Not Found
Exception and IO Exception. This helped us ensure that our file-handling programs
could run safely and handle unexpected conditions like missing files or unreadable
content. These skills are particularly useful in backend systems, where data is often
stored, retrieved, or logged in files for processing and auditing.

Later in the week, we were introduced to the Java Collections Framework — a set of
interfaces and classes that simplify working with groups of data. We explored key
interfaces like List, Set, and Map, and their commonly used implementations such as
ArrayList, LinkedList, HashSet, TreeSet, HashMap, and TreeMap. We wrote programs to
add, remove, search, and sort data using these collections. This helped us manage data
structures more efficiently than using basic arrays.

Each collection type has its unique behavior: Lists maintain insertion order and allow
duplicates, Sets eliminate duplicates, and Maps store key-value pairs. Understanding
when and where to use each collection is important in software development,
especially when dealing with large data sets or implementing algorithms. We also
practiced using enhanced for-loops and iterators to traverse these collections
 ACTIVITY LOG WEEK 8

S. Week Day Content

no

SPRING BOOT SETUP

1 Day-1

PROJECT STRUCTURE, ANNOTATIONS

2
Day-2

3 Day-3 REST API

Week-8
CRUD API WITH SPRING BOOT
4 Day-4

5 Day-5
POST MAN TESTING
Week 8: JDBC and Database Integration

In Week 8 of the internship, we focused on understanding how Java applications

interact with databases using JDBC .The week began with an introduction to relational
databases, particularly MySQL. We learned about database concepts such as tables,
primary keys, foreign keys, and SQL commands like SELECT, INSERT, UPDATE, and
DELETE. Using MySQL Workbench, we created sample databases and tables for our
practice sessions.
The core of the week was dedicated to JDBC, which is the standard Java API for
connecting and executing queries with relational databases. We started by
understanding the JDBC architecture and the steps involved: loading the driver,
establishing a connection, creating a statement, executing SQL queries, and closing the
connection. We used the JDBC Driver Manager and Connection classes to build basic
Java programs that could connect to a MySQL database.

Next, we worked with Statement and Prepared Statement interfaces to perform

database operations from our Java programs. While Statement was used for simple
static queries, Prepared Statement was preferred for parameterized queries that are
safer and more efficient, especially in preventing SQL injection. We practiced writing
Java programs that could insert student records into a database, retrieve all records,
and update or delete specific entries based on user input.

We also explored Result Set, which allows us to fetch and navigate through query
results. By integrating user input with SQL queries and displaying output through Java,
we could build small applications like login systems and product catalogs. Exception
handling was incorporated to ensure that database connections were safely opened
and closed, even in case of errors. This gave us a practical understanding of real-time
data access in applications.

By the end of Week 8, we successfully built several Java programs that could perform
CRUD operations on a database using JDBC. This week was a crucial step in our journey
toward full stack development, as it helped us understand how backend logic connects
with persistent data. These concepts will play a central role as we move on to
frameworks like Spring Boot, where database interactions become even more powerful
and efficient

ACTIVITY LOG WEEK 9

S. Week Day Content
no

SERVICE, REPOSITORY LAYERS

1 Day-1

2 DEPENDENCY INJECTION, JPI

Day-2

3 Day-3 DTOS, MODEL MAPPING

Week-9

4 Day-4 UNIT TESTING WITH J UNIT

5 Day-5
INTEGRATING SWGGER FOR API
DOCS
Week 9: Introduction to Spring Framework

In Week 9 of the internship, we were introduced to the Spring Framework, one of the
most widely used frameworks for building Java-based enterprise applications. The week
started with an overview of the Spring ecosystem and its benefits, such as lightweight
architecture, dependency injection, and modularity. We learned how Spring simplifies
the development of complex Java applications by managing object creation and wiring
through its powerful Inversion of Control (IoC) container.

We began by setting up a Spring project using Maven for dependency management.

With guidance, we configured our [Link] file to include the necessary Spring
dependencies. Once the setup was complete, we explored the basics of creating beans,
using annotations like @Component, @Autowired, and @Configuration. These
annotations made it easy to define and manage object dependencies, eliminating the
need for manual object creation and increasing code reusability.

Next, we dove deeper into the concept of Dependency Injection (DI), which is at the
core of the Spring Framework. We experimented with constructor-based and setter-
based injection to understand how Spring automatically injects objects into each other.
We also learned about the role of ApplicationContext and BeanFactory in managing
bean lifecycles and scopes. These foundational concepts helped us understand how
Spring handles object management and simplifies application logic.

In the latter part of the week, we learned about Spring’s support for building layered
applications. We were introduced to the DAO (Data Access Object), Service, and
Controller layers, which promote separation of concerns and clean architecture. We
created a small console-based application using Spring Core that followed this layered
pattern, making it easier to maintain and test different parts of the code independently.
 ACTIVITY LOG WEEK 10

S. Week Day Content

no

INTRODUCTION TO ANGULAR OR
1 Day-1 REACT

2 ENVIRONMENT SETUP
Day-2

3 Day-3 COMPONENTS, PROPS /INPUTS

Week-10

4 Day-4 EVENT BINDING, STSTSE MANAGEMENT

5 Day-5
CALLING BACKEND API FROM
FRONT END
Week 10: Spring Boot & REST API Development

In Week 10 of the internship, we began working with Spring Boot, a rapid application
development framework built on top of the Spring ecosystem. Spring Boot helps
developers create stand-alone, production-ready applications with minimal
configuration. We started by understanding the advantages of Spring Boot, such as
auto-configuration, embedded server support, and the ability to build RESTful APIs
quickly. We created our first Spring Boot project using Spring Initializr and set it up in
IntelliJ IDEA.

Our initial focus was on building basic REST APIs using Spring Boot. We learned the core
annotations used in REST API development, such as @RestController,
@RequestMapping, @GetMapping, @PostMapping, @PutMapping, and
@DeleteMapping. These annotations allowed us to create endpoints that could handle
different types of HTTP requests. We developed a simple CRUD (Create, Read, Update,
Delete) API for managing user data using in-memory lists to simulate a database.

We then explored the concept of Model-View-Controller (MVC) architecture in the

context of Spring Boot. We created DTO (Data Transfer Object) classes to handle data
representation, and service classes to separate business logic from controllers. This
helped us follow best practices and keep our code organized, scalable, and easier to
test. We also learned to handle different response types using Response Entity and
@ResponseStatus for better control over HTTP status codes.

Next, we integrated our Spring Boot APIs with a MySQL database using Spring Data JPA.
We created Entity classes, repositories (using JpaRepository), and connected them to
the database via [Link] configuration. This allowed us to store and
retrieve persistent data using simple method names like findAll(), save(), and
deleteById(). The integration of database and backend logic helped us build a complete
and dynamic backend system.
 ACTIVITY LOG WEEK 11

[Link] Week Day Content

FETECHING DATA FROM REST API

1 Day-1

2 DISPLAYING DATA USING TABLES

Day-2

3 Week-11 Day-3 CRUD OPERATIONS WITH UI

FORM HANDLING
4 Day-4

5 Day-5
ALERTS, TOASTS, ERROR HANDLING UI
Week 11: REST API Enhancements and Exception Handling

In Week 11 of the internship, we continued developing our REST API skills by learning
how to enhance our Spring Boot applications with features like custom exception
handling, validations, and better response structuring. The week began with a deep
dive into creating custom exceptions in Spring Boot. We implemented
@ControllerAdvice and @ExceptionHandler to manage exceptions globally, allowing our
applications to return clear and consistent error messages instead of default system
responses.

We also learned how to structure API responses using standard formats that include
status codes, messages, and data. By creating custom response wrapper classes, we
made our endpoints more user-friendly and ready for production use. This practice
improved both debugging and client-side integration, ensuring that front-end
developers receive predictable and meaningful responses from the backend.

Midweek, we focused on input validation using annotations from the

[Link] package such as @NotNull, @Size, @Email, and
@Min/@Max. Combined with the @Valid annotation in our controller methods, these
validations allowed us to prevent invalid data from being saved to the database. We
also learned how to handle validation errors using Binding Result, which helped us
provide detailed feedback to API consumers when data validation failed.

In addition, we revisited the CRUD application we had developed earlier and applied all
these enhancements to it. We refactored the code to handle custom exceptions (like
Resource Not Found Exception) , input validation, and structured error messages. We
tested each endpoint using Postman to ensure it handled all edge cases properly, such
as missing fields, invalid formats, or non-existent resource IDs.
 ACTIVITY LOG WEEK 12

S. Week Day Content

no

1 Day-1 LOGIN AND REGISTRATION UI

2 BACK END AURTH APIs

Day-2

3 Day-3 CONNECTING UI WITH AURTH API

Week-12

4 Day-4 SECURING PAGES BASED ON ROLES

5 Day-5
LOG OUT, TOKEN HANDLING
Week 12: Spring Security and Authentication

In Week 12 of the internship, we explored one of the most crucial aspects of backend
development — implementing security using Spring Security. We began the week by
understanding the fundamentals of web application security, including authentication,
authorization, and the importance of protecting REST APIs. Spring Security, a powerful
and customizable authentication and access control framework, was introduced as our
primary tool to secure Spring Boot applications.

The initial setup involved adding Spring Security dependencies to our project using
Maven. By default, Spring Security secures all endpoints, requiring basic authentication.
We learned how to configure custom username and password authentication using the
application. properties file. Then, we created an in-memory user store using the User
Details Service interface to manage multiple users with different roles like ADMIN and
USER, allowing us to restrict access to specific endpoints.

Midweek, we implemented role-based authorization using annotations like

@PreAuthorize and @Secured. This allowed us to control which user roles could access
certain resources. For example, endpoints for deleting or updating data were restricted
to ADMIN roles only, while general GET requests were accessible to all authenticated
users. We also explored method-level security, where access control was applied
directly at the service or controller method level.

We also customized login and logout functionality using Spring Security’s form-based
login and created a basic login page. Additionally, we configured CSRF (Cross-Site
Request Forgery) protection and learned how to enable or disable it based on project
requirements. Although form login is common in web apps, for APIs we implemented
stateless authentication using HTTP Basic Auth, and also explored the basics of JWT
(JSON Web Token), which we’ll cover in detail later.
 ACTIVITY LOG WEEK 13

S. Week Day Content

no

PROJECT IDEA FINILIZATION

1 Day-1

2 REQUIREMENT ANALYSIS
Day-2

3 Day-3 DATA BASE DESGIN

Week-13

4 Day-4 FRONTEND DESGIN

5 Day-5 BACKEND API WITH PLANNING

Week 13: JWT Authentication and Token-Based Security

In Week 13 of the internship, we focused on implementing JWT (JSON Web Token)

authentication to build a secure, stateless backend for our Spring Boot application. JWT
is widely used in modern web applications to handle authentication without relying on
server-side sessions. We began by understanding the structure of a JWT, which consists
of a header, payload, and signature. This token format allows secure user identity
verification across client-server communication.

We started by creating a Spring Boot authentication flow where the user provides a
username and password, and upon successful validation, a JWT is generated and
returned to the client. We used the jwt library to create and verify JWTs. The token
contains user details and roles, which are used by the application to verify access rights
in subsequent requests. Once received by the client, the token is stored (usually in
local Storage or session Storage) and included in the Authorization header for each
request.

We then built an authentication controller with endpoints for login and registration.
During login, the credentials were verified against the database, and if valid, a JWT was
generated. For each protected resource, the token was validated using a filter that
checked its integrity and expiration. We implemented a Jwt Authentication Filter and
Jwt Utils class to handle token parsing, validation, and user details extraction.

We also explored how to secure endpoints using JWT by replacing the default Spring
Security session-based authentication with stateless JWT filtering. By integrating Jwt
Authentication Entry Point, we handled unauthorized access gracefully, returning
appropriate HTTP 401 messages. Role-based access was preserved using
@PreAuthorize annotations, and only users with valid tokens and roles could access
protected endpoints.
 ACTIVITY LOG WEEK 14

S. Week Day Content

no

SPRING BOOT SET UP

1 Day-1

2 CREATE ENTITY, REPOSITORY, SERVICE

Day-2

3 Day-3 API END POINTS DEVELOPMENT

Week-14

4 Day-4 AUTHENTICATIO SETUP

5 Day-5 TESTING POSTMAN WITH SETUP

Week14: API Integration & Testing with Postman

In Week 14 of the internship, we focused on mastering API integration and testing,

primarily using Postman. Since we had already built several RESTful endpoints with
Spring Boot, this week was dedicated to validating those APIs through practical testing
scenarios. Postman, a powerful API client tool, helped us send different HTTP requests
(GET, POST, PUT, DELETE) and observe responses, making it easier to debug and
document our backend functionality.

We began the week by importing our Spring Boot API endpoints into Postman and
setting up different request collections. Each request included appropriate headers,
body content (in JSON format), and authentication tokens when required. We tested
various success and failure scenarios, such as valid inputs, invalid data, missing fields,
and invalid authentication. These tests helped us confirm that our validation, error
handling, and response structures were working as intended.

Midweek, we implemented token-based authentication testing using JWT. After

generating a token through the login endpoint, we used Postman to include the
Authorization: Bearer <token> header in secured requests. This process gave us a
practical understanding of how frontend clients or third-party tools consume secure
APIs. We also tested role-based access control by using tokens from users with different
roles (e.g., USER and ADMIN) to verify access restrictions on specific endpoints.

Next, we learned to write automated Postman test scripts using JavaScript. These
scripts allowed us to validate response codes, check for expected values in JSON
responses, and automate workflows by chaining multiple requests. We also organized
our Postman collection with environment variables, making it easier to switch between
development and production setups. This level of automation and organization helped
us simulate real-world API testing practices.
 ACTIVITY LOG WEEK 15

S. Week Day Content

no

1 Day-1 CREATE COMPONENTS

2
Day-2 CONNECT API

3 Day-3 FORM SUBMISSION

Week-15

4 Day-4 UI ENHANCEMENTS

5 Day-5 DATA BINDING AND VALIDATIONS

Week 15: Introduction to Frontend with [Link]

In Week 15 of the internship, we transitioned from backend development to the

frontend, beginning with [Link] — one of the most popular JavaScript libraries for
building dynamic user interfaces. We started with the basics: understanding how React
uses a component-based architecture and how it updates the user interface using a
virtual DOM. We installed [Link] and used Create React App to set up our first React
project environment.

We explored the structure of a React application, focusing on functional components,

JSX syntax, and how to render data dynamically using props and state. We built simple
components like headers, footers, and reusable cards to understand how components
communicate and manage internal data. The useState and useEffect hooks were
introduced to handle state and lifecycle events in functional components, which helped
us create interactive and reactive UIs.

Midweek, we learned how to use event handling and conditional rendering in React. We
built small features such as toggles, form handling, and dynamic list rendering
using .map(). This gave us hands-on experience in managing user input and displaying
dynamic content. We also learned to lift the state up and pass callback functions as
props to facilitate two-way communication between parent and child components.

We also explored basic routing using React Router. We implemented multiple pages
like Home, About, and Contact, and navigated between them using the <Link> and
<Route> components. This helped us simulate a multi-page application within a single-
page framework, laying the foundation for building frontend interfaces that connect
with our Spring Boot backend through REST APIs.
 ACTIVITY LOG WEEK 16

S. Week Day Content

no

FINAL TESTING
1 Day-1

2 BUG FIXING
Day-2

DEPLOYMENT ON RENDER/VERCEL/
3 Day-3
NETLIFY
Week-16

4 Day-4 PREPARE PRESENTATION

5 Day-5 FINAL REVIEW AND SUBMISSION

Week 16: Full Stack Integration & Project Deployment

In the final week of the internship, Week 16, we focused on integrating our backend
and frontend into a complete full stack web application. This involved connecting the
Spring Boot RESTful APIs we had developed earlier with the [Link] frontend we built in
Week 15. The integration allowed us to build an end-to-end solution where users could
interact with the application through a modern UI, while the data was processed and
persisted through the backend and database layers.

We began by setting up API communication between React and Spring Boot using the
Axios HTTP client library. Axios allowed us to send GET, POST, PUT, and DELETE
requests from React components to the backend endpoints. We created forms in React
to handle user input and mapped them to respective backend API calls. Data fetched
from the backend was displayed in tables and cards, making the application dynamic
and user-friendly.

Midweek, we implemented user authentication on the frontend. After logging in, the
JWT token received from the backend was stored in the browser’s localStorage and
included in the headers of all protected API calls. This enabled secure access to role-
based features within the application. We also used React Router for conditional
rendering of components based on user login status and roles, providing a smooth and
secure navigation experience.

Once the full stack application was functional, we focused on deployment. We built the
React application using npm run build and configured it to serve the frontend from the
Spring Boot backend using Spring’s resource handlers. The complete application was
then deployed to a cloud platform (such as Heroku or Render) with the help of version
control using Git. We also ensured that database connectivity, environment variables,
and security configurations were correctly set for a production environment.
Conclusion:

The 16-week Java Full Stack Internship has been a transformative journey, offering a
comprehensive and practical understanding of modern web development. From
mastering core Java concepts to building secure backend applications using Spring Boot
and finally developing responsive user interfaces with [Link], each phase contributed
significantly to enhancing our technical capabilities and problem-solving skills.

Throughout the internship, we learned to design and develop RESTful APIs, integrate
with databases using JPA and MySQL, implement robust security using JWT and Spring
Security, and test our endpoints thoroughly with Postman. The transition to frontend
development introduced us to the world of component-based architecture, state
management, routing, and full stack integration using [Link] and Axios.

A key achievement was the successful development and deployment of a full stack web
application that combined all layers of the software stack — frontend, backend, and
database — into one cohesive solution. This real-world project experience helped
reinforce the concepts learned and improved our ability to build scalable, secure, and
user-friendly applications.

The internship not only strengthened our technical foundation but also prepared us to
work effectively in a collaborative development environment, follow best coding
practices, and manage real-world software lifecycle workflows. It has been a stepping
stone toward becoming a confident and capable full stack developer.

In conclusion, this internship has laid a strong foundation for our future in software
development. The hands-on experience, coupled with consistent learning and project
work, has equipped us with the knowledge and confidence to take on complex
development tasks and contribute meaningfully to any tech-driven organization.
Internal & External Evaluation for Semester Internship

Objectives:

● Explore career alternatives prior to graduation.

● To assess interests and abilities in the field of study.

● To develop communication, interpersonal and other critical skills in the future job.

● To acquire additional skills required for the world of work.

● Toacquireemploymentcontactsleadingdirectlytoafull-timejobfollowing
graduation from college.

Assessment Model:

● There shall be both internal evaluation and external evaluation

● TheFacultyGuideassignedisin-chargeofthelearningactivitiesofthestudentsand for the

comprehensive and continuous assessment of the students.

● Theassessmentistobeconductedfor200marks.InternalEvaluationfor50marksand External
Evaluation for 150 marks

● [Link] and grade

points to include finally in the SGPA and CGPA. The weightings for Internal Evaluation
shall be:

o Activity Log 10 marks

o Internship Evaluation 30 marks

o OralPresentation 10 marks
● The External Evaluation shall be conducted by an Evaluation Committee comprising of the
Principal, Faculty Guide, Internal Expert and External Expert nominated by the affiliating
University. The Evaluation Committee shall also consider the grading given by the
Supervisor of the Intern Organization.

● Activity Logis the record of the day-to-day activities. The Activity Logisassessedon an
individual basis, thus allowing for individual members within groups to be assessed this
way.

● While evaluating the student's Activity Log, the following shall be considered-

a. The individual student's effort and commitment.

b. The originality and quality of the work produced by the individual

c. The student's integration and co-operation with the work assigned.

d. The completeness of the Activity Log.

● The Internship Evaluation shall include the following components and based on
Weekly Reports and Outcomes Description

a. Description of the Work Environment.

b. Real Time Technical Skills acquired.

c. Managerial Skills acquired.

d. Improvement of Communication Skill

 INTERNAL ASSESSMENT STATEMENT

Name Of the Student:

Program of Study:
Year of Study:
Group:
Register No/[Link]:
Name of the College:
University:

[Link] Evaluation criterion Maximum Marks

Marks Awarde
d
1 Activity Log 10
2 Internship Evaluation 30
3 OralPresentation 10
GRANDTOTAL 50

Date: Signature of the Faculty Guide

 EXTERNALASSESSMENTSTATEMENT

Name Of the Student:

Program of Study:
Year of Study:
Group:
RegisterNo/[Link]:
Name of the College:
University:

[Link] Evaluation criterion Maximum Marks

Marks Awarded
1 Internship Evaluation 80
For the grading giving by the
2 supervisor of the Intern 20
Organization
3 Viva-Voce 50
TOTAL 150
GRANDTOTAL(EXT.50M+INT.100M) 200

Signature of the Faculty Guide:

Signature of the Internal Expert:

Signature of the External Expert:

Signature of the Principal with: