Cloud Engineer Senior Java

Prahlada Reddy Kasani

Senior Java Cloud Engineer

***************@*****.*** 810-***-****

@www.linkedin.com/in/prahlada-reddy-26b8ab193

PROFESSIONAL SUMMARY

Results-driven Senior Java Cloud Engineer with over 9+ years of experience designing and implementing scalable, secure, and cloud-native systems across high-availability environments. Spearheaded the design of cloud-native microservices using Java 17 and Spring WebFlux, implementing reactive pipelines that handle concurrency surges and backpressure under high-load scenarios.

Delivered secure and scalable distributed systems across AWS (EKS, Lambda), GCP (Cloud Run, GKE Autopilot), and Azure (AKS, App Services), choosing optimal cloud constructs based on SLA, latency, and cost-efficiency trade-offs.

Built real-time, developed architectures using Kafka (Amazon MSK) and Google Pub/Sub, enabling fault-tolerant asynchronous workflows for event sourcing, audit trails, and inter-service coordination.

Modeled scalable transactional systems on Cloud Spanner and Amazon DynamoDB, architecting for strong consistency and high availability across geo-distributed workloads.

Integrated machine learning pipelines into transactional systems by embedding Vertex AI and SageMaker models into backend microservices, enabling dynamic decisioning for fraud detection and authorization logic.

Engineered zero-trust authentication layers using OAuth2, OpenID Connect, and JWT, tightly coupling identity-aware access with runtime behavior via policy-based enforcements.

Codified infrastructure-as-code with Terraform and AWS CDK, developing reusable modules for provisioning networking, IAM, Kubernetes clusters, and managed databases across environments.

Established contract-first API design workflows using OpenAPI/Swagger and enforced traffic governance via API Gateway, implementing edge-layer controls like JWT validation, rate limiting, and request throttling.

Applied Domain-Driven Design (DDD) to isolate business domains—like identity, access, and policy management—into bounded contexts, enabling modular ownership and decoupled service evolution.

Instrumented full-stack observability using OpenTelemetry, Cloud Trace, AWS X-Ray, and Prometheus, exposing latency, retry patterns, and failure hotspots across polyglot services.

Hardened containerized workloads using Kubernetes (GKE Autopilot, EKS), configuring PodSecurityPolicies, network segmentation, and automated sidecar injection for telemetry and compliance.

Automated end-to-end delivery pipelines with AWS CodePipeline, orchestrating unit tests, Docker image builds, and blue-green deployments to Fargate and EKS from GitHub workflows.

Tuned JVM services through garbage collection profiling, heap dump analysis, and non-blocking architecture patterns, achieving consistent low-latency performance even under traffic spikes.

Developed CI/CD pipelines with GitHub Actions, Jenkins, and Cloud Build, automating test coverage, SAST scans, Docker image builds, and zero-downtime blue-green deployments across multiple environments.

Conducted controlled chaos testing using Kubernetes fault injection, network latency simulators, and Gremlin, validating fallback mechanisms, auto-recovery strategies, and resilience SLAs.

Delivered unified data APIs via GraphQL alongside REST, reducing over-fetching and accelerating frontend release cycles by allowing consumers to query data adaptively.

Implemented enterprise-grade secrets and config management using AWS Parameter Store, Azure Key Vault, and Google Secret Manager, enforcing RBAC and access logging by default.

Established CIAM integrations using Okta, Auth0, and Azure AD, supporting both workforce and service identity flows with fine-grained role-scoping and token introspection.

Embedded policy-as-code via Open Policy Agent (OPA) and Kyverno into CI/CD workflows, enforcing deploy-time and runtime security/compliance across Kubernetes clusters.

Led design reviews and mentored cross-functional teams on container lifecycle best practices, distributed tracing patterns, service granularity, and multi-cloud portability strategies to drive long-term platform scalability.

TECHNICAL SKILLS

1.Programming Languages: Java, JavaScript, TypeScript, SQL, PL/SQL

2.Backend Frameworks & Libraries: Spring Boot, Spring MVC, Spring WebFlux, Spring Cloud, Hibernate, JPA, JDBC, REST, Cloud Platforms & Services: AWS (Lambda, ECS, EKS, Fargate, MSK, S3, API Gateway, DynamoDB, SageMaker, Wavelength, Step Functions, CloudWatch, X-Ray, CodePipeline, CDK, Parameter Store), Azure (App Services, AKS, Functions, SQL Database, Blob Storage, DevOps, Key Vault, Monitor), Google Cloud (Cloud Run, GKE Autopilot, Anthos, Cloud Spanner, Vertex AI Pipelines, API Gateway, Cloud Pub/Sub, Cloud Trace, Stackdriver)

3.Architecture & Patterns: Microservices, Reactive Architecture, Serverless, Domain-Driven Design, Contract-First APIs

4.DevOps & CI/CD: GitHub Actions, Jenkins, Cloud Build, Azure DevOps, AWS CodePipeline

5.Containerization & Orchestration: Docker, Kubernetes, Amazon EKS, Azure AKS, GKE

6.Infrastructure as Code (IaC): Terraform, AWS CDK, Azure CLI, Helm

7.Monitoring & Observability: OpenTelemetry, Prometheus, Grafana, AWS X-Ray, Jaeger, Stackdriver, Cloud Trace, Spring Boot Actuator, Azure Monitor

8.Databases: Cloud Spanner, Azure SQL, DynamoDB, MySQL, Oracle

PROFESSIONAL EXPERIENCE

Client: CyberArk, New York, NY Sep 2024 – Present

Role: Java Backend Engineer

Developed reactive microservices using Java 17 and Spring WebFlux to manage secure identity token issuance, enabling high-concurrency handling of secrets without thread blocking.

Deployed serverless APIs on Cloud Run for dynamic policy evaluation services, optimizing cold start latencies and autoscaling policies to meet unpredictable load conditions.

Built distributed stateful services on Cloud Spanner, modeling relational consistency with horizontal scalability for audit logging and user privilege management.

Conducted end-to-end audits of authentication and data exchange pipelines, validating TLS 1.3 configurations, mTLS policies, and Google-managed SSL certificates across all gRPC and REST interfaces to ensure compliance with zero-trust and encryption-in-transit standards.

Established CI/CD pipelines using Cloud Build and GitHub Actions, automating Docker image builds, security scans, integration tests, and blue-green deployments to Cloud Run and GKE.

Integrated Vertex AI Pipelines for automated model training and risk score inference, embedding ML predictions into backend authorization logic using secure service-to-service communication.

Implemented OAuth2 and OpenID Connect for zero-trust access control, integrating with BeyondCorp to enforce device-aware and identity-centric access across backend tiers.

Designed event-driven microservices with Cloud Pub/Sub, enabling decoupled processing of login events, privilege escalations, and alerting flows across services and third-party systems.

Deployed OpenTelemetry collectors as sidecars within GKE workloads, enabling rich distributed trace generation, with correlation IDs injected at the gateway and propagated via b3 headers to streamline incident root cause analysis.

Orchestrated workloads with GKE Autopilot under Anthos, applying pod autoscaling, network policies, and Google-managed security contexts for hardened container environments.

Enforced Domain-Driven Design by separating identity, access, audit, and policy domains, applying aggregate roots, value objects, and repository abstractions to isolate bounded contexts.

Developed and enforced contract-first APIs using API Gateway, controlling traffic, quotas, and JWT verification layers at the edge for all inbound service calls.

Automated infrastructure provisioning via Terraform, templating Cloud Run services, IAM policies, Spanner schemas, and monitoring configurations as reusable modules.

Hardened critical backend flows by embedding Resilience4j-based retry, timeout, and circuit breaker logic into reactive Spring WebFlux services, preserving availability during upstream failures under intermittent network issues

Instrumented services with OpenTelemetry and exported traces to Cloud Trace, enabling detailed visualization of service interactions, response times, and retry patterns under failure.

Facilitated technical design sessions and code reviews, advising cross-functional teams on effective service decomposition, telemetry instrumentation, and uniform error propagation strategies to enforce platform-wide observability and resilience.

Tuned reactive pipelines for backpressure handling and timeouts in Spring WebFlux, addressing memory pressure and latency spikes during traffic bursts.

Implemented service-level performance profiling for CPU/memory on GKE nodes, correlating JVM GC logs with container metrics to identify and fix memory leaks in long-running services.

Worked cross-functionally with Security, Machine Learning, and SRE teams to integrate threat detection, predictive risk scoring, and scalable infrastructure patterns into a cohesive zero-trust identity platform on Google Cloud.

Deployed scalable, fault-tolerant microservices using Java Spring Boot and RabbitMQ, designing asynchronous messaging patterns to ensure reliable inter-service communication and event-driven workflows.

Tech Stack: Java 17, Spring WebFlux, Anthos, GKE Autopilot, Cloud Run, Cloud Run, Cloud Spanner, Vertex AI Pipelines, OAuth2, OpenID Connect, BeyondCorp, API Gateway, Terraform, OpenTelemetry, Cloud Monitoring, Cloud Trace, Domain-Driven Design, Serverless Microservices, Event-driven Architecture, Microservices Patterns, GitHub Actions, Cloud Build, CI/CD, Performance Tuning

Client: Cisco, California, US Jan 2023 – Aug 2024

Role: Sr. Java Full Stack Developer

Engineered reactive microservices using Java 17 and Spring WebFlux, optimizing non-blocking I/O for telemetry ingestion services processing over 1M messages/hour from edge devices.

Designed event-driven microservices leveraging Amazon MSK (Kafka) and Spring Cloud Stream, implementing consumer retry policies and dead-letter topics for fault-tolerant stream processing.

Deployed serverless pipelines using AWS Lambda and API Gateway to handle lightweight compute workflows, eliminating container overhead and reducing cold start latency with provisioned concurrency.

Built low-latency, edge-optimized services on AWS Wavelength to support 5G network diagnostics, reducing round-trip latency by collocating services closer to user equipment.

Applied Domain-Driven Design to decouple bounded contexts across teams, using value objects and aggregates in core modules, and aligning microservice responsibilities with business capabilities.

Provisioned infrastructure using Terraform and AWS CDK, managing EKS clusters, MSK topics, S3 buckets, IAM policies, and custom VPC configurations with reusable and secure IaC modules.

Implemented secure authentication and authorization using OAuth2 and OpenID Connect, integrating with enterprise IdP to enforce scope-based access control across services and UI components.

Containerized services with Docker, deployed workloads on AWS Fargate and ECS, and used task definitions with IAM roles and secrets management via AWS Parameter Store.

Optimized microservice orchestration on Amazon EKS, configuring custom Horizontal Pod Autoscalers, pod affinity/anti-affinity rules, and network policies for efficient and secure deployments.

Instrumented services using OpenTelemetry, AWS X-Ray, and Jaeger, implementing distributed tracing to trace latency bottlenecks across async calls and external dependencies.

Integrated with AWS SageMaker endpoints to enable real-time ML inference within core Java services, embedding fraud scoring directly into transaction authorization flows.

Tuned JVM parameters and applied performance profiling to identify memory hotspots and thread contention in high-throughput WebFlux services, improving throughput underload.

Automated deployments using GitHub Actions and Jenkins, creating multi-stage CI/CD workflows for unit testing, security scanning (Trivy), Docker image builds, and EKS deployments.

Defined and enforced architectural patterns for Event Sourcing and Command Query Responsibility Segregation (CQRS) to decouple read/write responsibilities, improve auditability, and support high-throughput transaction processing in distributed systems.

Monitored production systems with AWS CloudWatch, defining custom metrics and anomaly detection alarms, and used dashboards to observe CPU, memory, and event loop performance.

Developed asynchronous workflows integrating AWS Step Functions and Lambda for long-running tasks such as user provisioning, email dispatch, and audit trail generation.

Conducted chaos testing scenarios on Kubernetes with pod eviction and network fault injection to ensure service resilience, measuring impact using Prometheus and Grafana metrics.

Led technical design reviews, introduced microservice resilience patterns (bulkhead, retry, circuit breaker), and enforced consistent error contracts and observability standards across teams.

Collaborated across backend, frontend, and DevOps teams to coordinate service contracts, reduce coupling, and maintain a shared schema registry for Kafka-based event payloads.

Tech Stack: Java 17, Spring WebFlux, Microservices Design Patterns, Event-Driven Architecture, OAuth2, OpenID Connect, AWS Lambda, AWS Fargate, Amazon ECS, Amazon MSK (Kafka), AWS SageMaker, AWS Wavelength, API Gateway, EKS (Kubernetes), Terraform, AWS CDK, GitHub Actions, Jenkins, AWS CloudWatch, AWS X-Ray, Jaeger, OpenTelemetry, DDD, CI/CD, IaC

Client: Progress Software, NY, United States May 2020 – Dec 2022

Role: Java Full Stack Developer

Built core services using Java 11, Spring Boot, and REST APIs to process billing and usage data, embedding error handling and retry logic for production resilience.

Used Spring Cloud Eureka for service discovery and Spring Cloud Config Server for centralized configuration, minimizing environment-specific code and improving deployment consistency.

Developed event-driven flows with AWS Lambda, API Gateway, and Step Functions to orchestrate transactional logic like invoice generation and notification dispatch, enabling serverless scalability.

Configured and managed API Gateway platforms such as Kong and Apigee to enforce authentication, rate limiting, request throttling, and JWT validation, ensuring secure and scalable API exposure across microservices.

Modeled high-volume activity logs in Amazon DynamoDB, tuning access patterns with partition keys and GSIs, and integrating data with Kinesis for downstream analytics.

Deployed containerized workloads on AWS Fargate using Docker, managing resource allocation and fault-tolerant job execution across parallel batch pipelines.

Enforced enterprise-grade security on microservices using Spring Security, implementing OAuth2, OpenID Connect, and JWT decoding to protect APIs with token-based SSO and dynamic RBAC policies.

Codified and modularized infrastructure with Terraform, provisioning AWS Lambda, API Gateway, IAM roles, and DynamoDB tables across staging and production with drift detection and plan validation.

Connected event-driven systems by integrating Apache Kafka, streaming user interaction and exception logs into downstream fraud detection and compliance analytics services with exactly once delivery semantics.

Developed GraphQL endpoints alongside REST APIs to support granular querying in client apps, reducing over-fetching and decoupling backend data contracts from frontend releases.

Participated in sprint planning, code reviews, and post-mortems, owning backend stories end-to-end and helping mentor newer team members on Spring Boot, Terraform, and AWS architecture.

Strengthening test reliability by designing layered test suites using JUnit 5 and Mockito, ensuring isolation of service logic and enabling contract-based testing across controller-service-repo boundaries.

Instrumented distributed tracing with AWS X-Ray, integrating trace headers in Spring Boot and Lambda invocations to diagnose latency spikes and detect cold start bottlenecks.

Deployed microservices to Amazon EKS using Helm charts, enforcing resource limits, readiness/liveness probes, and zero-downtime rollouts with progressive deployment strategies.

Integrated Spring Boot Actuators with Prometheus exporters, exposing custom business KPIs and health metrics for real-time monitoring via Grafana dashboards and SLO alerting.

Architected document ingestion and retention in Amazon S3, applying fine-grained IAM policies, bucket encryption, and lifecycle rules for compliance-grade storage management.

Environment: Java SE 11, Spring Boot, Spring Cloud, AWS Lambda, API Gateway, AWS Fargate, DynamoDB, Kinesis, Step Functions, CodePipeline, X-Ray, OAuth2, JWT, OpenID Connect, Docker, Kubernetes, Terraform, Kafka, Prometheus, REST, GraphQL, JUnit 5, Mockito

Client – Tavant Technologies, Chennai Jan 2018 – Nov 2019

Role – Java Backend Developer

Designed backend services using Java, Spring Boot, and REST APIs to handle high throughput claim adjudication workflows, streamlining processing delays and integrating dynamic premium logic.

Structured controller-service-repository layers using Spring MVC, enabling clear separation of concerns for claim submissions, approvals, and status retrieval.

Mapped complex entity relationships using Hibernate and JPA, ensuring ACID-compliant transactions and maintaining data consistency across policy and member modules in Azure SQL Database.

Built asynchronous processors with Azure Functions to offload heavy tasks like PDF generation and audit logging, improving API response times and enabling non-blocking operations.

Deployed microservices via Azure App Services, configuring deployment slots and startup scripts using Azure CLI, enabling blue-green releases without downtime.

Integrated Azure Key Vault to securely store API keys, client credentials, and DB secrets, replacing plain-text configuration and enforcing RBAC-based access control.

Utilized Azure Monitor and Log Analytics to track service health, set alerts on API latency and exception patterns, and proactively respond to degradation.

Implemented OAuth2 token-based authentication using Spring Security, facilitating secure partner API access while complying with identity and access policies.

Built and published CI/CD pipelines using Azure DevOps Pipelines, automating Maven builds, JUnit test execution, Docker image creation, and AKS deployments.

Stored user-uploaded claim documents and audit logs in Azure Blob Storage, with secure access via SAS tokens and lifecycle rules to control retention.

Containerized backend services with Docker, defining health checks, resource limits, and image versioning to maintain consistent environments from local to production.

Deployed services to Azure Kubernetes Service (AKS), configuring liveness/readiness probes, setting pod affinity, and managing autoscaling under traffic spikes.

Collaborated in Agile feature planning, taking ownership of backend deliverables, estimating story effort, fixing production incidents, and mentoring new joiners on CI/CD, Azure tooling, and secure backend coding practices.

Environment – Java SE, Spring Boot, Spring MVC, Hibernate, REST APIs, Azure App Services, Azure SQL Database, Azure Functions, Azure Key Vault, Azure Monitor, Azure DevOps, Azure Blob Storage, OAuth2, Docker, Kubernetes (AKS), GitHub, Azure CLI

Client – Persistent Systems, Bengaluru, India Jun 2015 – Dec 2017

Role – Java Developer

Developed backend services using Java and Spring MVC to externalize policy rules and claims workflows, replacing hardcoded logic with configurable rule engines.

Implemented dynamic UI pages using JSP and Servlets for agent onboarding, integrating validation and session control.

Built data access layers with JDBC and Hibernate to persist in user and policy data, ensuring accuracy and fail-safe rollbacks.

Developed REST APIs with JAX-RS to expose real-time claim status and policy search endpoints for partner integration.

Wrote unit tests using JUnit to validate service and persistence layers, preventing defects in downstream environments.

Managed builds and dependencies with Maven, standardizing configuration across developer and QA systems.

Configured Jenkins to trigger automated builds and test executions on version control commits, minimizing deployment errors.

Used Git for source control, handling feature branching, merging conflict resolution, and pull request reviews.

Deployed applications on AWS EC2, managing runtime variables and application logs in distributed environments.

Automated file storage and retrieval in AWS S3 using AWS CLI for centralized logging and document management.

Tuned SQL queries in MySQL and Oracle to enhance report generation and eliminate unnecessary table scans.

Collaborated in Agile sprints to analyze, fix, and verify production issues using stack trace analysis and RCA-driven patching.

Environment – Java, Spring MVC, JSP, Servlets, JDBC, Hibernate, MySQL, Oracle, REST (JAX-RS), JUnit, Maven, Git, Jenkins, AWS EC2, S3, AWS CLI

EDUCATION

Bachelor’s Degree

RGM College of Engineering and Technology 2015

Contact this candidate