Indraja Ambati

Sr Java Backend Developer

Career Objective
Accomplished and passionate Java Backend Developer with over 10+ years of experience designing, building, and
maintaining enterprise-level applications across Finance, Healthcare, and Telecom industries. Skilled in developing
secure and scalable microservices, optimizing cloud-native deployments, and implementing modern CI/CD pipelines.
Proven expertise in Spring Boot, Java 17, REST APIs, Kafka, and Cloud Platforms like AWS, Azure, and GCP, with
a focus on performance tuning and clean coding practices in Agile and TDD environments.

Professional Summary
 Over 10 years of backend development expertise using Java 8/11/17, Spring Boot, Spring Security, and J2EE
frameworks for secure enterprise-grade applications.
 Designed and implemented complex RESTful APIs with Spring MVC, JPA, and Hibernate, ensuring scalability,
reliability, and secure data communication.
 Built and deployed microservices-based architectures using Spring Cloud, Netflix Eureka, and Spring Ribbon,
enhancing modularity and reducing downtime.
 Integrated Apache Kafka and RabbitMQ for asynchronous messaging, enabling high-throughput data ingestion
across distributed systems.
 Developed secure authentication mechanisms using OAuth 2.0, JWT, and Spring Security, protecting sensitive user
and financial data.
 Automated deployment pipelines using Jenkins, GitLab CI, Docker, and Kubernetes, ensuring fast, error-free
releases.
 Proficient in cloud-native development on AWS (EC2, S3, RDS, Lambda) and Azure (Blob, App Service, SQL DB,
ADF) for reliable and cost-effective hosting.
 Built scalable pipelines using GCP services such as Dataflow, BigQuery, Pub/Sub, and Cloud Functions.
 Strong database development skills in PostgreSQL, MySQL, MongoDB, Oracle, and DynamoDB with deep
indexing and query tuning.
 Refactored monolithic apps into Spring Boot microservices, improving agility and easing continuous delivery cycles.
 Implemented GraphQL and REST API integrations, enabling efficient data exchange and flexible frontend
querying.
 Proficient in writing stored procedures and SQL for relational and NoSQL databases to support data analytics,
reporting, and transactions.
 Integrated Flask and Django REST APIs for hybrid service architecture in cross-functional environments.
 Developed and maintained frontend components using Angular 14–17, [Link], HTML5, CSS3, and Bootstrap for
admin and analytics dashboards.
 Used JUnit, Mockito, Cucumber, and Postman to write and execute unit, integration, and BDD tests across REST
APIs and service layers.
 Created end-to-end CI/CD workflows with Maven, Git, Jenkins, and Docker, supporting automated build, test, and
deployment.
 Migrated legacy systems to Spring Boot and Microservices, significantly improving modularity and developer
onboarding.
 Designed single sign-on (SSO) flows using OAuth2, SAML, and Spring Security, reducing user friction across
apps.
 Monitored production environments using Prometheus, Grafana, ELK Stack, and Azure Monitor, improving
uptime and issue resolution.
 Proficient in Test-Driven Development (TDD) and Behavior-Driven Development (BDD) using Jasmine, Karma,
Cucumber, and Selenium.
 Experience building real-time dashboards and custom workflows for analytics and monitoring using [Link], React,
and Kafka streams.
 Applied design patterns including DAO, DTO, Singleton, MVC, and Factory, ensuring clean, maintainable
backend code.
 Developed REST APIs using Jersey, JAX-RS, and Spring MVC, facilitating external vendor integrations and third-
party data ingestion.
 Hands-on with multi-threading, collections, reflection, and generics, building high-performance backend modules.
 Implemented Redis and Memcached caching layers, improving API response times and minimizing redundant DB
calls.
 Built and deployed Azure Kubernetes Service (AKS) and AWS EKS clusters to support cloud-native backend
scaling.
 Proficient in version control with Git, Bitbucket, GitHub, and used GitLab Pipelines for automating merge and
build flows.
 Developed and maintained Swagger documentation, enabling seamless onboarding and third-party integration.
 Used Maven and Gradle for dependency management, packaging, and triggering test runs.
 Worked on API Gateway, Load Balancers, IAM roles, and Security Groups for secure, scalable deployments on
cloud.
 Built and integrated backend features with React Native, enabling hybrid mobile app support.
 Applied Spring AOP, Spring Data, and Spring Transactions for cleaner separation of concerns.
 Experience integrating ETL pipelines using Azure Data Factory, improving batch data reliability and runtime
efficiency.
 Created asynchronous workflows and retry logic using Kafka, Spring Retry, and AWS Step Functions.
 Designed scalable schema models using MongoDB, Cassandra, and PostgreSQL for different access patterns.
 Conducted code reviews and mentored junior developers, ensuring adherence to standards and improving team
productivity.
 Built SPA (Single Page Applications) and connected them to backend services using [Link], Express, and
RESTful APIs.
Category Technologies & Tools
Languages Java 8/11/17, PL/SQL, Python, C, C++, PHP, Shell Scripting
Spring Boot, Spring MVC, Spring Security, Spring Cloud, Spring Batch, Spring Data, JPA, Hibernate,
Java/J2EE
JDBC, JMS, EJB
Frameworks Struts, JSF, iBatis, Flex, JAX-RS, JAX-WS, JAXB, Jersey, Apache Axis
Databases Oracle, PostgreSQL, MySQL, SQL Server, DB2, MongoDB, DynamoDB, Cassandra
AWS (EC2, S3, RDS, ELB, Route53, SNS, IAM, CloudFormation, CLI), Azure (Blob, App Service,
Cloud Platforms
SQL DB, ADF, AKS), GCP (BigQuery, Dataflow, Pub/Sub)
DevOps & CI/CD Jenkins, Docker, Kubernetes, Git, GitLab CI, GitHub, Bitbucket, Terraform, Maven, Gradle
Messaging Apache Kafka, RabbitMQ, JMS, AWS SNS, DynamoDB Streams, EventBridge
Web REST, SOAP, GraphQL, HTML5, CSS3, JavaScript, jQuery, AJAX, ReactJS, AngularJS/4/8/14/17,
Technologies [Link], [Link]
JUnit, Mockito, Postman, Cucumber, Selenium, HTMLUnit, JMeter, Citrus, Karma, Jasmine, Mocha,
Testing
Chai
Monitoring Grafana, Prometheus, ELK Stack, Azure Monitor, Log4J, CloudWatch
Version Control Git, Bitbucket, GitHub, GitLab, SVN
Design Tools Adobe Photoshop, Dreamweaver, IVR, After Effects
Modeling/Other UML, Rational Rose, Sparx, Visio, Swagger, STS, Eclipse, IntelliJ, VS Code

Organizational Experience :
Client: Albertsons Company
Role: Sr Java Backend Developer
Duration: April 2022 – Present
 Designed and developed RESTful APIs using Java 17 and Spring Boot, enhancing financial services platform
performance and response time.
 Implemented OAuth 2.0–based security using Spring Security, enabling secure authentication for internal APIs and
mobile apps.
 Built scalable microservices integrated via Apache Kafka and RabbitMQ, improving decoupling and asynchronous
communication.
 Developed full-stack components with Angular 17, HTML5, and Bootstrap, ensuring responsive UIs for financial
dashboards.
 Utilized Spring Batch and JPA for processing large financial datasets, improving ETL performance across scheduled
tasks.
 Deployed services on Azure App Service, Blob Storage, and Virtual Machines, ensuring secure cloud hosting and
data management.
 Wrote stored procedures and views in Azure SQL DB, optimizing business reporting and audit queries.
 Developed and containerized services with Docker, deployed on Kubernetes (AKS) with rolling updates for high
availability.
 Orchestrated CI/CD pipelines using Jenkins, Git, and Maven, reducing manual efforts and ensuring smooth
deployments.
 Created robust test suites with JUnit, Mockito, and Cucumber, ensuring code quality in TDD and BDD workflows.
 Built REST APIs in Django (DRF) and integrated with backend microservices for seamless data synchronization.
 Implemented event-driven logic using Spring Events, Kafka Streams, and RabbitMQ Queues, improving
scalability and responsiveness.
 Enabled role-based access using Spring Security and integrated JWT authentication for mobile and web clients.
 Used Azure Load Balancer, DNS, and CDN to manage traffic routing and ensure uptime during high traffic periods.
 Participated in backlog grooming and Agile ceremonies, aligning features with sprint goals and delivery deadlines.
 Created Swagger/OpenAPI documentation for backend services, accelerating onboarding of frontend and third-party
teams.
 Developed Python-based data enrichment pipelines integrated into Spring Boot services, improving data cleansing
accuracy.
 Used Azure Monitor, Grafana, and Log Analytics for real-time diagnostics and application performance insights.
 Handled complex business logic using Java 17 features like Switch Expressions, Records, and Text Blocks.
 Refactored monolithic applications into containerized microservices, improving modularity and reducing release
cycles.
 Managed source control using GitLab, conducted code reviews and managed merge requests with CI validation.
 Employed Spring Data JPA and Criteria API for dynamic query generation and relational joins in reporting
modules.
 Improved message throughput by 30% using Kafka producer configurations and partition strategies for data
pipelines.
 Deployed and maintained Azure Functions for event-driven triggers and payment status updates.
 Integrated API Gateway with backend services for rate limiting and authentication proxy management.
 Built Angular 14+ admin tools and integrated them using REST APIs, optimizing real-time account updates.
 Developed Spring Boot wrappers over external vendor services, ensuring consistent data formats and error handling.
 Used Mockito and JUnit with coverage tools to maintain test coverage above 90% across modules.
 Supported database migrations using Flyway, ensuring schema consistency across test, QA, and prod.
 Applied Spring Retry and Hystrix patterns for fault tolerance and circuit breaking in downstream calls.
 Created async task queues with RabbitMQ for batch report generation, improving user responsiveness.
 Led stand-up meetings, mentored junior developers, and contributed to architecture decisions and sprint planning.

Client: State of Texas

Role: Sr. Java Backend Developer
Duration: May 2019 – March 2022

 Developed scalable Spring Boot microservices for scheduling, logging, and user notifications, supporting decoupled
workflows.
 Designed and deployed Flask-based services for logging and lightweight reporting modules, integrated with backend
systems.
 Integrated backend with [Link] front-end components using RESTful APIs, Redux, and [Link] middleware.
 Built custom [Link] libraries and third-party adapters to enable message transformation and routing between
services.
 Implemented OAuth2 SSO using Spring Security, enabling seamless authentication across customer-facing portals.
 Used Kafka, RabbitMQ, and JMS for asynchronous message passing between microservices with failover patterns.
 Designed Maven multi-module structure for shared dependencies and modular packaging in microservices
architecture.
 Developed Java 14+–based services leveraging switch expressions and NullPointerException diagnostics for safer
backend logic.
 Created GraphQL APIs for selective data exposure to frontend dashboards and reporting interfaces.
 Used Dagger with Kotlin for dependency injection in mobile backend support components.
 Integrated Spring MVC, Hibernate, and Oracle for persistence, utilizing advanced ORM mappings and caching.
 Created REST endpoints for configuration services, dynamically updating service properties without downtime.
 Designed real-time event handling using Apache Kafka topics and consumer groups for parallel processing.
 Deployed containerized microservices on AWS EC2, Docker, and ECS, with full CI/CD via Jenkins Pipelines.
 Configured GCP BigQuery, Pub/Sub, and Dataflow to support backend data analytics and alerting flows.
 Used [Link] for visualization of operational metrics and frontend monitoring dashboards.
 Managed backend deployments on AWS and Azure, provisioning resources using Terraform for infrastructure
automation.
 Built event-driven workflows with AWS Lambda, DynamoDB Streams, and SNS topics for downstream system
triggers.
 Developed [Link]–based middle layers for bridging microservices and authentication proxies.
 Created centralized logging using Log4j, ELK Stack, and Grafana dashboards for operational insights.
 Implemented backend data sanitization and transformation logic using Java Streams and Jackson parsers.
 Wrote and executed integration test suites using Postman, JUnit, Mockito, and Cucumber in TDD fashion.
 Used MongoDB, MySQL, and PostgreSQL for mixed workload support, indexing, and replica configuration.
 Orchestrated deployment flows on Kubernetes with Helm charts for versioned rollouts and blue-green releases.
 Authored technical documentation and Swagger contracts for public and internal microservices.
 Configured GitLab CI to handle merge request validations, artifact publishing, and auto deployment scripts.
 Participated in sprint planning, code reviews, and architecture design with cross-functional teams.
 Worked with Apache Camel for backend integration patterns between data platforms and service endpoints.
 Integrated Spring Retry logic and fallback patterns to handle third-party service instability gracefully.
 Managed AWS IAM policies, RDS credentials, and Secrets Manager integrations for secure credential handling.
 Used Python scripts for quick ETL data cleaning tasks and format conversion between backend jobs.

Client: Capital Groups, Irvine, CA

Role: Sr. Java Backend Developer
Duration: August 2017 – April 2019
 Developed enterprise applications using Spring Boot, Hibernate, and Spring MVC, enabling modular backend
service delivery.
 Built dynamic RESTful web services using JAX-RS, Jersey, and Spring Controllers for patient management and
data integration.
 Leveraged RxJS with Angular for responsive HTTP request handling, improving real-time client interactions.
 Designed and deployed microservices using Docker and Kubernetes to orchestrate independent healthcare backend
modules.
 Created ETL pipelines using Azure Data Factory, automating ingestion from flat files, XML, and SQL-based
sources.
 Deployed scalable applications on Azure App Services, managing Blob Storage and Networking with Azure VNet
and Load Balancer.
 Worked with Python/Django to manage server logic and streamline content update APIs from the UI.
 Integrated Spring Data JPA, Spring IOC, and Spring AOP modules, separating business logic from controller logic.
 Used Kafka and Redis to handle high-volume real-time streaming data for patient event tracking.
 Developed Angular 6 front-end for analytics dashboards and consumed REST APIs for real-time data sync.
 Refined SQL queries and stored procedures on Oracle 12c, ensuring optimized access and minimal locking.
 Implemented MongoDB document-based data stores for unstructured clinical data and configured replica sets for
availability.
 Designed and implemented scalable backend logging with Log4J, routed into centralized ELK stack monitoring
tools.
 Built [Link]/Express APIs to expose certain backend modules to external vendors with strict request validation.
 Participated in Agile Scrum ceremonies, including sprint planning, daily stand-ups, and retrospectives.
 Integrated Azure Kubernetes Service (AKS) to support microservice deployment and seamless scaling.
 Used OAuth 2.0, Spring Security, and JWT for role-based access control and session management across services.
 Wrote automation scripts in Python for testing legacy ETL outputs and validating against updated backend models.
 Developed RESTful services with JSON/XML payloads to support both web and mobile integrations.
 Implemented advanced Spring MVC Controllers with custom exception handling and logging middleware.
 Created backend APIs that interfaced with React Native dashboards via Redux-managed front-end stores.
 Designed data models using MySQL, ensuring optimal normalization and referential integrity for healthcare data.
 Developed services for medical workflow orchestration using Spring Boot, RabbitMQ, and internal task queues.
 Conducted performance tuning for SQL and NoSQL DBs to handle concurrent access under load test conditions.
 Created CI pipelines using Git, Jenkins, and Maven, automating builds and integration tests.
 Authored internal API documentation using Swagger, accelerating development across front-end and QA teams.
 Implemented Azure DevOps YAML pipelines, triggering builds and deployments across testing and production
stages.
 Handled error tracing, alerting, and performance metrics using Grafana, Prometheus, and Azure Monitor.
 Integrated Spring Transactions and Hibernate Caching, improving backend efficiency in heavy update operations.
 Debugged API performance issues using Postman, SQL explain plans, and memory profiling in IntelliJ.

Client: Ford Motors, Dearborn, MI

Role: Java Backend Developer
Duration: February 2015 – July 2017
 Developed Java Spring MVC–based backend systems for enterprise web apps following MVC architecture and best
practices.
 Designed and implemented RESTful web services using Spring MVC, returning JSON/XML for cross-platform
consumption.
 Consumed and tested SOAP services with JAX-WS, using Apache Axis for applicant validation and notifications.
 Utilized RxJS and Angular 2/4 to create reactive front-end apps that consumed backend REST APIs for real-time
data updates.
 Configured Apache CXF and JAX-RS clients for calling external vendor services for notifications and event
tracking.
 Designed Spring-based application modules with IOC containers, separating service logic from web controllers.
 Implemented centralized logging using Log4j, establishing log levels for error, debug, and operational visibility.
 Built stored procedures and triggers using Oracle SQL, enhancing performance for bulk data operations.
 Used SOAP UI and Postman to test both REST and SOAP service endpoints, simulating multiple user roles.
 Implemented OAuth2 and secure token-based authentication to restrict access to protected endpoints.
 Migrated legacy backend modules to Spring Boot, enhancing modularity and support for container-based
deployment.
 Wrote unit tests for service and DAO layers using JUnit and Mockito, achieving over 85% test coverage.
 Built backend modules to interface with React Native and Angular-based SPAs for real-time analytics dashboards.
 Designed navigation logic using Spring Security and applied dynamic role-based menu generation in the front-end.
 Integrated MongoDB to store unstructured user data, using Mongoose for schema definition and fast access.
 Optimized REST services using async patterns and Spring Callable/WebAsyncTask, improving latency under load.
 Created Swagger/OpenAPI documentation for legacy REST endpoints to support refactoring and QA test creation.
 Wrote transformation logic using JAXB, converting XML payloads to Java objects in web service consumers.
 Managed version control using Git, resolved merge conflicts and contributed to daily CI/CD tasks using Jenkins.
 Participated in creating and testing SOAP-based authentication, including WSDL creation and security token
validation.
 Implemented Spring AOP to decouple cross-cutting concerns such as logging, validation, and auditing from core
logic.
 Conducted performance profiling using built-in JVM tools and log tracing to identify backend bottlenecks.
 Designed UI triggers that pushed events to backend web services, utilizing Angular services and Observables.
 Supported deployment scripts using Maven, ensuring all modules were tested, packaged, and archived correctly.
 Participated in sprint meetings, retrospective reviews, and collaborative design sessions with UI/QA teams.
 Developed SOAP/REST hybrid gateways that helped bridge legacy and new architecture for internal clients.
 Created schema validation handlers in Java, ensuring strict enforcement of data contracts in XML payloads.
 Wrote JPA entity mappings and implemented basic DAO layers using Hibernate for data persistence.
 Implemented thread-safe service layers and background batch processors using Executors and Java concurrency
APIs.
 Assisted senior developers in migrating legacy apps to Java EE 6+ stack, focusing on modularization and testing
coverage.

Client: Zensar Technologies, Hyderabad, India

Role: Java/J2EE Developer
Duration: June 2014 – July 2015
 Designed, developed, and maintained enterprise-grade web applications using Java 7, J2EE, Spring MVC, and
Hibernate, delivering secure and scalable business modules.
 Developed RESTful and SOAP web services to facilitate integration between internal systems and third-party
applications.
 Implemented Spring Core and Spring JDBC for dependency injection, transaction management, and database
interaction with Oracle and MySQL.
 Built and customized dynamic JSP pages integrated with Servlets, JSTL, and custom tag libraries to support data-
driven UIs.
 Developed DAO and Service layers using Spring and Hibernate ORM, applying lazy loading and caching for
optimized performance.
 Integrated log4j for centralized logging and exception handling frameworks for system-wide error management.
 Created and executed PL/SQL stored procedures, triggers, and views in Oracle for transactional and reporting
modules.
 Developed JavaScript and jQuery-based interactive components for form validation, AJAX calls, and UI
responsiveness.
 Designed and implemented MVC architecture, ensuring modular, testable, and easily maintainable code across
multi-tiered applications.
 Utilized HTML5, CSS3, and Bootstrap for cross-browser compatible and responsive front-end design.
 Automated build and deployment processes using Maven and integrated with Jenkins for continuous integration.
 Deployed web applications on Apache Tomcat and WebLogic servers, managing environment configurations
through Spring Profiles.
 Conducted unit testing and integration testing using JUnit 4 and Mockito, ensuring high-quality deliverables in
each sprint cycle.
 Worked closely with QA engineers to support defect resolution and regression testing during each release.
 Involved in code reviews, version control (SVN), and branch management, ensuring consistent code quality and
adherence to development standards.
 Participated in requirement analysis and design discussions with business analysts to translate functional
requirements into technical specifications.
 Supported performance optimization efforts by tuning SQL queries, improving caching strategies, and profiling
application response times.
 Collaborated in Agile (Scrum) teams, participating in sprint planning, stand-ups, and retrospectives to ensure timely
delivery of modules.

EDUCATION
Bachelor of Technology ([Link]) – Computer Science & Engineering
Jawaharlal Nehru Technological University (JNTU), Hyderabad, India