Name

Sr Java Full Stack Developer

Contact:
E-mail:

PROFESSIONAL SUMMARY

Over 10+ years of experience in Senior Java Full Stack Developer with an ability to handle any part of the process efficiently. To
succeed in an environment of growth and excellence and let me work on the leading areas of technology, a job that gives me
opportunities to learn, innovate and enhance my skills and strengths in conjunction with organization goals and objectives.

● Extensive experience in developing web applications using HTML5, XML, XHTML, DHTML, CSS, CSS3(Sass, Less), Bootstrap,
JavaScript, DOM, jQuery, Ajax, JSON, and JSP.
● Delivered scalable solutions across automotive platforms using full stack technologies including Java, Angular, Node, and
React.
● Delivered scalable microservices using Java and Spring Boot across cloud-native environments. Built event-driven backend
workflows leveraging AWS Lambda, S3, and SQS.
● Developed asynchronous messaging architectures using Kafka and RabbitMQ for decoupled service communication.
● Applied Test Driven Development using JUnit and Mockito for highly testable service layers. Migrated monolithic systems
to cloud-first architectures on AWS with containerized deployment.
● Engineered secure APIs using Spring Security with role-based access and OAuth2 integration. Designed and implemented
RESTful services for payment gateway and wallet processing applications.
● Automated deployments and build pipelines using Jenkins and integrated DevSecOps practices.
● Used PL/SQL and Postgres for optimized data operations in high-volume transaction systems. Maintained cloud-native
infrastructure using Kubernetes and Helm across hybrid environments.
● Integrated Spring Batch for scheduled processing of financial data and reports. Worked on multi-cloud solutions with both
AWS and GCP services to meet varied customer needs. Implemented structured logging and monitoring strategies for
production-grade APIs.
● Designed microservice APIs with bounded-context modeling for business domain alignment. Led API versioning and
backward compatibility efforts during rapid product evolution cycles.
● Developed Docker-based services deployed into OpenShift clusters with robust health checks. Built real-time reporting
modules using streaming data pipelines connected to Kafka. Integrated Redis and in-memory caching layers to reduce
latency in user-facing APIs.
● Created dynamic configuration management for Java services using Spring Cloud Config. Participated in chaos testing with
tools like Gremlin to assess service resilience. Contributed to secure data exchange workflows using encrypted S3 buckets
and signed URLs.
● Delivered cloud-ready Java apps with low cold-start times using optimized dependency loading. Defined CI/CD workflows
with Jenkins to support blue-green deployments and rollback strategies.
● Analyzed slow database queries and optimized PL/SQL routines for time-sensitive processes. Wrote Maven and Ant build
scripts to streamline legacy and modern codebase integration.
● Conducted API load testing using JMeter and integrated performance benchmarks into QA cycles. Worked in agile teams
to deliver sprint-based feature releases and hotfixes in production. Guided container hardening efforts and implemented
Helm-based deployment practices.
● Supported wallet, payments, and digital transaction logic with secure and auditable workflows.
● Created reusable Spring components for logging, error handling, and service communication.
● Improved platform resilience through Kafka-driven workflows, ensuring critical patient data events were processed
reliably and asynchronously.
● Authored secure and efficient JavaScript logic on the client side to support real-time interaction within high-availability
healthcare tools.
 ● Architected middleware in Node to abstract and normalize GraphQL data responses for frontend teams working on
personalization and search.

TECHNICAL SKILLS

Programming Languages C, Java, JavaScript, PHP, R, python, PL/SQL, Kotlin, UNIX Shell Script, C#/.NET Core

Java/J2EE Technologies Servlets, Spring, JPA, JTA, JDBC, JSP, JSTL, RMI, Applets.

Frameworks Struts 2.5, Hibernate 5.x, Spring 5.0, Spring Batch, Spring Security, Spring AOP, Spring Core,
Spring IOC, JSF.

Web Technologies HTML, HTML5, CSS/CSS3, AJAX, JQuery, Bootstrap, XML, Grunt, Gulp, JSON.

Database PLSQL, SQL Server, MySQL, Oracle, MongoDB, DB2, Cassandra, Firebase

JavaScript Frameworks AngularJS, Angular 8, JQuery, [Link], [Link], [Link], [Link], [Link].

Web Services XSD, WSDL, Apache Axis, SOAP, Restful, GraphQL, JAX RS, JAX WS

Messaging JMS (Java Message Service), IBM MQ, Apache Active MQ, Apache Kafka.

Web Application Servers Oracle WebLogic 10.x/9.x, IBM WebSphere 8.x/6.x, Apache Tomcat 8.0/7.x/6.x.

Methodologies Agile, Waterfall, OOAD, SCRUM.

Testing Tools JUnit, Mockito, Jasmine, Karma, Mocha, Chai, Selenium, Jest, Cypress, unittest

Version Control SVN, CVS, GIT, Jenkins and Clear Case,

Build Tools Maven, Gradle, ANT

IDEs Eclipse IDE, RAD 6.0/7.0, Intellij IDEA, Spring Tool Suite (STS).

Operating Systems Windows, Linux, and UNIX

Software Visual Studio, Rational Rose, and Microsoft Office

EDUCATION DETAILS

PROFESSIONAL EXPERIENCE

Client: Optum- Reston, VA. Sep 2022 –

Present
Sr Java Full Stack Developer
Responsibilities
● Involved in Software Development Life Cycle for gathering requirements, Analyzing, Designing, Developing and Testing
applications using Agile methodology.
● Created and deployed high-performance microservices using Spring Boot and core Java, supporting financial transactions in
digital payment systems.
● Built serverless functions with AWS Lambda and integrated them with SQS and S3 for event-driven backend workflows.
● Implemented fault-tolerant services by applying bounded-context principles, custom exception handling, and standardized
logging across APIs.
● Developed robust Kafka consumers and publishers to enable real-time streaming between services in a transaction-heavy
environment.
● Automated test coverage using JUnit within a TDD workflow, ensuring early detection of issues and production stability.
● Worked with Maven and Ant to manage builds and dependencies across multi-module Spring Boot projects.
● Migrated legacy services to AWS-native solutions, improving scalability and operational efficiency in cloud environments.
 ● Designed APIs with a focus on reusability and compliance, adhering to modern API integration patterns and OAuth2
security.
● Containerized Java services using Docker and deployed them on Kubernetes clusters within OpenShift for enhanced
portability.
● Orchestrated deployment pipelines using Jenkins and integrated DevSecOps checks to enforce secure code standards.
● Built and maintained applications running on both Tomcat and WebSphere, ensuring compatibility with legacy and modern
environments.
● Optimized SQL queries and stored procedures in Oracle and Postgres for high-volume workloads, using RDS in AWS for
managed operations.
● Applied chaos engineering principles using tools like Gremlin to simulate failures and validate service resilience.
● Implemented data transformation pipelines using Spring Batch for scheduled processing of large transaction datasets.
● Created secure integrations between services using Spring Integration, ensuring message delivery guarantees and
observability.
● Deployed applications on Red Hat Enterprise Linux (RHEL) servers with Helm for release management on Kubernetes.
Integrated monitoring and alerting tools with cloud-native services, ensuring visibility into Lambda functions and SQS
queues.
● Automated warranty processing logic using Java-based services, reducing manual interventions and error rates across
dealerships.
● Migrated legacy systems into Salesforce CRM, including mapping data models and integrating external APIs for real-time
sync.
● Built monitoring and health-check features into backend APIs, ensuring system resilience under peak usage. Practiced
continuous integration and deployment pipelines, enabling faster feedback and quicker production releases.
● Revamped key customer engagement features using React with dynamic component-driven architecture, resulting.
● Collaborated with architects to design OOP-compliant, modular components aligned with microservice design strategies.
● Designed solutions with multi-cloud compatibility, leveraging features from both AWS and GCP for different services.
● Enhanced performance using Gatling load testing and fine-tuned thread configurations to support high-concurrency APIs.
● Integrated Salesforce into legacy backend systems as part of an enterprise-wide migration project in the automotive
domain.

● Designed and implemented full-stack modules using Angular and Spring Boot, integrating MongoDB collections with RESTful
APIs for scalable and responsive applications.
● Deployed and optimized AWS workloads (EC2, S3, RDS, Lambda, API Gateway) to support microservices, ensuring security,
high availability, and cost efficiency.
● Developed backend services with C#/.NET Core, integrating APIs and ensuring seamless interoperability with existing Java
and Python components.
● Deployed applications on Azure cloud using App Services, Azure Functions, and Key Vault, implementing monitoring and
scaling strategies for enterprise workloads.
● Integrated Kong API Gateway and Solace event broker to streamline external partner communication and enhance system
resilience for high-volume event handling.
● Automated CI/CD pipelines using Harness with integrated SonarQube, JUnit, and JMeter for continuous testing, code quality
validation, and zero-downtime deployments.
● Leveraged GitHub Copilot to accelerate development in Java 17, implementing modular design and improving productivity
for microservice builds.

Client: Fanniemae, Plano, TX. Nov 2020 to Aug 2022

Java Full Stack Developer
Responsibilities
● Extensively worked in writing minimal code in building re-usable forms with their validations using REACT with Redux
Architecture.
● Refactored backend components into cloud-native Java services using Spring Boot, ensuring scalability and fast startup
times in production.
● Leveraged AWS S3 for handling large-scale file storage in event-driven pipelines and integrated lifecycle policies for cost
optimization.
 ● Built Lambda-based microservices triggered by SQS events, enabling asynchronous processing across distributed systems.
● Designed and deployed PL/SQL scripts and stored procedures in Postgres and Oracle, enhancing data integrity in financial
applications.
● Configured and managed Kubernetes deployments on OpenShift, ensuring high availability of mission-critical backend APIs.
● Automated application packaging using Docker and Helm, streamlining CI/CD workflows in Jenkins-based pipelines.
● Worked on RabbitMQ-based messaging systems for async communication between Java microservices, improving system
decoupling.
● Conducted API performance tuning using JMeter to identify latency bottlenecks in payment processing flows.
● Enforced secure access patterns in REST APIs using JWT and integrated role-based authorization mechanisms for sensitive
endpoints.
● Migrated on-prem legacy Java systems to containerized environments running on AWS ECS and EKS clusters. Collaborated
with security teams to integrate static and dynamic analysis tools into DevSecOps pipelines using Jenkins.
● Wrote robust unit and integration tests for complex business logic using JUnit and Mockito, aligned with TDD practices.
● Maintained strong version control and artifact handling through Maven, applying custom build profiles for different
environments.
● Developed reusable utilities in core Java for JSON parsing, data transformation, and service-to-service communication. Built
data sync solutions between transactional databases and NoSQL stores for caching and fast-access layers.
● Deployed resilient microservices with graceful fallback handling using circuit breakers and retry logic.
● Introduced Spring State Machine into the payment approval workflow to track transaction lifecycles and handle state
transitions.
● Participated in chaos engineering simulations using Litmus to ensure fault tolerance in payment gateway APIs. Integrated
cloud-native monitoring and alerting for AWS resources like Lambda, RDS, and S3, ensuring operational visibility.
● Actively contributed to design discussions, offering expertise in object-oriented programming and microservices
orchestration across domains.
● Built responsive UI elements using Angular 10+ for enterprise healthcare dashboards, improving usability and client
satisfaction across multiple platforms.
● Built responsive, interactive modules using Angular and React to streamline dealer onboarding in a multi-brand automotive
platform.
● Integrated backend APIs with frontend layers in a [Link] environment, ensuring seamless interaction between services.
● Led modernization efforts by redesigning outdated workflows and interfaces for better maintainability and performance.

● Collaborated with UI/UX designers and QA teams to deliver user-centric features, applying performance tuning, debugging,
and CI/CD practices using Jenkins, Docker, and Kubernetes.
● Validated UI components with Jest and Cypress, automating unit and end-to-end tests to improve reliability and reduce
regression defects.
● Built Python utilities with test coverage through unit-test, streamlining data validation and workflow automation in
distributed systems.
● Designed and deployed Kong-based API management solutions to handle external integrations, enabling secure routing and
versioned API lifecycle management.
● Implemented Solace event streaming alongside Kafka to ensure reliable, low-latency communication between distributed
services.
● Enhanced the CI/CD pipeline with Harness, integrating SonarQube quality gates and automated JUnit/JMeter testing for
robust and compliant releases.

Client: Casey’s, Ankeny, IA. April 2019 to Oct

2020
Java Full Stack Developer
Responsibilities
● Implemented web interface (UI) for end-users using AngularJS, which has migrated from the existing BackBone JS
application.
● Effectively used Angular Directives, filters, declarative templates, service providers, and context-aware communication.
 ● Took ownership of module-level design using DDD concepts, organizing bounded contexts and aligning implementation
with domain logic.
● Rewrote key warranty modules for a high-volume automotive client using Java and multithreaded patterns, significantly
enhancing system throughput.
● Refactored dealer management workflows in React and Angular to align with modern user interface standards and improve
maintainability.
● Coordinated closely with cross-functional teams and non-technical stakeholders during the Salesforce migration phase,
ensuring smooth adoption of new systems.
● Contributed to the design and implementation of microservice components that supported vehicle service history tracking
across dealerships.
● Translated legacy business rules from traditional platforms into scalable APIs using [Link] and Express, reducing service
downtime.
● Led modernization of critical automotive backend systems by replacing monolithic structures with modular service-oriented
architecture.
● Worked in agile teams to iteratively enhance applications focused on dealer interactions and service network integrations.
● Developed and optimized RESTful APIs used by third-party automotive partners, supporting real-time data access and
transaction processing.
● Actively participated in TDD-based development cycles using JUnit and Mockito to deliver robust and testable Java services.
● Applied design patterns and caching layers to ensure fast access to high-demand vehicle information and warranty status.
Built interactive dashboards in Angular for automotive clients to visualize and track dealer performance metrics in real-
time.
● Supported Salesforce data integration during migration efforts by aligning backend microservices with CRM workflows.
Took ownership of frontend logic in React and backend logic in Java, enabling consistent data flow in vehicle service
applications.
● Assisted in the gradual transformation of legacy systems within the automotive sector, prioritizing code modularity and
performance.
● Created scalable services for warranty claim approvals and audit trails using a microservices-first approach. Developed
backend logic to handle high-load dealer transactions using Java concurrency tools and thread pooling.
● Facilitated agile ceremonies and worked alongside geographically dispersed teams to deliver features on a tight automotive
release cycle.
● Collaborated with non-technical client teams, providing clear documentation and walkthroughs to support successful
platform onboarding. Built a caching mechanism using in-memory stores to accelerate warranty claim lookups and reduce
DB bottlenecks.
● Designed frontend components that adhered to modern UI/UX patterns, supporting responsive layouts for dealer apps.
● Participated in behavior-driven development efforts, crafting scenarios that aligned with real-world warranty handling
processes.
● Delivered consistent sprint outcomes while maintaining communication between developers, QA, and business users in
fast-paced environments.
● Contributed to the release planning process using Jira, mapping out epics and iterations for upcoming feature deliveries and
coordinating dependencies.

Client: State of Wyoming -Cheyenne,Wy. July 2017 to Mar

2019
Java Developer
Responsibilities
● Designing new components to fit in the already existing architecture using core java, multithreading, design patterns like
the factory method, abstract factory pattern, singleton, while developing web-based applications using rest web services.
● Effectively worked on Angular 1.0 to use the enhanced features of typescript, Angular Routers, and Angular Components.
● Worked on Agile methodology, including team-based design and code reviews.
● Implemented Spring Batch to run daily and monthly batches.
 ● Created stateless Spring Boot services deployed on Kubernetes, ensuring horizontal scalability and easy service
orchestration.
● Engineered Lambda functions for on-demand file processing workflows that interacted with AWS S3 and DynamoDB for
metadata tracking.
● Rewrote monolithic Java applications into distributed microservices with modular boundaries based on business contexts.
● Established cloud-native messaging between services using Kafka and integrated topic-based routing to improve message
flow.
● Managed automated builds and deployments using Jenkins, integrating unit testing and security scans into the CI/CD
lifecycle. Built asynchronous APIs using Spring WebFlux to handle high-concurrency use cases in the digital wallet domain.
● Tuned JVM parameters and garbage collection strategies for high-performance Java apps running on Red Hat Enterprise
Linux.
● Enabled near real-time synchronization between relational databases and cloud-native services using change data capture
patterns.
● Deployed secure and compliant APIs on AWS by integrating API Gateway, Lambda authorizers, and encrypted S3 buckets.
Designed and implemented event-driven processes triggered by SQS queues for backend order processing in a payment
service.
● Delivered infrastructure-as-code templates for AWS deployments using CloudFormation and Helm for containerized
resources.
● Applied design principles such as separation of concerns and dependency inversion in Spring-based microservices.
● Implemented structured logging and distributed tracing for debugging microservices using centralized logging stacks in
AWS.
● Built RESTful endpoints that handled complex JSON payloads and integrated validation and exception management at scale.
● Introduced Redis caching to reduce latency on frequently accessed data, supporting high-load wallet balance inquiries.
● Assisted in migrating payment processing services from on-prem servers to cloud-native platforms like AWS and GCP.
Developed payment reconciliation pipelines using Spring Batch to handle large transactional data sets and reports.
● Facilitated collaboration between backend, DevOps, and QA teams to ensure smooth delivery cycles under agile delivery
models. Implemented DevSecOps standards by integrating SonarQube, Fortify, and container scanning into Jenkins
pipelines. Mentored junior developers on best practices in Java, Spring Boot, and microservice architecture, supporting
team scalability.
● Involved in multi-tiered J2EE design utilizing Spring Inversion of Control (IOC) architecture and Spring JPA.

Client: Synchrony, In. July 2013—Oct 2015

Role: Java Developer
Responsibilities
● Developed SCM by using the JSP/HTML for each user interface. Servlets standard validations are used as the controllers for
business logic and using JDBC, XML parsing techniques using MVC.
● Worked with Log4J to capture the log that includes runtime exceptions.
● Configured [Link], [Link], and various properties files provided by Struts Framework for the
implementation module.
● Experience in developing Web APIs using [Link] and I have hosted these on many load-balanced API instances.
● Developed web applications using Struts, Spring, and iBatis framework.
● Used Spring boot, which is radically faster in building cloud microservices and developing spring mvc based applications
with very less configuration.
● Experience in installing, configuring, and deploying applications on Web Logic Server.
● We kept up the bean life cycle by utilizing Spring IOC, which keeps session information about beans.
● Extensively used the Struts tag libraries (Bean Tags, Logic Tags, HTML Tags, etc.) and Custom tag libraries.
● Familiar knowledge in creating Custom Reusable React Components Library.
● Implemented IBM WebSphere Application Server to deploy the application
● Deployed application on the Client Linux server.
● For securing the restful web services, I used spring security filters along with jwt token.
● Used Multithreading concept to post data from files to tables involving the transformation of files from one format to
another.
● Implemented Spring Boot to create a CRUD backend for our React-frontend application.
● Developed a DAO pattern to retrieve the data from the database.
● Implemented responsive web-based applications using HTML5, CSS3, JavaScript, jQuery.
● Used ANT build tool for compiling and generating war files.
● Designed a mailing application to send notifications to the Oracle users for intimating to start the following workflow.