VISAKHA INSTITUTE OF ENGINEERING &

TECHNOLOGY COMPUTER SCIENCE AND

ENGINEERING

Name: METTAPRAVEENBHATLU
Year: IV B-tech
Semester: II
RollNo: 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
(ApprovedbyAICTENewDelhi&RecognizedbyJNTUG,VIZI
NAGARAM) 88th Division, NARAVA, GVMC
Visakhapatnam -530027)
 INTERNSHIP16-WEEKSREPORT2025

INTERNSHIPPERIOD DURING 2025

 CERTIFICATEOFINTERNSHIP

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.ASC.TEJASWINIKONE
Department Internship Coordinator Head of the Department
DepartmentofCSE Department of CSE

EXTERNAL SIGNATURE
CERTIFICATEFROMEXCERLORGANIZATION
 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

Aproject 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,incompleting of this project.

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

extraordinarily busy withtheir duties,tooktime out tohear,guideandkeep 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 forall 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
informationthathelped in the successful completion of this project

METTAPRAVEENBHATLU

21NT1A0551
FULLSTACK JAVA 16-WEEKSINTERNSHIP

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, whilestyling 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 thebackend, JAVA frameworks such as SPRINGBOOT and servelts are used to

create a robus tserver-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 SQLAlchemy 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- 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- Day-3
JS DATA
2 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

S.n Week 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 advancing our JavaScript

knowledge and learning how to manipulate web pages dynamically using the
Document Object Model (DOM). We began the week by revisiting JavaScript arrays
and objects, which are essential for storing and managing collections of data. We
practiced creating arrays of data, accessing elements using indices, and performing
various array operations like push, pop, shift, unshift, splice, and map.

Moving forward, we explored the concept of objects in JavaScript, which allow us to

group related data and functions. Understanding how to create objects, access
properties, and use methods helped us structure our code more efficiently. We also
learned how arrays and objects could be nested, which is useful for handling complex
data structures such as user profiles or product 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 getElementById, querySelector, innerHTML, setAttribute, and
createElement 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.
fidently toward backend programming with Java in the coming weeks.
ACTIVITY LOG WEEK 5

Week Day Content

1 Day- JAVA INSTALLATION,FIRST

1 PROGRAM

2
Day- DATA TYPES,
2 OPERATORS,CONTROL
STATEMENTS

3 Week- Day- ARRAYS AND STRINGS

5 3

4 Day- OOPS CONCEPTS

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

Day-1 ABSTRACTION ,INTERFACE

S
1

2
Day-2 EXCEPTION HANDLING

Week Day-3 FILE HANDLING

3 -6

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
behaviors 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

1 Day-1 Introduction to SQL

2
Day-2 SQL QUERIES

3 Day-3 DatabaseConnection
Week
-7

4 Day-4 CRUDOperations

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, FileReader, FileWriter,
BufferedReader, and BufferedWriter. 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

FileNotFoundException and IOException. 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

1 Day-1 SPRING BOOT SETUP

2
Day-2 PROJECT
STRUCTURE,ANNOTATIONS

3 Day-3 REST API

Week
-8

4 Day-4 CRUD API WITH SPRING BOOT

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 DriverManager and Connection classes to build basic Java programs that could
connect to a MySQL database.

Next, we worked with Statement and PreparedStatement interfaces to perform database

operations from our Java programs. While Statement was used for simple static queries,
PreparedStatement 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 ResultSet, 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
1 Day-1 LAYERS

2
Day-2 DEPENDENCY
INJECTION ,JPI

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
1 Day-1 OR REACT

2
Day-2 ENVIRONMENT SETUP

3 Day-3 COMPONENTS ,PROPS

/INPUTS
Week
-10

4 Day-4 EVENT BINDING ,STSTSE

MANAGEMENT

5 Day-5
CALLING BACK END 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 ResponseEntity 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

1 Day-1 API

2
Day-2 DISPLAYING DATA USING
TABLES

3 Week- Day-3 CRUD OPERATIONS WITH UI

11

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 BindingResult, 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
ResourceNotFoundException), 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
Day-2 BACK END AURTH APIs

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
UserDetailsService 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

1 Day-1 PROJECT IDEA

FINILIZATION

2
Day-2 REQUIREMENT ANALYSIS

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 jjwt 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 localStorage or
sessionStorage) 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 JwtAuthenticationFilter and JwtUtils 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
JwtAuthenticationEntryPoint, 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
Day-2 CREATE
ENTITY ,REPOSITORY ,SERVICE

3 Day-3 API END POINTS

Week DEVELOPMENT
-14

4 Day-4 AUTHENTICATIO SETUP

W Day-5 TESTING POSTMAN WITH SETUP

ee
k
5
 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
UI ENHANCEMENTS
4 Day-4

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
Day-2 BUG FIXING

DEPLOYMENT ON
3 Day-3
RENDER/VERCEL/ NETLIFY
Week
-16
PREPARE PRESENTATION
4 Day-4

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&ExternalEvaluationforSemesterInternship

Objectives:

● Explorecareeralternativespriortograduation.

● Toassess interestsandabilitiesinthefieldofstudy.

● Todevelopcommunication,interpersonalandothercriticalskillsinthefuture job.

● Toacquireadditionalskillsrequiredfortheworldofwork.

● Toacquireemploymentcontactsleadingdirectlytoafull-
timejobfollowing graduation from college.

AssessmentModel:

● Thereshallbebothinternalevaluation andexternal 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.TheweightingsforInternalEvaluationshallbe:
o ActivityLog 10 marks
o InternshipEvaluation 30 marks
o OralPresentation 10 marks
● TheExternalEvaluationshallbeconductedbyanEvaluationCommitteecomprisingo
f the Principal, Faculty Guide,InternalExpertandExternalExpertnominatedbythe
affiliating University. The Evaluation Committee shall also consider the
grading given by the Supervisor of the Intern Organization.

● ActivityLogistherecordoftheday-to-dayactivities.TheActivityLogisassessedon
an individual basis, thus allowing for individual members within groups to be
assessed this way.

● Whileevaluatingthestudent'sActivityLog,thefollowingshallbeconsidered-

a. Theindividualstudent'seffortand commitment.

b. Theoriginality andqualityofthework producedbytheindividual

c. Thestudent'sintegrationandco-operationwiththeworkassigned.

d. Thecompleteness oftheActivityLog.

● TheInternshipEvaluationshallincludethefollowingcomponentsandbasedo
n Weekly Reports and Outcomes Description

a. DescriptionoftheWork Environment.

b. RealTimeTechnicalSkillsacquired.

c. ManagerialSkillsacquired.

d. ImprovementofCommunication Skills
 INTERNALASSESSMENTSTATEMENT

NameOftheStudent:
Program of Study: Year
of Study: Group:
RegisterNo/H.T.No:
Name of the College:
University:

SL.NO Evaluationcriterion Maximum Marks

Marks Awarde
d
1 ActivityLog 10
2 InternshipEvaluation 30
3 OralPresentation 10
GRANDTOTAL 50

Date: SignatureoftheFaculty
Guide
 EXTERNALASSESSMENTSTATEMENT

NameOftheStudent:
Program of Study: Year
of Study: Group:
RegisterNo/H.T.No:
Name of the College:
University:

SL.NO Evaluationcriterion Maximum Marks

Marks Awarde
d
1 InternshipEvaluation 80
Forthegradinggivingbythe
2 supervisor of the Intern 20
Organization
3 Viva-Voce 50
TOTAL 150
GRANDTOTAL(EXT.50M+INT.100M) 200

Signatureof the FacultyGuide

Signature of the Internal Expert

Signature of the External Expert

SignatureofthePrincipalwithSeal