Enterprise Web Application Development using

Java, Angular and SQL

INTERNSHIP REPORT

submitted in partial fulfillment of the requirements for the award of the degree
of
BACHELOR OF TECHNOLOGY
in
INFORMATION TECHNOLOGY ENGINEERING
Submitted by

Piyush Aggarwal
07711503121

Under the supervision of

Dr. Arvind Rehalia

Assistant Professor

DEPARTMENT OF INFORMATION TECHNOLOGY

BHARATI VIDYAPEETH’S COLLEGE OF ENGINEERING
(AFFILIATED TO GURU GOBIND SINGH INDRAPRASTHA UNIVERSITY,
DELHI)
NEW DELHI – 110063
MAY / JUNE 2025

1
 CANDIDATE’S DECLARATION
This is to certify that the material embodied in this Internship Report titled

“Enterprise Web Application Development using Java, Angular, SQL” being

submitted in the partial fulfillment of the requirements for the award of the degree of

Bachelor of Technology in Information Technology is based on my original work. It

is further certified that this Internship work has not been submitted in full or in part to

this university or any other university for the award of any other degree or diploma.

My indebtedness to other works has been duly acknowledged at the relevant places.

Piyush Aggarwal

07711503121

1
 CERTIFICATE FROM THE COMPANY
This is to certify that Piyush Aggarwal (Enrollment No. 07711503121) has
undertaken internship at NAGARRO, Sector 18, Gurugram, Haryana 122015, India
from 22nd Jan 2025 under the supervision and guidance of Ms Shradha Goswami,
Senior Analyst.

Shradha Goswami
Senior Analyst
Nagarro

2
 CERTIFICATE FROM INSTITUTE
This is to certify that the work embodied in this Internship Report titled “Enterprise
Web Application Development using Java, Angular, SQL” being submitted in the
partial fulfillment of the requirements for the award of the degree of Bachelor of
Technology in Information Technology, is original and has been carried out by
Piyush Aggarwal (Enrollment No. 07711503121) under my supervision and
guidance.

It is further certified that this Internship work has not been submitted in full or in part
to this university or any other university for the award of any other degree or diploma
to the best of my knowledge and belief.

Dr Arvind Rehalia Dr. Preeti Nagrath

Associate Professor TNP Head

Dr Prakhar Priyadarshi
Head of Department

4
 ACKNOWLEDGEMENT
I am deeply grateful to Nagarro for providing me the opportunity to pursue my internship as a Java

Trainee.

This experience has played a pivotal role in enhancing my practical knowledge of full stack

development. It complemented my academic learning with real-world exposure to building

dynamic web applications, enabling me to apply both frontend and backend concepts

effectively. The culmination of this training was a hands-on exit test project where I

developed a complete web application using Java and Angular, reinforcing my

understanding of application architecture, user interface design, and data handling.

I would like to extend my heartfelt thanks to my industry mentor, Ms. Akanksha Rastogi, for her expert

guidance, continuous encouragement, and constructive feedback throughout the project. Her support

was instrumental in helping me apply theoretical concepts to practical challenges and refine my

technical skills.

I am also thankful to Dr. Arvind Rehalia and the faculty of Bharati Vidyapeeth's College of Engineering

for their academic guidance and for structuring this internship as a part of the curriculum. Their support

was vital in helping me approach this internship with the right mindset and objectives.

Lastly, I would like to thank my family and peers for their unwavering motivation, patience, and moral

support throughout the course of this internship.

Piyush Aggarwal
(07711503121)

5
 ABSTRACT

This report details the development of a comprehensive community website platform,

consisting of a Java Spring Boot REST API backend and an Angular frontend. The
platform enables users to register, authenticate, search for questions, post new
questions, comment on existing questions, and like comments. The project
successfully implements all core requirements within the specified 6 PD timeline,
including bonus features such as the question closure system and statistics dashboard.

The development process followed industry best practices for both backend and
frontend implementations, with a focus on security, performance optimization, and
user experience. The platform architecture was designed with scalability in mind,
employing a layered approach that separates concerns and enables future
enhancements.

Key achievements include a robust search system capable of filtering questions by

multiple parameters, secure JWT-based authentication, responsive design for multiple
device types, and real-time updates for comments. The system demonstrates excellent
performance even under load, thanks to careful database design and frontend
optimization techniques.

This internship provided practical exposure to full stack java development using java
and angular, significantly enhancing my understanding of code quality control, and
efficient software delivery.

6
 TABLE OF CONTENTS

Declaration i
Certificate from the Company ii
Certificate from the Institute iii
Acknowledgement iv
Abstract v
List of Figures vi
Chapter 1: Introduction of the Company 1
1.1: About the Company 1
1.2: Profile of the Company 2
Chapter 2: Introduction of the Internship 5
2.1: About the Internship 5
2.2: Objectives of the Internship 5
2.3: Roles and Responsibilities 6
Chapter 3: Internship Activities 10
3.1: Task Description 10
3.2: Tools / Technologies / Platform used 12
3.3: Technical Application 18
3.4: Challenges Faced 20
Chapter 4: Contribution to the Organization 21
4.1: Key Activities and Contributions 21
Chapter 5: Learning and Development 25
5.1: Technical Skills Acquired 25
5.2: Professional and Soft Skills Developed 27
Chapter 6: Summary and Conclusion 28
6.1: Summary 28
6.2: Conclusion 29
Chapter 7: Suggestions for the Improvement 30
References 32

xi
15
 LIST OF FIGURES

Fig. No. Title Page No.

1 Spring boot flow architecture 13

2 Spring Security 13

3 Hibernate 14

xi
16
 CHAPTER 1: INTRODUCTION OF COMPANY

1.1 About the Company

Nagarro is a global leader in digital product engineering and technology

consulting, known for delivering tailored, high-quality solutions that address
complex business challenges. Founded in 1996 and headquartered in Munich,
Germany, the company has grown exponentially, with a presence in over 30
countries and a team of more than 18,000 professionals.

Nagarro operates on a foundation of agile methodologies, continuous innovation,

and customer-centric values. The organization focuses on helping businesses
adopt modern digital strategies, enabling them to remain competitive in fast-
changing markets. Nagarro’s services span the full software development life
cycle—from ideation and design to development, deployment, and post-launch
optimization.

The company’s philosophy is deeply rooted in engineering excellence and

human-centric values. It fosters a culture of transparency, collaboration, and
autonomy, encouraging its teams to think creatively and solve problems
independently. Nagarro is not just a service provider but a technology partner that
co-creates value with its clients by leveraging advanced technologies like cloud
computing, artificial intelligence, DevOps, and big data analytics.

In addition to its technical prowess, Nagarro is widely recognized for its people-
first approach. The company emphasizes a flat hierarchy, open communication,
and flexible work arrangements. Its caring policy is designed to ensure employee
well-being through mental health support, work-life balance, diversity and
inclusion programs, learning & development initiatives, and remote work
flexibility. Nagarro’s tagline—"Thinking Breakthroughs"—captures its
commitment to innovation through empowered, well-supported teams.

1
1.2 Profile of the Company

- Company Name: Nagarro SE

- Founded: 1996

- Headquarters: Munich, Germany

- Global Presence: Offices in 30+ countries across Europe, Asia, Americas,

and Australia

- Workforce: Over 18,000 professionals

- Core Philosophy: Thinking Breakthroughs

- Mission Statement: To make distance irrelevant between intelligent people

1.2.1 Industries Served:

- Healthcare

- Finance & Banking

- Retail & eCommerce

- Travel & Hospitality

- Automotive

- Manufacturing

- Public Sector

1.2.2 Key Service Areas:

- Software Development & Product Engineering

- Cloud Services & DevOps

- Artificial Intelligence & Machine Learning

- Cybersecurity

2
 - Data Analytics & Business Intelligence

- User Experience & UI/UX Design

- Enterprise Resource Planning (ERP) Solutions

1.2.3 Employee-Centric Policies:

- Flexible working hours and remote work culture

- Mental health and wellness support programs

- Inclusive environment with DEI (Diversity, Equity & Inclusion)

initiatives

- Ongoing training, certifications, and learning programs

- Flat organizational structure encouraging autonomy and creativity

1.3 Core Values and Work Culture

At the heart of Nagarro’s organizational philosophy is the belief: "We are powered
by caring." This core value drives everything—from how the company interacts with
clients to how it fosters innovation and builds its global workforce. Caring is what
fuels Nagarro’s long-term partnerships, its culture of responsibility, and its continuous
delivery of exceptional results.

Nagarro’s values are deeply embedded in every layer of its operations:

 Client-Centric: Nagarro prioritizes client success and aims to build strong, long-
term partnerships based on trust, performance, and mutual growth.

 Agile: The company thrives on iteration and innovation. It follows a flexible,

feedback-driven approach to quickly adapt, evolve, and create breakthrough
solutions.

 Responsible: Nagarro promotes ownership and accountability, encouraging every

employee to stand by their work and treat colleagues, clients, and the planet with
respect and integrity.

3
 Intelligent: The company values smart decision-making over rigid processes. It
celebrates boldness, merit, and results over hierarchy or geographic location.

 Non-Hierarchical: Nagarro fosters a flat organizational culture that empowers

employees to be entrepreneurial, creative, and self-driven. Roles are defined by
responsibility, not rank.

 Global: With a presence in 38 countries and a team of over 18,000 professionals

representing 16 nationalities at the senior management level, Nagarro is truly
global. It draws strength from its diversity and collective intelligence.

This dynamic, people-focused environment is what defines Nagarro as more than just
a tech company—it is a growing "Nation of Nagarrians", driven by purpose,
innovation, and human connection.

The Spirit of Innovation and Experimentation:

Nagarro nurtures a mindset where innovation isn't limited to research labs or

designated roles—it's a part of daily problem-solving. Employees are encouraged to
think outside the box, take calculated risks, and experiment with emerging
technologies. This open-minded approach creates a space where creative ideas are
welcomed, rapidly prototyped, and iterated upon. Whether it’s building a new tool or
improving internal workflows, Nagarrians are empowered to challenge the status quo
and pursue excellence.

Learning and Growth as a Continuous Journey:

At Nagarro, learning is seen as a lifelong pursuit. Through structured training

programs, mentoring, and hands-on project exposure, the company ensures that each
employee continues to grow in their personal and professional journey. Interns are not
only treated as learners but also as contributors. They are given real-world
responsibilities and the support needed to deliver. This fosters a sense of purpose and
belonging early in one's career and helps cultivate confidence, skills, and a growth
mindset.

4
 CHAPTER 2: INTRODUCTION OF THE
INTERNSHIP

2.1 About the Internship

This internship was conducted at Nagarro, a globally recognized IT consulting and

digital engineering company, as a part of the academic curriculum of my
undergraduate program. The internship began on 22nd January 2025 and is currently
ongoing. It is being conducted in offline mode, requiring daily presence at Nagarro's
Gurgaon office, which provided valuable exposure to a professional work
environment.

Before the internship began, a technology allocation assessment was conducted,

based on which I was assigned to the Java domain under the role of a Technology
Trainee. The internship served as an initial phase of industry training, later leading to
a full-time role offer based on performance and learning outcomes.

During the training program, I worked extensively on building full-stack web

applications using Core Java for backend development and Angular for the frontend,
complemented by SQL for database management and HTML, CSS, and JavaScript for
creating responsive user interfaces. Key areas of focus included object-oriented
programming, RESTful service development, frontend component architecture, and
structured query building. I also strengthened my algorithmic thinking through in-
depth practice in Data Structures and Algorithms.

This hands-on experience culminated in a final exit test project, where I applied the
complete stack to build a real-world web application. The program provided a strong
foundation in enterprise-level development practices and helped me bridge the gap
between academic learning and real-world implementation within a corporate
environment.

5
2.2 Objectives of the Internship

 To Gain Practical Exposure to Java Development Practices

Understand and apply Java development principles in real-world scenarios,
including writing clean, maintainable, and efficient code following best practices.
 To Build Robust Backend Systems with Spring Framework
Learn to develop RESTful APIs using Spring Boot, implement security with
Spring Security, and work with databases using Spring Data JPA and Hibernate.
 To Work with Databases in Java
Learn how to interact with relational databases using JDBC, Spring Data, and
ORM tools. Understand how to design efficient and scalable database models and
perform CRUD operations.
 To Bridge the Gap Between Academic Learning and Industry Practices
Apply theoretical knowledge in practical Java development scenarios, using
industry-standard tools and frameworks to build production-ready systems.
 To Build Team Collaboration and Professional Communication Skills
Gain experience working in a collaborative environment with agile teams,
participating in code reviews, and delivering features using Git-based version
control.
 To Prepare for a Future Full-Time Role
Build the necessary skills and confidence to transition into a full-time Java
developer role post-internship, including knowledge of cloud-native Java
applications and scalability considerations.
 To Gain Practical Exposure to Frontend Development Practices
Learn how to build dynamic and responsive single-page applications (SPAs) using
Angular, leveraging the framework's modularity and component-based
architecture.
 To Learn and Implement Angular Components and Services
Understand the creation of reusable components, services, and directives, and
learn how to manage state and handle data binding efficiently in Angular
applications.
 To Build Robust Web Applications with Angular CLI
Master the Angular CLI for project scaffolding, managing dependencies, and

6
 automating tasks such as testing, building, and serving the app for different
environments.

2.3 Roles and responsibilities

 Understanding Core Java Concepts:

I gained a deep understanding of fundamental Java programming concepts such as
variables, data types, control structures, loops, functions, and object-oriented
programming (OOP). I applied these concepts to build efficient and scalable
backend solutions, leveraging Java’s features like exception handling, collections,
and multi-threading for improved performance and reliability.
 Development and Version Control:
I applied best practices for developing Java applications using object-oriented
principles, with a focus on maintainability and code quality. For version control, I
used Git to manage code changes, collaborate with other developers, and follow
industry-standard workflows such as feature branching and pull requests.
 Working with APIs and Libraries:
I integrated RESTful APIs and used third-party libraries to extend the
functionality of Java applications. Understanding the use of libraries like Jackson
for JSON processing and Apache Commons for utility functions helped me build
robust applications.
 Application Design Patterns:
I applied design patterns like Singleton, Factory, and Observer to solve common
design challenges in Java. This improved code modularity and made maintenance
easier.
 Understanding Java 8 Enhancements:
I gained hands-on experience with key Java 8 features such as lambda expressions,
streams, and the Optional class. I used lambda expressions to write more concise
and expressive code, and streams to process collections efficiently in a functional
programming style.
 Functional Programming in Java:
I explored functional programming concepts in Java 8, including the use of
higher-order functions, function composition, and working with immutable data

7
 structures. This improved my understanding of how to write clean, less error-
prone code
 Date/Time API:
I became proficient with the new Date/Time API introduced in Java 8, which
helped me handle date and time manipulations in a more intuitive and thread-safe
way compared to the old Date and Calendar classes.
 Building Web Applications with Spring MVC:
I worked with the Spring MVC framework to develop scalable and secure web
applications. I leveraged Spring's Model-View-Controller (MVC) architecture to
separate concerns and ensure a clean, maintainable codebase.
 Dependency Injection and IoC:
I used Spring’s Dependency Injection (DI) to manage object dependencies and
improve testability. This made my applications more modular and easier to scale
and maintain.
 Database Integration with Spring Data JPA:
I integrated Spring Data JPA for seamless database interaction and used Hibernate
for ORM mapping, improving the efficiency and ease of managing database
operations
 Spring Security:
I implemented authentication and authorization mechanisms using Spring Security
to secure web applications and REST APIs, including role-based access control
(RBAC) and OAuth2 integration.
 Understanding Fundamental Data Structures:
I studied and implemented core data structures such as arrays, linked lists, stacks,
queues, trees, and graphs. This gave me a solid foundation for solving algorithmic
challenges and optimizing code performance.
 Solving Problems Using Algorithms:
I applied searching and sorting algorithms, including binary search, quicksort,
mergesort, and breadth-first search, to solve real-world problems efficiently.
 Time and Space Complexity Analysis:
I analyzed the time and space complexity of algorithms using Big O notation,
ensuring I could optimize solutions for better performance, especially for large
datasets.

8
 Dynamic Programming and Recursion:
I mastered dynamic programming techniques to solve problems involving
overlapping subproblems, and I applied recursion to break down complex
problems into manageable parts.
 Graph Algorithms and Tree Traversals:
I implemented graph algorithms such as Dijkstra’s and depth-first search (DFS)
and learned different tree traversal techniques like in-order, pre-order, and post-
order.
 HTML for Structuring Web Pages:
I gained proficiency in HTML5 to create semantic, well-structured web pages. I
used HTML elements like forms, tables, and links to build user-friendly interfaces.
 Styling with CSS:
I used CSS to design visually appealing web pages, leveraging techniques like
Flexbox and Grid for layout, and CSS transitions and animations for interactive
elements.
 Responsive Web Design:
I developed responsive web applications by using media queries to ensure that the
UI adapts seamlessly to various screen sizes and devices.
 JavaScript for Interactivity:
I wrote JavaScript to add interactivity to web pages, including DOM manipulation,
event handling, and AJAX calls to create dynamic and responsive user
experiences.
 ES6+ Features in JavaScript:
I explored modern JavaScript features like arrow functions, template literals,
destructuring, async/await, and classes to write clean, efficient code.
 Writing Complex SQL Queries:
I gained proficiency in writing complex SQL queries to retrieve, insert, update,
and delete data from relational databases. I used techniques like joins, subqueries,
and window functions to efficiently handle various data requirements.
 Database Design and Normalization:
I applied database design principles such as normalization to create efficient,
scalable schemas, reducing redundancy and ensuring data integrity.
 Optimizing SQL Queries:
I learned how to optimize SQL queries for performance, including indexing, query
9
 profiling, and understanding execution plans to ensure queries run efficiently on
large datasets.
 Stored Procedures and Triggers:
I developed stored procedures and triggers to automate repetitive tasks, ensuring
business logic is executed consistently at the database level.
 Data Security and Transactions:
I implemented data security measures such as access controls and encryption. I
also worked with transactions to ensure data consistency and integrity in multi-
step operations.
 Building SPAs with Angular:
I developed Single-Page Applications (SPAs) using Angular, utilizing
components, services, and directives to build dynamic and responsive user
interfaces.
 Routing and State Management:
I implemented Angular’s router to manage navigation and handle dynamic content
loading. I also explored state management techniques using RxJS and NgRx to
manage application state efficiently.
 Forms and Validation in Angular:
I worked with template-driven and reactive forms to handle user inputs and
implemented form validation to ensure data integrity.
 Observables and Reactive Programming:
I mastered the use of RxJS observables for handling asynchronous data streams
and implemented reactive programming patterns to improve data flow and UI
responsiveness.
 Component Communication and Dependency Injection:
I learned how to manage communication between Angular components and
services using Angular’s dependency injection system, making the app modular
and easier to maintain.

10
 CHAPTER 3: INTERNSHIP ACTIVITIES

3.1 Task Description

During my internship at [Your Company], I worked on a comprehensive Full-Stack

Web Application project titled “Developing, Deploying, and Managing Java-
based Backend, Angular Frontend, and SQL Databases.” The primary objective
was to design, develop, and deploy a full-stack web application, ensuring seamless
integration between the front-end, back-end, and the database. This project covered
various stages of development, from setting up the backend with Java and Spring
Boot, creating dynamic, responsive user interfaces with Angular, to managing data
and performance with SQL databases.

I applied industry best practices for web development and collaborated with multiple
teams to ensure that the application was robust, maintainable, and scalable. I utilized
several tools and technologies including Java (Spring Boot), Angular, SQL
(MySQL/PostgreSQL), Git for version control, and Jenkins for CI/CD, integrating
them into the overall project workflow to streamline development and deployment
processes.

Key Highlights of the Project:

 Java Backend Development (Spring Boot):

I developed the backend of the application using Java and Spring Boot, focusing
on building RESTful APIs that interacted with the front-end and database. I
implemented services for CRUD operations, authentication (JWT), and security,
ensuring the application was scalable and secure. By leveraging Spring Boot’s
automatic configurations and modules like Spring Data JPA, I ensured efficient
database management and smooth API development.

 Angular Frontend Development:

I worked on creating the front-end of the application using Angular, ensuring a
dynamic and responsive user interface. I developed features like data binding,
form validation, routing, and integration with backend APIs. By leveraging
Angular’s powerful CLI and component-based architecture, I created reusable
and maintainable components that were consistent across the entire application.

 Database Design and Management (SQL):

I designed and managed the SQL database using MySQL/PostgreSQL, ensuring

11
 that the data layer was efficient and reliable. I created normalized tables,
implemented relationships, and wrote complex SQL queries to fetch and
manipulate data. By optimizing queries and using indexing, I was able to improve
performance for large datasets.

 Version Control & Collaboration:

I utilized Git for version control and collaborated with team members through
GitHub. I followed Git flow to manage branches, handle pull requests, and
resolve merge conflicts, ensuring smooth collaboration with other developers.

 API Integration:
I integrated the Angular front-end with the Java back-end by calling the REST
APIs to fetch and submit data. I used HTTPClient in Angular to handle
asynchronous requests and displayed dynamic data from the backend on the
frontend. This integration was crucial for making the web application interactive
and functional.

 Authentication & Security:

I implemented JWT-based authentication on the backend and integrated it with
the Angular front-end to ensure secure user login and role-based access control
(RBAC). By utilizing industry-standard practices like encryption and token-based
authentication, I ensured that sensitive data remained secure.

3.2 Tools/Technologies/Platform used

1. Spring Boot

Simplified Configuration: Spring Boot's "convention over configuration" approach

eliminated the need for extensive XML configuration, enabling rapid development

with sensible defaults.

Auto-configuration: The framework automatically configured many components

based on dependencies in the classpath, reducing boilerplate code.

Embedded Server: The application includes an embedded Tomcat server,

simplifying deployment by eliminating the need for a separate application server.

12
Spring MVC: This component facilitated the development of RESTful endpoints

with annotations like @RestController, @RequestMapping, and @ResponseBody.

Spring Data: Integration with JPA simplified database operations through repository

interfaces, reducing the need for custom SQL queries.

Fig 1 : Spring Boot flow architecture

2. Java

Type Inference with var: Local variable type inference reduced verbosity while
maintaining type safety.

String API Enhancements: New methods like isBlank(), strip(), and lines()
simplified text processing.

Collection Factory Methods: Methods like List.of() and Map.of() enabled easier
creation of immutable collections.

Stream API Improvements: Enhanced functional programming capabilities with

new methods such as dropWhile() and takeWhile().

13
HTTP Client API: The standardized HTTP client simplified API communication for
external services.

3. Spring Security with JWT

Authentication: Custom authentication provider integrated with JWT for stateless

authentication.

Authorization: Role-based access control with method-level security annotations.

Password Encoding: BCrypt password hashing for secure storage of user credentials.

CORS Configuration: Controlled cross-origin requests to allow frontend access from

different domains during development.

CSRF Protection: Protection against cross-site request forgery attacks for non-GET
endpoints.

Fig 2: Spring Security

4. Spring Data JPA with Hibernate

The data access layer leveraged Spring Data JPA with Hibernate for object-relational
mapping:

Repository Pattern: Spring Data repositories reduced boilerplate code for database
operations.

14
Specification API: Dynamic query building for complex search operations with
multiple optional filters.

Entity Relationships: Mapping of complex relationships between entities (one-to-

many, many-to-many).

Transaction Management: Declarative transaction management with

@Transactional annotations.

Query Optimization: Eager and lazy loading strategies to optimize database access.

Fig 3: Hibernate

5. MySQL Database

MySQL provided a robust relational database management system for the application:

Schema Design: Normalized database schema to minimize redundancy and ensure

data integrity.

Indexing Strategy: Carefully placed indexes on frequently searched columns to

optimize query performance.

Constraints: Foreign key constraints to maintain referential integrity between related

tables.

Character Encoding: UTF-8 encoding to support international characters in user-

generated content.

15
6. Angular

Angular provided a comprehensive framework for building the frontend application:

Component Architecture: Encapsulated UI elements with their own templates, styles,

and logic.

TypeScript Integration: Strong typing improved code quality and developer

experience.

Dependency Injection: Built-in DI system simplified service management and

testing.

Reactive Forms: Powerful form handling with validation and dynamic form controls.

Routing: Client-side navigation with route guards for protected areas.

Observables: Reactive programming with RxJS for managing asynchronous

operations.

7. HTML5 & CSS3

Modern web standards were employed for markup and styling:

Semantic HTML: Proper use of HTML5 elements for improved accessibility and
SEO.

CSS Grid and Flexbox: Modern layout techniques for responsive design.

CSS Variables: Custom properties for consistent theming and easier maintenance.

Media Queries: Responsive breakpoints for adapting to different screen sizes.

CSS Animations: Subtle animations for improved user experience.

8. VS Code

Visual Studio Code (VS Code) has become the preferred IDE for many Angular
developers due to its lightweight nature, extensive extension marketplace, and

16
excellent support for TypeScript and JavaScript development. Provides rich editor
features like code completion, error checking, and quick info for Angular templates.
Accelerates development with pre-built code fragments for common Angular patterns.
Provides a UI for running Angular CLI commands directly within VS Code.
Intelligent code completion that understands Angular's dependency injection system.
Chrome Debugger extension for real-time debugging of Angular applications

9. Intellij Idea

IntelliJ IDEA, particularly the Ultimate Edition, offers comprehensive support for
Java and Spring Framework development. Its deep understanding of Spring's
architecture makes it an ideal choice for enterprise application development.Spring
Initializr Integration Create new Spring Boot projects directly from the IDE Spring
Boot Dashboard Manage and control Spring Boot applications Spring Tool Support
Visualize and navigate Spring beans, controllers, and services. Advanced code
completion with awareness of Spring annotations and patterns. Robust debugging
with conditional breakpoints and expression evaluation

3.3 Technical Application

The system follows a modern client-server architecture with clear separation between
the frontend and backend components. This separation allows for independent scaling
and maintenance of each layer.

The backend is built using Spring Boot, providing RESTful API endpoints that handle
data processing, business logic, and persistence. The frontend, developed with
Angular, communicates with these endpoints using HTTP requests, presenting data to
users through an intuitive interface and collecting user input.

Data flows between these layers in the form of JSON payloads, with the backend
validating all incoming data before processing. Authentication is handled through
JWT tokens, which are generated upon successful login and attached to subsequent
requests.

The overall architecture follows these principles:

17
  Separation of concerns: Each component has well-defined responsibilities
 Statelessness: The backend does not maintain client state between requests
 Layered system: Components interact only with adjacent layers
 Uniform interface: Communication follows standardized RESTful patterns

The backend implements a layered architecture pattern, consisting of:

Controller Layer :This layer handles incoming HTTP requests, performs basic
validation, and routes requests to appropriate service methods. Controllers are
organized by domain (authentication, questions, comments) and follow RESTful
conventions for endpoint design. They translate between HTTP requests/responses
and the service layer's domain objects.

Service Layer :This layer contains the business logic of the application. Services
validate data more thoroughly, orchestrate operations that might span multiple
repositories, and enforce business rules. They abstract the complexity of operations
from controllers and provide a clean API for the controller layer.

Repository Layer :This layer interfaces with the database, using Spring Data JPA to
translate between Java objects and database records. Repositories provide methods for
basic CRUD operations and more complex queries.

Security Layer :This cross-cutting layer handles authentication and authorization

concerns. It includes JWT token generation and validation, user authentication, and
role-based access control. The security layer intercepts requests before they reach
controllers to ensure they come from authenticated sources with appropriate
permissions.

Model Layer :This foundational layer defines the domain entities that represent the
core data structures of the application, such as User, Question, Comment, and Tag. It
also includes Data Transfer Objects (DTOs) that structure the data exchanged
between layers and with the frontend.

The Angular frontend follows a component-based architecture organized around

features and shared functionality:

18
Core Module :Contains singleton services and components that are loaded once
during application startup, including:

 Authentication service
 HTTP interceptors for token handling
 Guards for route protection
 Global error handling

Shared Module :Houses reusable components, directives, and pipes used across the
application:

 Form components (input fields, validators)

 UI components (cards, pagination, loaders)
 Utilities and common services

Feature Modules :Organized around specific functional areas of the application:

 Authentication (login, registration)

 Home (landing page, statistics)
 Questions (search, view, post)
 Comments (post, like)
 User (profile, my questions)

Each feature module contains:

 Components that handle the UI presentation and user interaction

 Services that communicate with the backend API
 Models that define the data structures
 Routing definitions for navigating within the feature

State Management The application uses a service-based state management approach,

with services maintaining state through RxJS BehaviorSubjects and exposing it via
Observables. Components subscribe to these Observables to receive updates and
render accordingly.

19
3.4 Challenges faced

Technical Learning Curve

 Multiple Framework Mastery: Developers often struggle with maintaining

expertise in both Java backend (Spring Boot/Java EE) and Angular frontend
technologies simultaneously
 Testing Framework Complexity: Learning and implementing different testing
approaches for Java (JUnit, Mockito) and Angular (Jasmine, Karma) within the same
CI pipeline
 Build Tool Integration: Configuring Maven/Gradle for Java while using npm/yarn
for Angular, and ensuring they work together seamlessly

Environment and Deployment Challenges

 Environment Consistency: Maintaining consistent development, testing, and

production environments across both Java and Angular components
 Containerization Complexities: Creating optimized Docker containers for both Java
services and Angular applications, with proper layering to reduce image size
 Hot Reloading Issues: Setting up effective hot-reloading for development
environments, particularly challenging when integrating Java backend changes with
Angular frontend updates

Pipeline and Integration Problems

 Multi-Module Build Pipeline Delays: Managing slow CI/CD pipelines when both
Java and Angular components need to be built, tested, and deployed
 Frontend-Backend Version Compatibility: Ensuring API contracts between
Angular frontend and Java backend remain compatible through versioning and
contract testing
 Static Analysis Configuration: Configuring SonarQube/SonarCloud for both Java
and TypeScript codebases with appropriate quality gates

Operational Challenges

 Separated Logging Systems: Consolidating logs from Java services and Angular
applications into a unified monitoring solution

20
  Performance Bottleneck Identification: Determining whether performance issues
originate in the Java backend, Angular frontend, or network communication between
them
 Resource Scaling Imbalances: Managing different scaling requirements for stateful
Java services versus stateless Angular applications

Integration and Configuration Issues

 Authentication Flow Integration: Implementing and debugging JWT/OAuth flows

between Angular and Java components
 CORS Configuration Problems: Setting up proper CORS policies in Java backends
to accept requests from Angular applications
 Proxy Configuration: Managing development proxies to route API requests from
Angular to Java services appropriately

DevOps Process Optimization

 Independent Deployment Requirements: Designing pipelines that allow for

separate deployment of Java and Angular components when needed
 Automated Testing Strategy: Creating an effective testing pyramid across both
technologies while avoiding test duplication
 Database Migration Management: Handling database schema changes
synchronized with both Java model changes and Angular form/component updates

CHAPTER 4: CONTRIBUTION TO THE

ORGANIZATION
During my internship at Nagarro as a Java Trainee, I had the opportunity to not only
enhance my technical and professional skills but also contribute meaningfully to the
Java intern program and its collaborative learning environment. While the primary
goal was training and skill development, the internship was structured to allow interns
to actively participate, share insights, and improve team workflows — in line with
Nagarro’s culture of innovation and collaboration.

21
4.1 Key Activities and Contributions

1. Active Participation and Knowledge Sharing: I consistently engaged in daily

technical sessions and group discussions, where I asked relevant questions and shared
logical approaches to problem-solving, particularly in areas such as spring, java, and
angular. My contributions often helped spark discussions and supported my peers in
clarifying complex java concepts.

I also prepared concise notes and summaries from sessions — especially related to
tools like java and angular — and shared them within the group. These documents
were appreciated for their clarity and proved helpful as quick references for others.

2. Implementation of Concepts into Practical Solutions:

Throughout the internship, I was deeply involved in building and optimizing

development for both Java (Spring MVC) and spring. The objective was to streamline
the entire software development lifecycle from code to deployment using best
practices. My responsibilities began with configuring the build process using tools
like Maven for Java, ensuring that each application was compiled and packaged
correctly. I then integrated automated testing stages to validate application logic and
prevent regressions early in the pipeline.

To maintain code quality and consistency, I added SonarCloud-based static code

analysis into the pipeline, ensuring that only high-quality code could progress to the
next stages. Once the builds were successfully generated, I stored the output artifacts
in JFrog Artifactory, which enabled version control and traceability of every build.
The applications were then containerized using Docker, providing an isolated and
consistent runtime environment.

The final deployment was executed on Azure Kubernetes Service (AKS) where the
Dockerized applications were orchestrated using Kubernetes. This end-to-end pipeline
not only ensured faster and reliable software delivery but also gave me hands-on
experience in building production-grade CI/CD systems, aligning with industry
standards for modern DevOps workflows.

22
3. Contribution through Assignments, Feedback, and Level-Up Tests: I
performed well in periodic level-up assessments and mentor vivas, and consistently
submitted assignments before deadlines. I actively contributed feedback regarding
pipeline optimizations, security configurations, and improved Terraform workflows.

In some cases, my solutions were reviewed in group sessions to demonstrate efficient

approaches. This helped shape a more structured understanding for everyone involved
and allowed mentors to adjust training depth where needed.

4. Identifying and Fixing Common Issues in codebase: As interns progressed with

their tasks, I noticed common configuration issues in java and angular — such as
versioning errors, misconfigured secrets, or YAML syntax issues. I documented these
with resolution steps in a shared troubleshooting guide that became a quick resource
for many interns.

This proactive approach helped improve workflow efficiency and reduced repetitive
debugging queries to mentors.

5. Suggesting Improvements in Workflow and UI Feedback:

While I was not directly involved in frontend development tasks during the internship,
I actively contributed by offering usability feedback during the deployment and
demonstration stages of our applications. As I interacted with the codebase and
observed the outputs during testing and deployment, I identified areas where user
experience and clarity could be improved, especially for developers and reviewers
working with these automation workflows.

For instance, I suggested enhancements such as clearer formatting of error logs, so

that debugging issues became quicker and more intuitive. I also recommended more
descriptive labeling of automated build steps in the workflow outputs, ensuring that
each stage — such as testing, code analysis, packaging, or deployment — was easily
identifiable. These minor adjustments significantly improved the readability and
traceability of pipeline executions, allowing team members and mentors to monitor
progress and troubleshoot more efficiently.

23
Such feedback helped create a smoother experience for users interacting with the
automation systems, fostering better collaboration and understanding between
development and operations teams. This experience highlighted the importance of
paying attention to user-centric design even in backend and DevOps workflows,
where ease of use can directly impact productivity and communication.

6. Promoting a Culture of Timeliness, Clean Code, and Collaboration:

I consistently maintained disciplined timelines for all assigned tasks and deliverables
throughout the internship. By treating each assignment with a sense of responsibility
and urgency, I ensured that deadlines were met without compromising the quality of
work. I made a conscious effort to adopt and promote best practices in version control,
such as writing clear, meaningful commit messages, organizing commits logically,
and following a consistent formatting standard, especially in configuration files like
YAML. This not only made my own codebase easier to understand and maintain but
also set an example for my peers to emulate.

Over time, these practices began to influence the group culture positively. Fellow
interns and teammates started paying more attention to structured commits, well-
formatted code, and clearer documentation, leading to improved collaboration across
the board. I also placed strong emphasis on code hygiene, routinely reviewing my
scripts and configuration files for clarity and maintainability, and encouraging others
to do the same. My attitude toward peer learning and teamwork was evident in the
way I shared tips, helped others debug pipeline issues, and regularly participated in
team discussions with thoughtful inputs.

These efforts contributed to a more professional and productive environment, aligning

well with Nagarro’s values of collaboration, discipline, and continuous improvement.
Through these small but impactful practices, I was able to indirectly shape the
working tone of the internship program and demonstrate what it means to uphold
engineering excellence in a team-based setting.

24
CHAPTER 5: LEARNING AND DEVELOPMENT

During my internship at Nagarro as a javaTrainee, I gained a comprehensive mix of

technical expertise, professional skills, and practical insights into industry-standard
tools, processes, and team collaboration. The experience provided exposure to real-
time problem-solving and end-to-end project handling in a professional environment.

Below is a detailed account of the knowledge and skills acquired:

5.1 Technical Skills Acquired

 WebApp Development:
Gained an in-depth understanding of the Model-View-Controller (MVC)
architecture by actively working on full-stack web applications built using Java
(Spring MVC) and angular frameworks. This architectural pattern played a critical
role in organizing the application logic by separating responsibilities into three
interconnected components: the Model for handling business logic and data, the
View for managing user interface and presentation, and the Controller for
processing incoming requests and coordinating between Model and View. By
implementing and modifying real-world applications, I learned how this
separation of concerns enhances modularity, simplifies debugging, and promotes
better code reuse. It also made the applications more scalable and maintainable, as
each component could be developed and tested independently. Understanding and
applying the MVC design pattern laid a strong foundation for building clean,
structured, and enterprise-ready web applications.
 Scripting Knowledge:
Gained hands-on experience in writing Shell scripts (for Linux environments) and
PowerShell scripts (for Windows) to automate repetitive system tasks, CI steps,
and environment setup. This introduced me to scripting best practices and helped
streamline operations in the pipelines.
 Version Control Systems:
Became proficient in using Git for source code management and collaborative
development. Worked with both GitHub and GitLab, understanding branching

25
 strategies, pull requests, code merges, and issue tracking in distributed
development environments.
 Code Quality Management:
Integrated SonarCloud for static code analysis in CI pipelines and used Trivy and
Grype for container image vulnerability scanning. This helped in maintaining
code quality and security standards across applications before deployment.
 Package and Artifact Management:
Used JFrog Artifactory as a central artifact repository to store, manage, and
distribute build artifacts generated during the CI/CD process. This tool played a
crucial role in ensuring consistent versioning, traceability, and repeatable
deployments across different environments. By integrating Artifactory with build
tools like Maven for Java and MSBuild for .NET, I learned how dependencies are
resolved dynamically and how teams manage binary outputs such as .jar, .dll, and
Docker images. This experience gave me a clear understanding of artifact
lifecycle management, from creation to promotion and cleanup. It also
emphasized the importance of maintaining clean, structured repositories to avoid
dependency conflicts and ensure faster, more reliable software delivery. Overall,
working with JFrog Artifactory helped me appreciate how large-scale enterprise
software projects maintain control, security, and consistency in their deployment
pipelines.
 CI/CD Pipeline Development:
Built robust pipelines using GitHub Actions for .NET applications and Azure
DevOps for Java projects. These pipelines were configured to automate code
build, test, and deploy steps, promoting the DevOps principle of continuous
integration and delivery.
 Docker Containerization:
Learned to create Dockerfiles, build container images, and run applications in
isolated environments. Docker improved consistency between development,
testing, and production environments by packaging code along with dependencies.
 Container Orchestration with Kubernetes:
Deployed containerized apps using Kubernetes, which included writing
deployment and service YAML files, managing pods, scaling applications, and
ensuring high availability. This taught me how modern applications are deployed
and managed at scale in production.
26
 Infrastructure Provisioning with Terraform:
Applied Infrastructure as Code (IaC) concepts using Terraform to provision
Azure resources such as Azure Web Apps, Container Registry (ACR), and virtual
networks. This improved my understanding of reproducible and automated
infrastructure management.
 Configuration Management with Ansible:
Used Ansible playbooks for automating configuration tasks on remote servers,
reducing manual intervention and human error. This introduced me to agentless
configuration management and its role in maintaining server environments
consistently.

5.2 Professional and Soft Skills Developed

 Teamwork and Collaboration:

Worked in a highly collaborative and team-oriented setup where tasks were
distributed based on shared goals and timelines. Throughout the internship, we
engaged in regular stand-up meetings, brainstorming sessions, and sprint planning,
which fostered strong communication and alignment among team members. Code
was maintained in shared repositories, encouraging frequent code reviews and
constructive peer feedback. These practices not only helped improve code quality
but also enhanced my understanding of collective responsibility and version
control best practices. I learned the importance of maintaining clear and
comprehensive documentation, which ensured smooth handoffs and long-term
maintainability of our projects. The experience also taught me to navigate and
resolve conflicts respectfully and efficiently, fostering a culture of trust,
accountability, and teamwork — skills that are crucial for success in any
professional environment.
 Communication Skills:
Attended scheduled communication development sessions conducted by Nagarro.

27
CHAPTER 6: SUMMARY AND CONCLUSION

6.1 Summary
This internship at Nagarro as a DevOps Trainee proved to be a highly enriching and
transformative journey, bridging the gap between academic learning and practical
industry application. Over the course of the internship, I was immersed in real-world
software delivery environments where I applied my theoretical understanding of
DevOps concepts to actual enterprise-grade projects. This hands-on experience
allowed me to witness firsthand how large-scale software systems are built, tested,
deployed, and maintained using modern DevOps methodologies.

The core objective of my project — “Java & .NET MVC WebApp CI/CD & Code
Quality Management” — centered around streamlining and automating various
phases of the software development lifecycle. From continuous integration and
automated testing to secure and scalable deployments, I built and managed workflows
that ensured smooth delivery pipelines across both Java (Spring MVC) and .NET
MVC applications. This required the integration of a wide array of powerful tools and
technologies, including GitHub, GitLab, Azure DevOps for version control and
pipeline orchestration; Docker and Kubernetes for containerization and orchestration;
Terraform and Ansible for infrastructure provisioning and configuration; and
SonarCloud, Grype, Trivy, and JFrog Artifactory for maintaining code quality,
security, and artifact management.

Through repeated practice and real-time problem-solving, I gained confidence and

expertise in designing CI/CD pipelines, writing infrastructure-as-code templates,
managing containerized workloads, and embedding security and quality checks into
the workflow. I also learned how to maintain traceability, monitor pipeline
performance, and collaborate effectively with cross-functional teams.

This internship not only enhanced my technical skills but also gave me valuable
exposure to industry-level practices and expectations. It deepened my understanding
of how DevOps facilitates faster, more reliable software delivery and helped me build
a solid foundation for my future in this field. I now feel more equipped and motivated

28
to take on real-world challenges and continue my journey as a future DevOps
engineer.

6.2 Conclusion
The internship experience significantly contributed to both my technical and personal
development. I improved in areas such as teamwork, communication, time
management, and problem-solving — all essential for success in a collaborative tech
environment. Regular assessments, mentor vivas, presentations, and assignment
deadlines created a structured and growth-oriented learning environment.

This internship served as a strong foundation for launching my career in DevOps and
cloud engineering. It allowed me to transition from an academic learner to an
industry-ready professional, confident in applying technical skills and collaborating in
real-world settings. I now feel prepared to contribute meaningfully in a dynamic and
innovation-driven organization like Nagarro or similar workplaces.

CHAPTER 7: SUGGESTIONS FOR THE

IMPROVEMENT

While the internship at Nagarro was an excellent learning experience, it also helped
me identify several areas where I can personally improve to grow further as a DevOps
engineer:

- Strengthening Core Programming Skills:

Although my internship at Nagarro was centered around bestpractices, I came to

understand the critical role that strong backend development skills play in
resolving deployment issues. In many scenarios, debugging deployment errors
required a clear understanding of the underlying Java or C# code. Gaining deeper
expertise in these programming languages would empower me to not just deploy
and manage applications but also to better analyze failures, optimize code
performance, and contribute meaningfully during troubleshooting. Strengthening
my programming foundation will enable me to bridge the gap between
development and operations more effectively.
29
- Improving Scripting Efficiency:

Throughout the internship, I worked with scripting languages like Shell and
PowerShell to automate various tasks, such as deployment and system
configuration. While I became comfortable with the basics, I recognized the need
to write cleaner, more modular scripts that can be reused across different projects.
Writing efficient scripts is a vital skill, as it forms the basis of automation. In the
future, I plan to study scripting best practices, explore advanced scripting use-
cases, and practice writing scripts that are both scalable and easy to maintain.

- Enhancing Cloud Platform Expertise:

I gained practical hands-on experience with Microsoft Azure during my

internship—provisioning resources, managing deployments, and integrating
services. However, I realized that to be a truly flexible and well-rounded java
engineer, I must broaden my knowledge across multiple cloud providers.
Exploring platforms like AWS and Google Cloud will help me understand diverse
cloud-native tools and features, making me adaptable to different organizational
preferences. This cloud-agnostic approach is essential for designing robust
solutions in multi-cloud or hybrid cloud environments.

- Mastering Monitoring and Logging Tools:

While I gained solid hands-on experience in Continuous Integration, Continuous

Deployment (CI/CD), and automating application delivery pipelines, I realized
that an equally critical part of the DevOps lifecycle — system monitoring, log
management, and real-time alerting — remained relatively unexplored during the
internship. These components play a vital role in maintaining the health and
performance of production systems, detecting issues early, and ensuring quick
response times. To bridge this gap, I plan to proactively learn and work with
widely-used observability tools such as Prometheus for metrics collection,
Grafana for interactive visualization and dashboards, and the ELK stack
(Elasticsearch, Logstash, and Kibana) for centralized log aggregation and analysis.
Developing skills in these tools will help me ensure operational visibility, system

30
 reliability, and performance optimization — completing the end-to-end DevOps
toolchain and making me better equipped to manage real-world production
environments.

- Better Time Estimation and Prioritization:

Managing multiple assignments with tight deadlines taught me the importance of

estimating task durations realistically. I aim to improve my ability to prioritize
tasks and avoid last-minute pressure.

- Improving Communication in Technical Discussions:

I participated in presentations and communication sessions, but I feel there's room

for improvement in confidently explaining complex concepts to both technical and
non-technical audiences.

- Gaining More Depth in Infrastructure Tools:

I worked with Terraform and Ansible, but mostly at an introductory level. I aim to
build more complex infrastructure-as-code setups and configuration automation in
my future learning.

- Regular Self-Evaluation:

The level-up tests and mentor vivas highlighted the importance of regular self-
assessment. I plan to incorporate weekly learning reviews and personal check-ins
to stay consistent with progress.

31
 References

- · Oracle Java Documentation - https://docs.oracle.com/en/java/

- · OpenJDK Documentation - https://openjdk.org/

- · Java Design Patterns - https://java-design-patterns.com/

- · Baeldung Java Tutorials - https://www.baeldung.com/category/java/

- · Spring Framework Documentation - https://docs.spring.io/spring-

framework/reference/

- · Spring Boot Reference Guide - https://docs.spring.io/spring-

boot/docs/current/reference/htmlsingle/

- · Spring Security Documentation - https://docs.spring.io/spring-

security/reference/

- · Spring Data JPA Documentation - https://docs.spring.io/spring-

data/jpa/docs/current/reference/html/

- · Spring Cloud Documentation - https://docs.spring.io/spring-

cloud/docs/current/reference/html/

- · Angular Official Documentation - https://angular.io/docs

- · Angular Material - https://material.angular.io/

- · Angular CLI Documentation - https://angular.io/cli

- · Angular Testing Guide - https://angular.io/guide/testing

- · RxJS Documentation - https://rxjs.dev/guide/overview

- · Apache Maven Documentation - https://maven.apache.org/guides/

- · Maven Central Repository - https://search.maven.org/

- · Maven Plugins Documentation - https://maven.apache.org/plugins/

32
- · Maven Surefire Plugin - https://maven.apache.org/surefire/maven-surefire-
plugin/

- · Maven Dependency Plugin - https://maven.apache.org/plugins/maven-

dependency-plugin/

- · Hibernate ORM Documentation - https://hibernate.org/orm/documentation/

- · Hibernate Validator Documentation -

https://hibernate.org/validator/documentation/

- · Hibernate Search Documentation - https://hibernate.org/search/documentation/

- · JPA Specification - https://jakarta.ee/specifications/persistence/

- · Spring Boot with Docker - https://spring.io/guides/topicals/spring-boot-docker/

- · Angular Docker Deployment - https://angular.io/guide/deployment

- · JHipster (Java Hipster) - https://www.jhipster.tech/documentation-archive/

- · Jenkins Pipeline for Java/Spring - https://www.jenkins.io/doc/tutorials/build-a-

java-app-with-maven/

- · SonarQube for Java/TypeScript - https://docs.sonarqube.org/latest/

- · JUnit 5 Documentation - https://junit.org/junit5/docs/current/user-guide/

- · Mockito Documentation - https://javadoc.io/doc/org.mockito/mockito-

core/latest/org/mockito/Mockito.html

- · TestNG Documentation - https://testng.org/doc/documentation-main.html

- · Jasmine Testing Framework - https://jasmine.github.io/

- · Karma Test Runner - https://karma-runner.github.io/

- · Swagger/OpenAPI - https://swagger.io/docs/

- · Spring REST Docs - https://docs.spring.io/spring-

restdocs/docs/current/reference/html5/
33
- · Pluralsight Spring Path - https://www.pluralsight.com/paths/spring-framework

- · LinkedIn Learning Java Courses -

https://www.linkedin.com/learning/topics/java-development

- · Udemy Spring Boot & Angular - https://www.udemy.com/topic/spring-boot/

- · Manning Publications Books - https://www.manning.com/

- · Packt Publishing - https://www.packtpub.com/

- · Stack Overflow - https://stackoverflow.com/

- · Spring Forum - https://forum.spring.io/

- · Angular Community - https://angular.io/community

- · Dev.to Java Community - https://dev.to/t/java

- · Hibernate Community - https://hibernate.org/community/

34