Stack Developer Senior Java

Name: Rupa G

Senior Java Backend Developer

E-mail: *********@*****.***

Contact: 732-***-****

LinkedIn: www.linkedin.com/in/rupa-g03

Career Highlights

Senior Java Full Stack Developer with over 10 years of experience delivering scalable, secure and resilient software systems across the full development lifecycle, utilizing Agile practices, advanced Java skills and modern frameworks for both front-end and back-end solutions.

Experienced in all phases of the Software Development Life Cycle (SDLC), including requirement gathering, development, testing, and production support, with a strong understanding of Agile frameworks like Scrum and Kanban for iterative project execution.

Deep knowledge of Java (versions 6 through 17), covering object-oriented programming (OOP) principles, core data structures, and advanced features like lambda expressions, streams, and ZGC to deliver performant and maintainable applications.

Specialized in developing rich web applications using JavaScript, TypeScript, HTML5, CSS3, and Bootstrap, with effective use of Ajax to enable responsive and asynchronous client-side interactions.

Hands-on with modern front-end frameworks like Angular, React, and jQuery, proficient in creating reusable UI components, managing application state, and enhancing the DOM using AJAX techniques.

Familiar with frontend testing frameworks such as Jasmine and Karma, used to write and maintain unit and integration tests that validate UI functionality, consistency, and cross-browser behavior.

Well-versed in the Spring framework, including Spring Boot for building microservices, Spring Cloud for distributed systems, Spring Security for enforcing security policies, and Spring MVC, Spring JMS, and Spring Batch for web and messaging workflows.

Proficient in API development using REST (JSON), SOAP (XML), and GraphQL, with practical experience using Postman for testing endpoints. Also comfortable with Node.js and its extensive module ecosystem.

Extensive exposure to cloud platforms including AWS, Microsoft Azure, and Google Cloud Platform (GCP), using their services to deploy, manage, and scale cloud-native applications across diverse environments.

Skilled in infrastructure automation with Terraform, along with managing compute, storage, and identity services like EC2, Lambda, IAM, S3, ECS, Azure VMs, AKS, and ACI for robust and secure deployments.

Thorough understanding of CI/CD practices, having designed and managed pipelines using Jenkins, Bamboo, GitLab CI/CD, and CircleCI to automate builds, tests, and deployments at scale.

Advanced experience with Docker and Kubernetes, using containers for consistency across environments and leveraging orchestration for auto-scaling, health checks, service discovery, and fault tolerance in microservice architectures.

Expert in managing persistent data using Spring JPA, Hibernate, and Spring JDBC, ensuring optimized data access patterns, complex entity relationships, and transactional consistency.

Competent in using build tools such as Maven, Gradle, Bazel, SBT, and Ant, and well-practiced with IDEs like Eclipse, NetBeans, and IntelliJ IDEA for efficient development and debugging.

Proficient in configuring and deploying Java applications across multiple application servers, including JBoss, Tomcat, GlassFish, WebSphere, and WebLogic. Experienced with both relational databases (e.g., PostgreSQL, Oracle, MS SQL) and NoSQL databases (e.g., MongoDB, Cassandra).

Strong grasp of code quality and static analysis tools including SonarQube, JaCoCo, and Checkstyle, as well as expertise in event-driven systems using Kafka, RabbitMQ, ActiveMQ, and JMS.

Experienced in version control and collaboration tools like GitLab, Bitbucket, GitHub, and SVN, and adept with issue tracking systems such as Jira, Redmine, and Bugzilla for managing workflows and collaboration.

Knowledgeable in a wide range of testing frameworks including JUnit, Mockito, TestNG, and Selenium, and proficient with logging tools like Log4j, SLF4J, and Logback for monitoring and diagnostics.

Experienced in documentation and knowledge-sharing platforms such as Confluence, GitLab Wiki, Bitbucket Wiki, and SharePoint, contributing to improved team communication and project alignment.

Technical Skills

Programming Languages

Java (v6 to v17), JavaScript, TypeScript, Node.js

Frontend Technologies

HTML5, CSS3, Bootstrap, Ajax

UI Frameworks

Angular, React, jQuery

UI Testing Tools

Jasmine, Karma

Backend Frameworks

Spring Boot, Spring Cloud, Spring Security, Spring MVC, Spring JMS, Spring Batch

API Technologies

REST (JSON), SOAP (XML), GraphQL, Postman

Cloud Platforms

AWS, Azure, GCP

Infrastructure Tools

Terraform, EC2, Lambda, IAM, S3, ECS, Azure VMs, AKS, ACI

CI/CD Tools

Jenkins, Bamboo, GitLab CI/CD, CircleCI

Containerization & Orchestration

Docker, Kubernetes

Database Technologies

PostgreSQL, Oracle, MS SQL, MongoDB, Cassandra, Spring JPA, Hibernate, Spring JDBC

Build Tools & IDEs

Maven, Gradle, Bazel, SBT, Ant, Eclipse, NetBeans, IntelliJ IDEA

Application Servers

JBoss, Tomcat, GlassFish, WebSphere, WebLogic

Messaging & Event Streaming

Kafka, RabbitMQ, ActiveMQ, JMS

Code Quality Tools

SonarQube, JaCoCo, Checkstyle

Version Control & Issue Tracking

GitLab, BitBucket, GitHub, SVN, Jira, Redmine, Bugzilla

Testing Tools

JUnit, Mockito, TestNG, Selenium

Logging Tools

Log4j, SLF4J, Logback

Documentation Tools

Confluence, GitLab Wiki, Bitbucket Wiki, SharePoint

Job Experience

Client: Keycorp, Cleveland, OH Duration: Sep 2022 – Till Date

Senior Java Full Stack Developer

Role & Responsibilities:

Participated in Agile ceremonies including sprint planning, retrospectives, and stand-ups to support iterative backend feature delivery aligned with banking compliance and regulatory standards.

Developed high-performance backend microservices using Java 14/17, applying functional programming, streams, and lambda expressions to process large volumes of financial data including transactions, user profiles, and real-time reporting metrics.

Designed and implemented RESTful APIs and microservice components using Spring Boot, Spring MVC, and Spring Cloud, supporting modular deployments, scalability, and centralized configuration management.

Created secure APIs using Spring Security, integrating JWT-based authentication and OAuth2 to enforce role-based access and protect sensitive customer and banking data.

Built robust batch processing jobs with Spring Batch, enabling parallel execution and transactional integrity for recurring operations like end-of-day reconciliation, billing cycles, and regulatory exports.

Optimized backend data persistence using Spring Data JPA, JPQL, and Hibernate, crafting efficient queries and entity mappings to support complex business logic and high-concurrency environments.

Instrumented backend observability with Spring Boot Actuator, Micrometer, and Prometheus, providing real-time system health insights, performance metrics, and fault analysis.

Enabled event-driven communication between services using Kafka, supporting decoupled workflows for fraud detection, transaction notifications, and asynchronous financial events.

Integrated backend utilities and asynchronous tasks using Node.js, building lightweight scripts for file processing, log handling, and automation of middleware tasks in the AWS ecosystem.

Developed backend automation and utility tasks using Node.js, handling backend file parsing, log cleanup, and maintenance scripts within AWS Lambda for cost-efficient compute.

Deployed backend services to Amazon Web Services (AWS) using Amazon ECS (Fargate), AWS Lambda, Amazon API Gateway, and Elastic Beanstalk, achieving high availability and seamless scaling across environments.

Provisioned cloud infrastructure using Terraform and AWS CloudFormation, automating deployment of resources such as Amazon S3, VPCs, EC2, RDS, and IAM roles for secure access control.

Containerized backend applications using Docker and orchestrated them through Amazon ECS, implementing service discovery, health monitoring, and autoscaling with Application Load Balancer (ALB).

Built robust CI/CD pipelines using AWS CodePipeline, AWS CodeBuild, and GitLab CI/CD, integrating static code analysis, testing, and environment-specific deployment workflows.

Enforced code quality and security with SonarQube, running static analysis on backend services to minimize technical debt and ensure maintainability.

Performed code reviews in IntelliJ IDEA, contributing to quality assurance, refactoring legacy components, and improving maintainability of complex logic.

Used GitLab to manage version control, implement Git workflows, and collaborate via merge requests across a distributed backend team.

Implemented structured logging using Log4j, SLF4J, and AWS CloudWatch Logs, improving traceability and enabling quick diagnostics in distributed production environments.

Wrote and maintained comprehensive unit and integration tests using JUnit and Mockito, practicing TDD to ensure backend resilience and bug-free releases.

Tracked deliverables, bugs, and sprints using Redmine, supporting Agile processes and cross-functional coordination in a highly regulated financial environment.

Client: Deutsche Bank, New York, NY Duration: Oct 2020 – Aug 2022

Senior Java Full Stack Developer

Role & Responsibilities:

Led end-to-end software development initiatives in the financial domain, participating in Agile ceremonies including sprint planning, daily stand-ups, and retrospectives to align backend deliverables with regulatory and compliance objectives.

Developed scalable microservices using Java 11, following OOP best practices, streams, and lambda expressions to support high-volume operations such as account management, payments, and loan servicing.

Built and maintained secure RESTful APIs using Spring MVC, applying layered architecture, global exception handling, and Hibernate Validator for robust request validation and service modularity.

Implemented authentication and authorization using Spring Security, with JWT, OAuth2, and method-level security to protect customer data and restrict sensitive financial operations.

Created batch workflows with Spring Batch, supporting multi-threaded job steps and transactional rollbacks for critical processing like billing, reconciliation, and regulatory file generation.

Enabled backend observability using Spring Boot Actuator, Micrometer, Prometheus, and AWS CloudWatch, ensuring real-time health checks, metrics visualization, and performance alerting.

Developed persistence layers using Spring Data JPA and Hibernate, writing optimized JPQL queries, tuning entity relationships, and applying EntityGraph for efficient lazy/eager loading strategies.

Designed asynchronous workflows using RabbitMQ and Amazon SQS, decoupling backend services to handle tasks such as fraud detection, alerts, and background job triggers.

Built utility modules in Node.js to support asynchronous file processing, logging tasks, and middleware automation integrated with AWS Lambda for event-driven computing.

Deployed backend services to AWS, utilizing Amazon ECS (Fargate), Amazon EC2, Elastic Beanstalk, and Amazon API Gateway to ensure scalable and secure service hosting.

Defined infrastructure using Terraform and AWS CloudFormation, provisioning resources like Amazon VPC, Amazon S3, RDS, IAM, CloudTrail, and Security Groups with versioned and reusable configurations.

Containerized services using Docker and orchestrated deployments through Amazon ECS, configuring load balancing with Elastic Load Balancer (ELB), auto-scaling policies, and service discovery.

Designed and maintained CI/CD pipelines using AWS CodePipeline, AWS CodeBuild, and Bamboo, integrating unit tests, static code analysis, build promotion, and automated deployments across environments.

Integrated test coverage tools such as JaCoCo into CI/CD workflows to ensure consistent backend test visibility and enforcement of code quality gates.

Managed dependencies and builds using Gradle, supporting efficient incremental compilation, plugin integration, and multi-module microservice architecture.

Tuned backend performance on JBoss by configuring JVM memory settings, thread pool limits, and connection pooling to handle concurrent traffic under peak loads.

Designed and queried distributed datasets using Amazon DynamoDB and Cassandra, enabling high-availability data access for real-time financial transactions and audit logging.

Used Bitbucket and Git for version control, implementing branching strategies, pull requests, and conducting code reviews to maintain clean and collaborative codebase management.

Tracked development progress, sprint goals, and release coordination using Jira, facilitating backlog refinement, bug triaging, and continuous feedback cycles.

Validated service logic using JUnit, Mockito, and TestNG, implementing test-driven development practices and regression test suites across all backend components.

Client: Elevance Health, Indianapolis, IN Duration: May 2018 – Sep 2020

Java Full Stack Developer

Role & Responsibilities:

Participated in Agile-based development of healthcare IT platforms, supporting sprint planning, backlog refinement, and team stand-ups to ensure timely backend feature delivery and adherence to HIPAA and clinical compliance requirements.

Developed robust backend services using Java 8, leveraging functional programming, custom comparators, and stream APIs to optimize data handling across patient records, insurance claims, and lab result workflows.

Automated high-volume data workflows using Spring Batch and Spring Boot, orchestrating jobs for electronic health record (EHR) synchronization, medical billing, and scheduled exports of clinical data.

Enabled backend system integration with Spring Integration, facilitating reliable messaging and seamless interoperability between core systems, insurance partners, and third-party clinical service providers.

Implemented real-time communication features using Spring WebSocket, supporting live clinical notifications, patient monitoring, and interactive status updates across web-based dashboards.

Designed and developed RESTful APIs for modular healthcare microservices, ensuring secure, stateless data exchange for scheduling, claim adjudication, and health record management under high concurrency.

Provisioned and managed Azure cloud infrastructure using Terraform, automating deployment of Virtual Machines (VMs) and Virtual Networks (VNets) for scalable and secure hosting of backend services.

Improved service responsiveness using Node.js, developing utility services and backend handlers with performance strategies such as caching, load balancing, and clustering.

Built and maintained CI/CD pipelines using GitLab CI/CD, integrating GitLab Runner to support automated unit testing, build validation, and deployment to Azure-based environments.

Managed builds with Maven, optimizing dependency resolution and supporting repeatable backend builds; used Eclipse IDE for development, debugging, and refactoring activities across service layers.

Implemented asynchronous messaging with ActiveMQ, enabling decoupled service communication across critical modules like lab processing, appointment management, and insurance coordination.

Enforced backend code standards using Checkstyle, improving maintainability, readability, and adherence to team-wide conventions during development cycles.

Deployed Java-based services to Apache Tomcat, tuning server configurations (JVM memory, thread pools, etc.) for performance and uptime optimization in clinical environments.

Utilized Oracle databases for persistent data storage, writing optimized SQL queries and managing schema design to handle complex healthcare datasets efficiently and reliably.

Used Jira to manage user stories, sprint boards, and issue tracking, coordinating with QA and product stakeholders to ensure accurate and timely delivery.

Implemented structured logging using SLF4J, enabling detailed diagnostics, traceability, and rapid incident investigation in production systems.

Client: Assurant Inc, Atlanta, GA Duration: July 2016 – April 2018

Java Developer

Role & Responsibilities:

Contributed to the full software development lifecycle (SDLC) for enterprise insurance systems, supporting Agile practices like sprint planning and backlog grooming to deliver scalable, regulatory-compliant backend solutions.

Developed enterprise-grade backend services using Java 7, building maintainable modules for core insurance operations including policy processing, claims adjudication, and customer data management.

Designed and implemented high-volume data workflows using Spring Batch and Spring Integration, automating operations like premium calculations, policy renewals, and batch claims ingestion.

Engineered modular, service-oriented architecture (SOA) using Spring Boot, enabling independent deployment and rapid delivery of underwriting and policy servicing features.

Created RESTful APIs for inter-service communication and leveraged tools like Postman for testing and validation. Integrated early GraphQL patterns for flexible data querying in distributed environments.

Deployed backend microservices in AWS, leveraging ECS with Fargate for container orchestration and IAM for secure access control to cloud-hosted components.

Configured and optimized CI/CD pipelines using TeamCity and CMake, automating build and deployment steps across staging and production environments.

Developed and debugged backend modules using NetBeans IDE, utilizing advanced refactoring, code analysis, and integration tools to accelerate feature development.

Enabled asynchronous communication between distributed components using JMS, improving system decoupling and throughput for policy issuance, notifications, and payment processing workflows.

Deployed services on IBM WebSphere, tuning configurations and JVM parameters for improved performance and scalability in enterprise-grade insurance systems.

Wrote optimized SQL and managed complex data models in PostgreSQL, ensuring fast data access and transactional integrity for large-scale customer and policy datasets.

Used Mercurial for source control, managing version history, branching, and team collaboration, while tracking issues and enhancements via Bugzilla to support efficient delivery cycles.

Applied JUnit for backend unit testing, supporting test-driven development (TDD) and ensuring reliable integration with other service modules.

Maintained internal documentation using Confluence, capturing service behavior, API contracts, and technical decisions to support cross-functional collaboration.

Client: Gap, San Francisco, CA Duration: Nov 2013 – June 2016

Java Developer

Role & Responsibilities:

Developed scalable backend systems for retail e-commerce platforms using Java 6, supporting key features such as inventory control, order management, and payment processing in a fast-paced Agile environment.

Implemented robust application-level security using Spring Security, establishing secure authentication mechanisms and role-based access controls to protect sensitive data such as customer accounts and order history.Implemented application-level security with Spring Security, managing robust authentication and role-based access controls to safeguard sensitive retail data such as customer profiles and order histories.

Built and maintained SOAP-based web services using XML, supporting structured communication between core e-commerce systems and external integrations like logistics, billing, and CRM tools.

Automated batch data processing using Spring Batch, orchestrating jobs for large-scale operations such as nightly order reconciliations, price updates, and inventory synchronization.

Configured and tuned WebLogic Server environments for performance and scalability, ensuring stable handling of concurrent retail traffic and responsive application behavior.

Administered MS SQL Server databases, designing relational schemas, optimizing queries, and managing indexing strategies to support efficient transaction workflows.

Automated project build and deployment processes using Ant, streamlining integration steps and enabling consistent environment provisioning across development and production.

Used Subversion (SVN) for version control, maintaining structured branching and merging workflows for team collaboration and feature tracking.

Tracked and resolved bugs and enhancements using Bugzilla, ensuring issue accountability and maintaining delivery quality through structured QA collaboration.

Performed load and performance testing using Apache JMeter, identifying application bottlenecks and fine-tuning backend processes to ensure responsiveness during high-traffic sales events and seasonal spikes.

Academic Qualifications

Bachelors in Computer Science.

Qualification Badges

AWS Certified Solution Architect Associate.

Microsoft Certified Azure Solution Architect Expert.

Contact this candidate