Introduction :

My name is Poojitha , and I’ve been working as a Full Stack Java Developer for the past 3+ years.
I’m really passionate about building robust and scalable applications, and I love working with
technologies like Java, Spring Boot, Azure, React, and Angular. I enjoy the challenge of designing
solutions that not only solve complex problems but also provide a great user experience.
In my most recent role at Cardinal Health, I was part of a team that developed and maintained
microservices-based applications using Spring Boot on the backend and React on the frontend.
We focused on creating RESTful and SOAP APIs for seamless integration between different
systems. I worked closely with cross-functional teams, including product managers and
architects, to deliver high-quality solutions. One of the highlights was optimizing the database
schema using Hibernate and Oracle, which helped us improve query performance tuning by
30%.
I’m also quite experienced with setting up and managing CI/CD pipelines. At Cardinal Health, I
integrated Jenkins, SonarQube, GitHub, and Slack to automate our build, test, and deployment
process. This not only sped up our release cycles but also ensured consistent code quality across
multiple teams. I really enjoyed the challenge of streamlining the deployment process and
seeing how automation positively impacted our productivity.
Besides the technical side, I value collaboration and open communication. I believe the best
solutions come from teamwork and diverse perspectives, and I always try to bring that mindset
to my work.
I’m really excited about this opportunity because it aligns perfectly with my background in Java,
Spring Boot, and Full Stack Development, and I’m eager to contribute to your team’s success. I’m
looking forward to learning more about the role and how I can add value to your organization.
Thank you for having me today!"

Cardinal Health:
My project at Cardinal Health was about developing a Claims and Insurance
Management System designed to streamline the entire claims processing
workflow. The main objective was to ensure that insurance claims were
processed accurately and efficiently, minimizing manual intervention and
reducing errors. This system managed everything from claim submission and
verification to approval and settlement, providing real-time updates and
notifications to users.
It was particularly beneficial to both customers and internal teams.
Customers experienced a faster and more transparent claims process, enhancing
their overall satisfaction and trust. They could easily submit claims, track the
status in real-time, and receive timely notifications about approvals or additional
requirements. For internal teams, such as claims adjusters and customer
support, the system provided better visibility and control over claims, enabling
them to manage verification, approval workflows, and settlements efficiently.
Additionally, the system integrated seamlessly with existing platforms, ensuring
consistent and accurate data across all departments. Overall, this project
significantly improved operational efficiency and customer experience in the
claims and insurance domain for Cardinal Health.
Roles and responsibilities:
At Cardinal Health, my day-to-day responsibilities as a Full Stack Java
Developer involved a mix of development, collaboration, and deployment tasks.
I started my day by reviewing JIRA tickets to prioritize tasks, which typically
included feature development, bug fixes, or optimizing existing functionalities. I
worked on building and maintaining Spring Boot microservices on the
backend and React components on the frontend, ensuring seamless
integration and high performance.
I was actively involved in designing and consuming RESTful and SOAP APIs for
communication between microservices and with legacy systems. This required
close collaboration with cross-functional teams, including product managers,
architects, and frontend developers, to understand requirements and design
scalable solutions. I participated in daily stand-up meetings to provide updates
on my progress and discuss any blockers.
A significant part of my role was focused on database schema design and
optimization using Hibernate and Oracle. I spent time analyzing query
performance and implemented composite indexes to optimize complex joins
and queries, which enhanced application performance by 30%. I also ensured
data integrity and efficient data storage through proper entity mapping and
relationships.
To maintain high code quality, I followed Test-Driven Development (TDD)
practices, writing unit tests using JUnit and Mockito for backend microservices,
and Jest for React components. I made it a point to write tests before coding
new features, ensuring that all edge cases were covered. Once development and
testing were done, I pushed the code to GitHub and created pull requests for
peer reviews.
I was responsible for managing the CI/CD pipelines using Jenkins and
SonarQube. I configured automated builds, static code analysis, and
deployment pipelines, ensuring a smooth and efficient deployment process. I
integrated Slack for real-time notifications on build statuses, allowing the team
to respond quickly to any issues. This automation reduced deployment cycles by
40% and maintained high code quality standards.
Additionally, I managed web servers like Tomcat and WebSphere for
application deployment and monitoring. I regularly checked server logs and
performance metrics to ensure high availability and security compliance. I also
handled server configurations, SSL certificates, and load balancing to maintain
optimal performance and security.
Overall, my daily routine was a mix of coding, collaboration, testing, and
deployment, ensuring that the applications were scalable, maintainable, and
high-performing while meeting business requirements and timelines."
HerbaLife:
At Herbalife, my project was focused on developing a Scalable E-Commerce
Platform that streamlined the ordering process for distributors and customers.
The primary goal was to enhance user experience and operational efficiency by
automating order management, inventory tracking, and payment processing.
The system handled high volumes of transactions while ensuring accurate order
fulfillment and seamless integration with existing CRM systems.
This platform significantly benefited both distributors and internal teams.
Distributors could easily place orders, track shipments in real-time, and access
personalized offers, which improved their purchasing experience and increased
customer retention. For internal teams, such as inventory managers and
customer service representatives, the system provided better visibility and
control over stock levels, order processing, and customer interactions. It
minimized manual tasks, reduced errors, and optimized workflow efficiency.
Additionally, the platform offered powerful reporting and analytics, enabling the
business to make data-driven decisions. Overall, this project improved
operational efficiency, enhanced user satisfaction, and contributed to the growth
of Herbalife's e-commerce ecosystem

Roles and responsibilities :

"At Herbalife, my daily role as a Full Stack Developer involved building and
maintaining the e-commerce platform used by distributors and customers for
ordering and inventory management. I started each day by checking JIRA tickets
to prioritize tasks, which included adding new features, fixing bugs, and
optimizing existing functionalities. I worked closely with product managers,
designers, and backend teams to understand requirements and deliver solutions
that enhanced the user experience.
I developed APIs to connect the frontend with backend systems, ensuring real-
time updates for orders and inventory levels. I also integrated the platform with
CRM systems to provide personalized offers and better customer insights. I
focused on optimizing inventory management to reduce errors and improve
efficiency. I followed Test-Driven Development (TDD) practices to ensure high
code quality and participated in code reviews for maintaining clean and
maintainable code.
I managed CI/CD pipelines for automated builds, testing, and deployments,
enabling quick and reliable updates. I also monitored system performance to
identify and fix issues, ensuring the platform was fast and reliable. My daily
routine was a mix of coding, collaborating with the team, testing, and deploying
new features, all aimed at delivering a seamless user experience."
 While building and deployment of scripts while in the CI/CD pipelines we
will use python often like for automating build and deployment task
 Object Oriented design principles –
 Single Responsibility Principle (SRP) - maintained and enhanced
enterprise services and applications using domain-driven design and test-
driven development, which inherently follows SRP
 Open/Closed Principle (OCP) - Implementing new features or
enhancements to existing microservices at Cardinal Health while keeping
the core application logic unchanged demonstrates OCP.
 Can we use multiple OOD, yes, we can use it for example like
Creating Controller classes responsible only for handling HTTP requests
(SRP).
Using Service classes for business logic, ensuring you can add new
features without modifying existing services (OCP).
 Databases:
Oracle - Oracle is a Relational Database Management System (RDBMS)
that uses Structured Query Language (SQL) for defining and manipulating
data and also supports ACID properties
Usage in Your Projects:
 You designed and optimized database schemas using Oracle in Cardinal
Health, ensuring efficient data persistence and query performance tuning.
 You likely wrote SQL queries for CRUD (Create, Read, Update, Delete)
operations and utilized Hibernate for Object-Relational Mapping.
PostgreSQL: Open-Source Relational Database that also uses SQL for
querying and managing data and supports ACID properties, JSON support
and also allow it to stor semi structure data
Usage in Your Projects:
 In your Herba Life project, you likely used PostgreSQL for database
operations, leveraging its advanced querying capabilities and integrations
with Spring Boot and Hibernate.
Query Performance Tuning:
 It enhances application responsiveness and user experience and It reduces
load on database servers, improving scalability and efficient resource
utilization, especially in production environments.
 Where You've Used It:
 In your Cardinal Health project, you designed and optimized database
schemas using Hibernate and Oracle, ensuring query performance
tuning for efficient data persistence.
 In Herba Life, you utilized PostgreSQL and likely optimized complex
queries for better performance.
NO SQL Databases:
CosmosDB
You can use the Spring Data CosmosDB library to integrate CosmosDB with
your Spring Boot application and It allows for CRUD operations, indexing, and
query execution using Java-based repositories.
Example:
I have hands-on experience with NoSQL databases, particularly Cassandra,
where I optimized query performance and designed scalable data models. I
understand the NoSQL paradigm, including schema flexibility, partitioning,
and consistency models, which are fundamental to CosmosDB as well. With
my background in Spring Boot and cloud platforms, I can easily adapt to
CosmosDB’s APIs and leverage its global distribution features.
AZURE:
"I have extensive experience deploying Spring Boot microservices and React
frontends using Cloud Foundry. I understand the cloud-native principles of
scalability and high availability, which align well with Azure's offerings. I am
particularly interested in leveraging Azure App Services and Azure Functions
for serverless architectures, while utilizing CosmosDB for scalable NoSQL
storage. Additionally, my experience with CI/CD pipelines in Jenkins will
enable me to seamlessly adapt to Azure DevOps for automated deployment
workflows.
FaaS (Function as a Service)
Developers write a small single-purpose functions which are deployed to the
FaaS platform and those functions are executed in response to specific events
like HTTP requests, database changes, scheduling events, message from
queues
"I have extensive experience with Spring Boot microservices, and I see Azure
Functions as a powerful extension for serverless event-driven architectures.
For example, in my previous project, I could have used Azure Functions for
processing asynchronous tasks like sending notifications or processing data
uploads. Its integration with CosmosDB would allow me to build scalable, real-
time applications with minimal infrastructure management."
MOCKITO:
"In my role at Cardinal Health, I used Mockito extensively for unit testing
Spring Boot microservices. I mocked service dependencies and database
interactions to ensure isolated tests, achieving high code coverage and
reliable builds. For example, I used @MockBean with MockMvc to test REST
endpoints without hitting the actual database, ensuring faster execution and
consistent test results."

Domain Driven Design (DDD):

A conceptual model of the business domain with real-world entities and
relationships, for example in e-commerce applications, entities could be
order, customer and product
Test-Driven Development (TDD):
Tests are written before writing the actual code, here development is done is
short cycles like write a failing test, write the minimum code required to pass
the test.
"At Cardinal Health, I maintained and enhanced enterprise services using
Domain-Driven Design, ensuring that the business logic was modeled closely
with the domain requirements. I designed entities, value objects, and
repositories following DDD patterns in Spring Boot. Additionally, I followed
Test-Driven Development practices, writing unit tests with Mockito before
implementing features, which improved code reliability and maintainability. I
integrated these tests into CI/CD pipelines using Jenkins and SonarQube,
ensuring high test coverage and code quality."
REST/SOAP:
Collaborated with cross-functional teams to design and implement RESTful
APIs using Spring Boot and JSON for seamless integration between
microservices.
Built and consumed SOAP web services using Spring Boot and WSDL for
integrating with legacy systems.
Used XML for request and response payloads, ensuring compatibility with
enterprise systems.
"At Cardinal Health, I built RESTful APIs using Spring Boot and JSON for
seamless integration between microservices. Additionally, at Herba Life, I
developed SOAP web services using WSDL and XML to integrate with legacy
systems, ensuring secure and reliable communication."
Hibernate and Oracle:
"In summary, my role at Cardinal Health involved designing and optimizing
database schemas using Hibernate and Oracle to ensure efficient data
persistence and high-performance query execution. I collaborated closely with
database administrators and frontend teams to design scalable solutions,
implemented indexing strategies, and leveraged Hibernate's advanced ORM
capabilities. My experience in query performance tuning and efficient data
modeling has consistently contributed to improved system scalability and
user satisfaction."
DevOps Tools:
 Configured Jenkins Pipelines (Declarative and Scripted) for automating the CI/CD
process.
Automated the building and testing of Spring Boot microservices and React/Angular
frontends.
Integrated with GitHub for source code management and triggering builds on code commits.
Deployed applications to Cloud Foundry and Docker containers using Jenkins.
Ensured consistent code quality by integrating SonarQube for static code analysis.
Jenkins:
At Cardinal Health, I used Jenkins to automate the CI/CD pipelines for Spring
Boot microservices and React frontends. I configured Declarative Pipelines to
trigger builds on every commit to the main branch in GitHub. The pipeline
included stages for code compilation, unit testing, static code analysis using
SonarQube, and deployment to Cloud Foundry. Additionally, I integrated
Jenkins with Slack to notify the team about build statuses and deployment
progress. This automation reduced manual intervention and deployment time
by 40%, ensuring faster delivery cycles.
SonarQube: (Static code analysis tool that checks code quality and
security vulnerabilities.)
I integrated SonarQube into the CI/CD pipelines using Jenkins to ensure high
code quality and security. By configuring Quality Gates, I enforced coding
standards, code coverage, and security checks. For example, I set a rule that
blocked deployments if the code coverage dropped below 80% or if any
critical vulnerabilities were found. This approach helped us maintain clean
code practices and improved overall code quality across multiple teams.
Slack: (Communication and collaboration platform for team
notifications.)
I integrated Slack with Jenkins to enhance team communication and
collaboration. I configured Slack Webhooks to send real-time notifications
about build statuses, code quality analysis results from SonarQube, and
deployment progress. This enabled the team to quickly respond to build
failures and deployment issues, ensuring faster turnaround times and
improved team productivity.
Tomcat:
At Cardinal Health, I managed application deployments on Apache Tomcat
for multiple Spring Boot microservices and REST APIs. I configured context
paths and server ports for isolated microservices deployment, ensuring
zero downtime during updates. I also secured application endpoints by
configuring SSL/TLS certificates and enforced security constraints in
[Link]. Additionally, I monitored application performance using JMX and
Tomcat Manager to identify and resolve memory leaks and slow response
times, optimizing server resources and ensuring high availability
IBM WebSphere: (is a Java EE application server designed for
Enterprise-grade applications for hosting java EE application)
Deployed Java EE applications on IBM WebSphere for high availability and
enterprise-level performance.
"At Herba Life, I deployed enterprise-grade Java EE applications on IBM
WebSphere, ensuring high availability and security. I configured JNDI for
database connection pooling, optimizing resource utilization and
improving application performance. To achieve scalability, I set up
WebSphere Clustering with load balancing, enabling seamless failover and
zero downtime deployments. Additionally, I used the WebSphere
Integrated Solutions Console for managing deployments, monitoring
server health, and configuring security settings with LDAP integration. I
also automated deployments using Jenkins integrated with WebSphere."
Nexus Repository: (Nexus Repository is a repository manager)
Centralized Storage: Stores and manages all build artifacts and dependencies
in one place.
Artifact Storage: Stores build artifacts (e.g., JARs, WARs, Docker images) for
versioning and reuse.
Stores, organizes, and distributes software components, binaries, and
artifacts.
Manages dependencies required by builds,
At Cardinal Health, I integrated Nexus Repository with Jenkins CI/CD pipelines
to manage dependencies and store build artifacts for Spring Boot
microservices and React applications. I configured Maven to fetch
dependencies from Nexus, ensuring version consistency across builds. During
the CI pipeline, build artifacts, including JARs and Docker images, were
automatically published to Nexus, enabling version control and consistent
deployments. Additionally, I set up proxy repositories for Maven Central and
[Link], reducing build times by caching dependencies locally. This
streamlined our CI/CD pipelines, reducing build times by 30% and ensuring
reproducible builds.