Senior Java Backend Developer with Cloud & Microservices Expertise

Santhosh

Sr. Java Backend Developer

Email: ****************@*****.*** Phone: +1-559-***-****

PROFESSIONAL SUMMARY:

Senior Java Backend Developer with 6+ years of experience designing, developing, and deploying enterprise-grade, scalable, and high-performance backend systems.

Strong expertise in Core Java, J2EE, Java 8+, multithreading, concurrency, Collections, Streams API, Lambda expressions, and OOP principles.

Extensive hands-on experience with Spring Framework (Spring Boot, Spring MVC, Spring Data JPA, Spring Security), microservices, and REST/GraphQL APIs.

Proven experience in cloud-native application development with AWS (EC2, ECS, EKS, S3, RDS, Lambda, API Gateway, CloudFront, SQS, SNS) and Azure (App Service, Functions, Logic Apps, Active Directory).

Strong DevOps exposure with CI/CD pipelines using Jenkins, Azure DevOps, Maven, Gradle, and infrastructure automation using Terraform and Ansible.

Hands-on experience with Docker containerization, Kubernetes orchestration, and OpenShift for scalable deployments.

Solid background in RDBMS and NoSQL databases including MySQL, PostgreSQL, Oracle, MongoDB, and AWS RDS.

Skilled in event-driven architecture and messaging platforms: Apache Kafka, RabbitMQ, JMS, AWS SQS/SNS.

Proficient in monitoring, logging, and troubleshooting using ELK Stack, Splunk, JProfiler, VisualVM, and memory leak analysis.

Experience in Pair Programming, Test Driven Development, Waterfall model and agile methodologies like SCRUM

Experienced in unit, integration, and automation testing using JUnit, Mockito, Postman, Cucumber, and Selenium.

Strong understanding of security mechanisms including Spring Security, OAuth 2.0, JWT, and Azure AD.

Has working knowledge of Redis Cache and RabbitMQ.

Experience in Continuous Integration (CI) and Continuous Delivery (CD) process implementation.

Good Understanding of APIGEE architecture.

Good experience in developing customized policies in Apigee Edge and developing API's in Apigee Baas.

Strong understanding of object-oriented development and design patterns.

Hands-on experience in using message brokers such as ActiveMQ and RabbitMQ

Experienced in Agile/Scrum, Kanban, TDD, and collaboration using JIRA, Confluence, and Git.

Proven ability to mentor junior developers, conduct code reviews, and deliver high-quality software in fast-paced enterprise environments.

TECHNICAL SKILLS:

Programming Languages: Java (Core Java, Java 8+, J2EE, Collections, Lambda, Streams API, Concurrency, Multithreading, OOP), SQL, PL/SQL

Frameworks & Libraries: Spring (Spring Boot, Spring MVC, Spring Core, Spring Data JPA, Spring Security), Hibernate, JPA, EJB, AOP

Web Services & APIs: RESTful APIs, Microservices, GraphQL, SOAP (WSDL), JAX-RS, Swagger

Cloud Platforms & Services: AWS (EC2, ECS, EKS, S3, RDS, Lambda, API Gateway, Glue, CloudFront, SQS, SNS), Azure (App Service, Functions, Logic Apps, Active Directory)

Build & Dependency Management: Maven, Gradle, Apache Ant

CI/CD & DevOps Tools: Jenkins, Azure DevOps, Docker, Kubernetes, OpenShift, Terraform, Ansible, Helm

Application Servers: Apache Tomcat, JBoss

Databases: SQL, MySQL, PostgreSQL, Oracle, MongoDB, Cassandra, AWS RDS

Messaging & Streaming: Apache Kafka, RabbitMQ, JMS, AWS SQS, AWS SNS

Version Control & Collaboration: Git, GitHub, Bitbucket, JIRA, Confluence

Troubleshooting & Performance Tuning: Profiling tools (JProfiler, VisualVM), memory leak analysis, garbage collection tuning, thread dump analysis

Testing & Automation: JUnit, Mockito, Selenium WebDriver, Postman, Cucumber, TDD, BDD

Security & Authentication: Spring Security, OAuth 2.0, JWT, Azure Active Directory (AAD)

Markup & Transformation: XML, XSD, XSLT, JSON

Development Methodologies & Tools: Agile (Scrum, Kanban), SDLC, Eclipse IDE, IntelliJ IDEA, TDD

Problem Solving & System Design: Data Structures and Algorithms, scalability, performance optimization, backend architecture design

Logging & Monitoring: ELK Stack (Elasticsearch, Logstash, Kibana), Splunk, AWS CloudWatch,

Prometheus, Grafana, Log4J

Debugging & Troubleshooting: Root cause analysis, production issue debugging,

thread dump analysis, heap dump analysis

Performance Tuning & Profiling: JProfiler, VisualVM, garbage collection tuning,

memory leak analysis

EXPERIENCE:

Cisco, Dallas, Texas Sep 2025 - Current

Senior Java Backend Engineer

Responsibilities:

Developed web applications using Java, Spring Boot, Spring Framework, and Hibernate ORM, ensuring efficient backend services and seamless frontend integration.

Designed and developed backend modules using Java and J2EE technologies, applying strong object-oriented analysis and design (OOAD) principles to build scalable and maintainable systems.

Designed modular and scalable application architectures using Spring MVC, IoC, and DI, reducing code complexity by 35% and improving maintainability across multiple modules.

Developed and consumed RESTful APIs and GraphQL endpoints to enable secure, scalable communication between microservices and frontend applications.

Implemented Aspect-Oriented Programming (AOP) to separate concerns, reduce code duplication by 40%, and maintain a clean, efficient codebase.

Integrated PostgreSQL and Cassandra databases using the DAO pattern, improving data management, reliability, and scalability for large-scale applications.

Engineered real-time data streaming solutions and JSON APIs, improving user experience by 25% and ensuring responsive performance during peak usage.

Deployed and managed cloud-based applications on AWS (EC2, Lambda, S3, RDS), optimizing scalability and reliability while reducing infrastructure costs by 20%.

Designed AWS CloudFormation templates and configured auto scaling for EC2 instances, contributing to the automated provisioning of the AWS cloud environment.

Implemented OAuth 2.0 for secure user authentication and authorization, ensuring compliance with modern security standards.

Implemented backend security using Spring Security, OAuth 2.0, and JWT, ensuring secure service-to-service communication.

Worked on high severity production alarms, added additional features and improved its efficiency.

Successfully established and upheld the monitoring and alerting of production and corporate servers/storage using CloudWatch.

Containerized applications using Docker and orchestrated deployments with Kubernetes, streamlining development, testing, and production workflows.

Automated infrastructure provisioning and management with Terraform, applying Infrastructure as Code (IaC) practices for consistent deployments.

Implemented GraphQL APIs alongside REST services to allow flexible querying and reduce over-fetching of data in microservices.

Implemented unit, integration, and API tests using JUnit, Mockito, and Postman to ensure high backend reliability.

Used Splunk for checking logs and created alerts to trigger if any error occurs.

Used ELK Stack for log aggregation, monitoring, and analytics to maintain system health and identify performance bottlenecks.

Leveraged Apache Kafka for event-driven architecture, enabling real-time data streaming and message queuing between distributed services.

Integrated CI/CD pipelines using Jenkins, Gradle, and Git, automating testing, builds, and deployments, accelerating development cycles by 40% and reducing deployment errors by 30%.

Monitored Kubernetes workloads using Prometheus and Grafana for pod-level and node-level observability.

Performed performance tuning, debugging, and troubleshooting, achieving a 20% improvement in response times and ensuring low-latency user experiences under heavy traffic.

Created and maintained Swagger specifications for RESTful APIs developed using Spring Boot.

Mentored junior developers, conducted code reviews, and led architecture discussions to enforce best practices.

Designed and implemented event-driven architectures using message queues to support high-throughput, fault-tolerant systems.

Planned, developed, tested, deployed, and documented application components across the full Software Development Life Cycle (SDLC).

Environment: Java, Spring Boot, Spring, Hibernate ORM, Spring MVC, Node.js, Express.js, Angular, jQuery, RxJS, Material UI, Bootstrap, HTML5, CSS3, PostgreSQL, Cassandra, DAO, JSON, AWS, OAuth 2.0, Docker, Kubernetes, Terraform, ELK Stack, Apache Kafka, Jenkins, Gradle, Git, Agile (Scrum).

US BANK Minneapolis, MI NOV 2023 – Aug 2025

Senior Java Backend Engineer

Key Responsibilities:

Participated in end-to-end design and development of enterprise-grade applications following SDLC, ensuring high performance, maintainability, and adherence to best practices.

Built scalable microservices architecture using Core Java, J2EE, Spring Boot, enabling modular development and independent service deployment.

Utilized Hibernate ORM for efficient data persistence, optimizing database operations and ensuring seamless integration with relational databases.

Designed and developed dynamic UIs using AngularJS, HTML5, CSS3, JavaScript for seamless user experience.

Implemented AWS-based infrastructure using Lambda for serverless execution and EC2 for dynamic compute scaling, reducing overhead.

Developed serverless functions with Java Lambda to handle API triggers, file uploads, and scheduled tasks, improving operational efficiency by 40%.

Implemented event-driven architecture using AWS Lambda, S3, DynamoDB Streams, SQS, automating workflows.

Monitored system health using JProfiler and ELK Stack for proactive troubleshooting.

Built and managed AWS-based backend infrastructure using EC2, Lambda, S3, RDS, API Gateway, IAM, and Auto Scaling.

Designed and optimized SQL queries in MySQL and PostgreSQL, performing joins, indexing, and stored procedures for high-volume transactional systems.

Implemented backend logic using Java 8 features such as Streams API, Lambda expressions, and Optional, improving code readability and performance.

Leveraged Apache Kafka for messaging between distributed services, supporting real-time data pipelines.

Secured applications using Spring Security, implementing fine-grained authentication and authorization.

Applied design patterns such as Singleton, Saga orchestration, and CQRS to improve system scalability and fault tolerance.

Diagnosed and resolved multithreading issues, improving application stability.

Developed and maintained automation frameworks using Selenium WebDriver and Core Java, improving test efficiency by 40%.

Applied JUnit and Mockito for unit and integration testing of backend components.

Administered AWS RDS, providing robust database solutions with automated backups, failover, and scaling.

Implemented backend services interacting with RDBMS ensuring transactional consistency, optimized queries, and efficient data storage.

Designed and optimized RDBMS schemas and queries in PostgreSQL and MySQL.

Built secure REST APIs with Spring Security, ensuring role-based access control and token-based authentication.

Validated REST APIs using Postman, ensuring proper response codes, payload structures, and error handling.

Applied RESTful best practices, including consistent naming conventions, HTTP status codes, and HATEOAS principles.

Developed multithreaded Java applications handling concurrent processing and resource synchronization, reducing latency in high-throughput backend services.

Containerized Spring Boot microservices using Docker and deployed to Amazon ECS (Fargate), ensuring scalability.

Deployed and managed Docker containers within Kubernetes environments using Helm charts and YAML manifests.

Utilized Redis for distributed caching of frequently accessed data.

Applied IaC with Terraform and automated configuration with Ansible.

Secured backend services using Spring Security, OAuth 2.0, and JWT.

Documented API contracts, system designs, and knowledge-sharing resources using Confluence, improving team collaboration and onboarding.

Configured CI/CD (Continuous Integration / Continuous Deployment) pipelines using Jenkins, and Maven, automating build, test, and deployment processes to accelerate release cycles.

Used Swagger annotations to document API endpoints, request/response models, and validation rules.

Performed debugging, root cause analysis, and performance tuning using thread dumps, heap dumps, JProfiler, and VisualVM.

Automated backend build, test, and deployment pipelines using Maven, Gradle, Jenkins, and Git.

Prepared and maintained technical design documents, flow diagrams, and system documentation to support development and maintenance activities.

Used Rapid Application Development (RAD) tools to accelerate development cycles, perform debugging, and streamline application builds and deployments.

Supported System Integration Testing (SIT) by coordinating with dependent systems and resolving integration defects.

Designed application components using UML diagrams, class diagrams, and sequence diagrams.

Applied structured analysis/design techniques and object-oriented methodologies to design scalable and maintainable applications.

Collaborated with product owners, QA, and backend teams to define feature requirements.

Delivered enterprise Java/J2EE applications across the full SDLC including design, development, testing, integration, and deployment.

Environment: Java (Spring Core, Spring Boot, Hibernate, Spring Security), AWS (Lambda, EC2, RDS, S3, API Gateway, CloudFront), Apache Tomcat, Apache Kafka, Terraform, Ansible, Docker, Kubernetes, JProfiler, ELK Stack, Jenkins, SonarQube, Cucumber, Git, GitHub, JUnit, Agile.

Southern Glazers Wine & Spirits -Miramar, FL Jan 2023 -Nov 2023

J2EE Developer

Key Responsibilities:

Developed and maintained Spring Boot RESTful microservices to deliver secure, high-performance backend services, integrating with MongoDB for high-volume, unstructured data.

Applied Spring IoC and Dependency Injection (DI) to build modular, reusable, and testable components, enhancing maintainability and scalability.

Built efficient data access layers using Spring Data JPA and Hibernate, optimizing query execution and transactional consistency.

Configured HikariCP connection pooling with AWS RDS to support high concurrent workloads and reduce latency.

Implemented serverless functions using AWS Lambda for asynchronous processing, reducing infrastructure overhead.

Integrated AWS SQS and SNS to enable event-driven microservices communication, improving system reliability and scalability.

Implemented backend authentication and authorization using OAuth and JWT.

Designed NoSQL data models using MongoDB and Cassandra, supporting scalable and flexible storage for real-time data applications.

Integrated MongoDB for handling NoSQL high-volume unstructured data, improving read/write performance and query flexibility for microservices.

Containerized applications using Docker and orchestrated deployments with Kubernetes, leveraging YAML manifests and Helm charts for reproducibility.

Developed secure REST APIs with Spring Boot, applying OAuth-based authentication and authorization and monitoring token usage.

Implemented asynchronous REST API endpoints integrated with AWS SQS/SNS for decoupled microservices communication.

Implemented backend logic using Java 8 features such as Streams API, Lambda expressions, and Optional, improving code readability and performance.

Built and maintained Kafka producers and consumers using Spring Kafka for high-throughput event streaming.

Leveraged Redis for low-latency caching to enhance application responsiveness.

Configured CI/CD (Continuous Integration / Continuous Deployment) pipelines using Jenkins, and Maven, automating build, test, and deployment processes to accelerate release cycles.

Optimized REST API response times using caching (Redis) and database query tuning.

Ensured high-quality REST APIs by applying unit and integration tests using JUnit and Mockito.

Automated deployments using Jenkins and AWS CodePipeline, ensuring consistent delivery across environments.

Conducted API testing with Postman and automated UI testing using Selenium WebDriver for end-to-end quality assurance.

Monitored application health and performance using AWS CloudWatch, AWS X-Ray, and Splunk, identifying and resolving production issues proactively.

Implemented versioned REST APIs to maintain backward compatibility during microservices evolution.

Applied API rate-limiting, throttling, and caching strategies on REST endpoints to optimize performance under heavy traffic.

Documented REST API contracts using Swagger for internal and third-party integrations.

Implemented logging and monitoring solutions in Prometheus and Grafana for Java applications running on Kubernetes, ensuring proactive issue detection and resolution

Collaborated with QA, DevOps, and product teams in an Agile Kanban environment, delivering incremental backend enhancements aligned with business priorities

Environment: Java, Spring Framework, Spring Boot, Spring Data JPA, Hibernate, AWS (EC2, S3, RDS, Lambda, SQS, SNS, CloudWatch, X-Ray), Kafka, MongoDB, Redis, Docker, Kubernetes, Jenkins, AWS CodePipeline, OAuth, Postman, Selenium, Maven, JBoss, GitHub, Swagger, JUnit, Splunk, Linux, Unix, JIRA, Kanban, BDD.

Wex Inc - Portland, ME Sep 2020 - Dec 2021

Java Backend Developer

Key Responsibilities:

Applied Inversion of Control (IoC) and Dependency Injection (DI) to enable modular design and reduce coupling across backend components.

Designed and developed enterprise-grade Java backend applications using Spring Framework (Spring Boot, Spring MVC, IoC, DI), ensuring maintainable, scalable architecture.

Built and maintained Spring Boot microservices using Java 11, adhering to clean code principles and SOLID design patterns.

Implemented Hibernate ORM / JPA for seamless data persistence with PostgreSQL, optimizing query performance for high-volume transactional systems.

Implemented backend logic using Java 8 features such as Streams API, Lambda expressions, and Optional, improving code readability and performance.

Developed and exposed RESTful APIs using Spring MVC, delivering JSON-based responses for integration with frontend and third-party systems.

Deployed and managed Java microservices on Azure App Service and Azure Kubernetes Service (AKS), ensuring scalability, high availability, and fault tolerance.

Implemented Azure Functions for serverless workflows, reducing infrastructure overhead and improving system responsiveness.

Integrated Azure Active Directory (AAD) for secure authentication and authorization across applications.

Designed and optimized event-driven architectures using Apache Kafka, tuning brokers, partitions, replication factors, and retention policies for low-latency, high-throughput messaging.

Built and maintained CI/CD pipelines using Jenkins / GitLab CI / Azure DevOps, automating Docker image builds, vulnerability scanning, and Kubernetes deployments.

Containerized applications using Docker and deployed to Kubernetes / OpenShift, ensuring consistent environments across development, staging, and production.

Secured APIs using OAuth 2.0, JWT, and API Keys, validating authentication and authorization flows via Postman.

Secured backend services using Spring Security, OAuth 2.0, and JWT.

Applied Test-Driven Development (TDD) principles, writing unit and integration tests with JUnit and Mockito to ensure high test coverage.

Designed and optimized SQL queries in MySQL and PostgreSQL, performing joins, indexing, and stored procedures for high-volume transactional systems.

Developed RESTful services using Spring MVC to expose backend functionality to internal and external clients.

Implemented Redis caching to improve backend response times and reduce database load.

Performed debugging, multithreading issue resolution, and performance optimization.

Collaborated closely with QA teams to reproduce, debug, and resolve defects, improving overall release stability and production readiness.

Monitored and troubleshot containerized workloads using Prometheus and Grafana, improving system observability, uptime, and performance.

Actively participated in Agile/Scrum ceremonies, contributing to continuous delivery and improvement.

Maintained documentation and collaborated with cross-functional teams using Confluence and Bitbucket, supporting code reviews, version control, and knowledge sharing

Environment: Java 11, Spring Framework (Spring Boot, Spring MVC, IoC, DI), Hibernate ORM / JPA, RESTful APIs, JSON, PostgreSQL, Apache Kafka, Docker, Kubernetes (AKS, OpenShift), Azure (App Service, Functions, Active Directory, DevOps), OAuth 2.0, JWT, Jenkins, GitLab CI, Mockito, JUnit, Postman, Prometheus, Grafana, Linux, IBM WebSphere, Bitbucket, Confluence, Agile/Scrum, TDD.

Aakruti Software Solutions Pvt Ltd India Aug 2018 - Aug 2020

Java Developer

Key Responsibilities:

Built enterprise-grade applications using the Spring Framework, utilizing Inversion of Control (IoC) and Dependency Injection (DI) to promote modularity and testability.

Developed and enhanced enterprise Java applications using Core Java and J2EE, following OOP principles: encapsulation, inheritance, abstraction, and polymorphism.

Built backend components using Spring (IoC, DI, MVC) to improve application modularity, maintainability, and testability.

Implemented Spring MVC architecture to separate presentation, business, and persistence layers, enabling scalable application design.

Integrated Hibernate ORM and JPA for object-relational mapping, reducing boilerplate JDBC code and ensuring efficient database interaction.

Designed and optimized PL/SQL queries, stored procedures, and functions in Oracle, supporting high-volume transactional systems.

Managed dependencies and project builds using Maven, standardizing project structure and enabling reproducible builds across environments.

Developed reusable Java business logic components to support enterprise workflows, ensuring high performance, reliability, and code reusability.

Implemented Java Message Service (JMS) for asynchronous messaging, enabling loosely coupled and message-driven application components.

Created and executed unit test cases using JUnit, ensuring functional correctness and improving overall code quality.

Validated RESTful services using Postman and integrated automated API tests into CI/CD pipelines using Newman for regression testing.

Used Apache Ant for build automation and dependency management to support consistent application builds across environments.

Applied logging and debugging techniques using Log4J, improving application observability and troubleshooting production issues.

Managed source code using Git, including branch management, code merges, and version control best practices.

Participated in Agile SDLC processes, collaborating with cross-functional teams to deliver features on time and meet business requirements

Environment: Java (Core Java, J2EE, EJB), Spring Framework (IoC, DI, MVC), Hibernate, JPA, Oracle (PL/SQL), JMS, Apache Ant, Eclipse IDE, JUnit, Postman, Log4J, Git.

Contact this candidate