VISAKHA INSTITUTE OF ENGINEERING & TECHNOLOGY

COMPUTER SCIENCE AND ENGINEERING

Name: METTAPRAVEENBHATLU
Year: IV B-tech
Semester: II
Roll No: 21NT1A0551
Internship: FULL STACK JAVA
 ANINTERNSHIPPROJECTREPORTON

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)
VISAKHAINSTITUTEOFENGINEERINGANDTECHNOLOGY
(Approved by AICTE New Delhi & Recognized by
JNTUG,VIZINAGARAM) 88th Division, NARAVA, GVMC
Visakhapatnam -530027)
 INTERNSHIP16-WEEKSREPORT2025

INTERNSHIP PERIOD DURING 2025

 CERTIFICATE OF INTERNSHIP

This is to certify that the “FULL STACK JAVA’’ submitted by NAME: Metta
Praveen Bhatlu (Regd. No: 21NT1A0551) 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.

K.VIJAY Dr.A.S.C.TEJASWINI 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

th
towards completion training 4 year of BTech (CSE) At EXCELR comprises of

our original work pursue under the guidance of DEPARTMENT OF CSE.

 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

METTAPRAVEENBHATLU

21NT1A0551
FULLSTACK 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

Week- Day-3
HTML AND CSS FUNDAMENTALS
1

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

1 Day-1 RESPONSIVE DESIGN, CSS GRID

2
Day-2 INTRODUCTION TO JAVA SCRIPT

3 Week-2 Day-3
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 System.out.println. 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 java.io
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 (Java Database Connectivity). 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 pom.xml 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 application.properties 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

S.no 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

4 Day-4 FORM HANDLING

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

javax.validation.constraints 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 React.js

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

beginning with React.js — 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 Node.js
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

3 Day-3 DEPLOYMENT ON RENDER/VERCEL/

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 React.js 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 React.js, 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 React.js 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

● Thenumberofcreditsassignedis12.Laterthemarksshallbeconvertedintogrades
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/H.T.No:
Name of the College:
University:

SL.NO 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/H.T.No:
Name of the College:
University:

SL.NO 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: