Java Developer Stack

Sindhu Kande

Sr. Full Stack Java Developer

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

PROFFESSIONAL SUMMARY:

Senior Full stack java developer with 11+ years building cloud-native, enterprise systems using Java, Spring Boot/Cloud/Security, and modern front-end stacks (React, Angular, Vue), delivering highly available solutions on AWS and Azure.

Designed and led microservices architectures with Spring Boot and Spring Cloud; implemented asynchronous messaging with Kafka and ActiveMQ; containerized services with Docker and orchestrated deployments on Kubernetes using Helm.

Built secure, low-latency REST and GraphQL APIs in Java/Node.js/TypeScript; validated and documented interfaces with Postman; enforced API governance and versioning across distributed teams.

Architected serverless and cloud-native workloads using AWS Lambda, Azure Functions, S3, ECS, ELB, and Auto Scaling; automated provisioning with Terraform and AWS CloudFormation for repeatable, compliant environments.

Delivered rich, responsive UIs in React, Angular, and Vue; applied Material-UI/Bootstrap/CSS with Redux/Context for state management and React Router for seamless navigation.

Engineered real-time and batch data pipelines with Apache Spark (Streaming), Scala, and Python; enabled high-throughput ingestion via Kafka; powered analytics with Elasticsearch and Amazon Redshift.

Implemented robust batch workflows using Spring Batch; optimized persistence with MongoDB, DynamoDB, Oracle, and MySQL via Spring Data JPA/Hibernate and effective schema/model design.

Established CI/CD at scale using Jenkins, GitHub Actions, and Bitbucket Pipelines; enforced quality with SonarQube and standardized builds with Maven/Gradle for consistent, traceable releases.

Improved performance and resiliency through Redis caching, Elasticsearch full-text search, and back-pressure/reactive patterns; achieved low-latency responses for high-concurrency workloads using WebSocket and reactive programming.

Secured platforms end-to-end with OAuth2.0, JWT, Spring Security, and SSO; implemented centralized policy, token management, and fine-grained authorization across microservices.

Centralized observability with Splunk, Prometheus, and Kibana; delivered actionable dashboards, real-time alerts, and proactive incident response for distributed, cloud-native systems.

Documented architectures and operating procedures using Confluence/Bitbucket Wiki/GitHub; mentored teams, drove best practices (TDD with JUnit/Mockito/Selenium), and led cross-functional delivery from design to production.

Designed high-throughput data platforms with Spark (batch & streaming), Kafka ingestion, and Elasticsearch/Redshift for analytics, aligning storage choices across Oracle/MySQL/MongoDB/Cassandra/DynamoDB use cases.

Implemented secure-by-default practices (OAuth2, JWT, Spring Security), centralized auth/SSO, and defense-in-depth for services and data in transit/at rest.

Built production-grade CI/CD with Jenkins/GitHub Actions/GitLab CI—trunk-based development, quality gates (SonarQube), unit/integration/e2e pipelines, blue-green/canary releases.

Operated Kubernetes at scale (Docker, Helm) with autoscaling, graceful rollouts/rollbacks, resource tuning, and fault-tolerant deployments across AWS/GCP/Azure.

Automated cloud infrastructure with Terraform/CloudFormation; standardized reusable modules/stacks for consistent, compliant, and auditable environments.

Established SLOs/SLIs and proactive observability using ELK/Kibana, Splunk, CloudWatch, and Prometheus to reduce MTTR and improve service reliability.

Optimized performance and cost via JVM tuning, query/index optimization, Redis caching, asynchronous I/O, and right-sizing compute/storage across environments.

Delivered feature-rich, responsive UIs with React/Angular/Vue, strong state management (Redux/Context/RxJS), and component libraries (Material-UI/Bootstrap).

Orchestrated batch workloads with Spring Batch and serverless jobs (Lambda/Azure Functions) for scalable, event-triggered processing.

Guided data modeling and migration strategies (schema evolution, zero-downtime rollouts, CDC), plus graph use-cases with Neo4j for recommendations and relationship insights.

Delivered integrations across heterogeneous stacks (Node.js, ASP.NET, Python) and messaging platforms, ensuring interoperability and consistent telemetry.

EDUCATION:

Bachelor’s in Jawaharlal Nehru Technological University, Hyderabad, India.

TECHNICAL SKILLS:

Category

Tools & Technologies

Programming Languages

Java (8, 11, 16, 17), JavaScript (ECMAScript 2016+), TypeScript, Python, Scala, C#, C, C++, Perl, Shell Scripting .

Frontend Technologies

React.js (with Redux, Hooks, Context API), Angular (9+), Vue.js, RxJS, HTML5, CSS3, Bootstrap, Material-UI.

Backend Frameworks

Spring Boot, Spring Cloud, Spring Security, Spring Data JPA, Spring Batch, Spring WebFlux, Django, Flask, Express.js, Play Framework, Microservices.

Databases

PostgreSQL, MySQL, Oracle, MongoDB, Cassandra, DynamoDB (with DAX), Redis, Neo4j,

Elasticsearch.

Messaging Platforms

Apache Kafka, RabbitMQ, ActiveMQ, AWS SQS, AWS SNS, Kafka Streams, Redis Streams.

Build & Automation Tools

Maven, Gradle, NPM, Jenkins, GitLab CI/CD, GitHub Actions, Nexus, Bazel, Apache Ant.

Version Control

Git, GitLab, BitBucket, AWS CodeCommit, SVN.

Cloud Platforms

AWS (EC2, RDS, Lambda, Fargate, ECS, EKS, S3, DynamoDB, CloudWatch, AppSync, Step

Functions), Google Cloud Platform (BigQuery, Dataflow, Dataproc, Kubernetes Engine, Cloud Functions), Microsoft Azure (App Services, Logic Apps, Event Grid, Functions), IBM Cloud, OpenStack.

DevOps Tools

Docker, Kubernetes, Helm, Terraform, AWS CloudFormation, Elastic Load Balancer (ELB), Auto Scaling, Jenkins Pipelines.

Monitoring & Logging

Splunk, New Relic, Prometheus,ELK Stack (Elasticsearch, Logstash, Kibana), AppDynamics, MongoDB Compass.

Integration Tools

Apache Camel, Spring Integration,IBM Integration Bus, Oracle Integration Cloud, SonarQube.

Testing Tools

JUnit, Mockito, Selenium, Cypress, Jasmine, Karma, Rest Assured, TestNG, Cucumber, PowerMock, Protractor, Jest, Spock.

API and Integration

RESTful APIs, GraphQL, WebSockets, OAuth2, JWT, API Gateway,, Event-Driven

Architectures, Kafka Connect, FIX Protocol.

WORK EXPERIECNE:

Client: Goldman Sachs, Atlanta, GA. Feb 2024 to present

Role: Sr. Full Stack Java Developer

Project Title: Capital Markets Trading & Risk Management Platform Project Description:

A platform that handles the full trade lifecycle capture, validation, execution, and settlement—for equities and derivatives. It keeps orders, positions, and risk figures accurate and secure, even during heavy market activity. Traders and risk teams use clear dashboards to view prices, order flow, and key alerts. Automated testing, streamlined releases, and continuous monitoring keep the system stable and reduce downtime. Comprehensive logging and audit trails support compliance and speed up investigations.

Responsibilities:

Developed microservices using Java17, Java 21 and Spring Boot/Cloud, implementing REST and GraphQL for high throughput trading, and standardized Kafka for low-latency, fault-tolerant trade communication.

Implemented secure authentication with Spring Security, integrating OAuth and JWT for FIX-compliant APIs, with API documentation and testing via Swagger and Postman.

Designed and processed trade-event streams using Apache Spark (Scala) and Kafka, integrating AWS Lambda for distributed, high-throughput processing.

Applied TDD and built CI/CD pipelines using Jenkins; deployed containerized services with Docker and orchestrated with Kubernetes on AWS.

Designed backend services using Kotlin and Node.js with reactive patterns for asynchronous trade processing; introduced in memory caching for order-book reads to ensure sub-millisecond responses.

Designed relational database schemas using Oracle, optimizing for low-latency execution and settlements; utilized Spring Data JPA for FIX-aligned trade data and complex SQL.

Built MongoDB stores for high-frequency tick data and trade histories, optimizing query performance for frequently accessed datasets.

Modeled instrument relationships and correlation data within the approved data stores to support advanced risk analytics.

Processed and queried large datasets using AWS Glue, stored curated data in S3, and queried historical trading events with Athena.

Centralized trade logs and metrics using AWS CloudWatch, monitoring latency and error rates and configuring alerts for issues affecting trade execution.

Developed single-page applications for trade and position monitoring using React, managing state with Redux and navigation with React Router; integrated data-fetch patterns with GraphQL.

Styled responsive, accessible UIs with HTML and CSS, modularizing components for tickers, order books, and position trackers.

Integrated market-data updates into dashboards using web Sockets, optimizing payloads with GraphQL to fetch only required fields.

Automated UI testing with Jasmine, Karma, and Selenium, validating trade placement, P&L, and portfolio workflows across browsers.

Optimized front-end performance with lazy loading and modularization to improve rendering of data-intensive dashboards.

Built analytics dashboards in React, integrating backend REST APIs to visualize margin exposure and derivative-position values.

Designed interactive forms in React for order entry and validation, integrating backend services via REST and applying accessible, consistent styles with CSS.

Configured centralized logging for UI interactions with AWS CloudWatch, tracking user response times and component performance for proactive debugging.

Developed modular, reusable front-end components with HTML/CSS, standardizing layouts for equity tickers and P&L trackers.

Validated end-to-end front-end workflows with Jasmine, Karma, and Postman, integrating suites into Jenkins pipelines.

Environment: Java 17, Java 21, Spring, Spring Boot, Spring Cloud, REST APIs, GraphQL, Node.js, Kafka, Active MQ, Redis, Jenkins, Docker, Kubernetes, AWS, Spark, Scala, Oracle, MongoDB, Kibana, Splunk, React, Angular, Vue.js, HTML, CSS, Bootstrap, Selenium, NPM, WebSocket, Postman, TDD, OAuth2, JWT.

Client: State of Georgia, Atlanta, GA. April 2021 to Jan 2024

Role: Full Stack Java Developer

Project Title : Enterprise Data Streaming & Reporting Hub Project Description:

An enterprise platform that consolidates high-volume data from multiple programs into a governed streaming hub. Apply common standards and validations to produce trusted, comparable information, then expose it through secure APIs and curated reports. Provides dashboards and scheduled reporting so leaders can track activity, trends, and exceptions with confidence. Built for scale and reliability with automation, monitoring, and role-based access, reducing manual effort and accelerating decisions.

Responsibilities:

Built reactive APIs with Spring WebFlux on AWS, integrating Amazon Kinesis to handle high-throughput streaming and concurrent requests.

Designed and deployed pipelines with Spring Batch and AWS Glue to transform large datasets into DynamoDB (operational) and Redshift (analytics) for fast access and reporting.

Implemented serverless workflows with AWS Lambda triggered by S3 and Kinesis to automate event-driven tasks and downstream processing.

Automated AWS infrastructure using CloudFormation and Terraform; deployed scalable services on ECS/EC2 with high availability and fault tolerance.

Designed and implemented microservices with Java/Spring Boot and Spring Cloud, integrating DynamoDB for operational data and Redshift for analytical workloads. Built secure REST/GraphQL APIs via API Gateway, integrating OAuth2/JWT and Cognito to enforce access control across backend services.

Automated CI/CD with Jenkins and SonarLint for quality checks; deployed containerized applications to AWS ECS/EKS with minimal downtime and safe rollbacks. Developed asynchronous streaming workflows using Amazon Kinesis to ensure reliable event handling and scalable throughput across services.

Created Node.js supporting APIs on AWS Lambda that read/write to DynamoDB and publish curated outputs to Redshift. Built ASP.NET supporting services on AWS integrating with DynamoDB and deploying ECS/EC2 for secure, scalable business workflows.

Implemented authentication and authorization with Spring Security, Cognito, and token-based OAuth2/JWT to provide robust identity management.

Migrated legacy storage to S3 with lifecycle policies; enabled ad-hoc querying and scheduled reporting via Redshift (and Athena for exploration).

Optimized read performance and latency by designing efficient access patterns and precomputed views on DynamoDB and Redshift.

Built analytics jobs with Apache Spark (Scala/Python) on Glue; prepared aggregates and metrics persisted in Redshift for reporting.

Developed batch ETL workflows with Python, Glue, and AWS Data Pipeline, producing standardized datasets in DynamoDB and Redshift.

Modeled NoSQL entities in DynamoDB (GSIs, partitions) to support application access patterns and integrated them with Spring Boot services.

Delivered supervisor and leadership dashboards using React.js and TypeScript, providing clear, live views of status, priorities, and trends.

Built responsive UI components with React.js and TypeScript, integrating backend GraphQL/REST APIs to surface actionable insights.

Developed interactive dashboards in React.js backed by Redshift datasets, enabling intuitive decision-making for operational analytics.

Conducted rigorous testing with JUnit, Mockito, and TestNG; validated APIs with Postman; enforced TDD practices and static checks with SonarLint to ensure stability, security, and maintainability.

Environment: Java 16, Java 17, Spring Boot, Spring, ASP.NET, Terraform, RabbitMQ, Kafka, AWS Services, GraphQL, Scala, Spring Security, Redis, AWS API Gateway, Terraform, Vue.js, Spark, React.js, TypeScript, JWT, Elasticsearch, DynamoDB, neo4j, Spring webflux, Python, OAuth2, AWS Glue, Postman, SonarLint, Jenkins, Redshift.

Client: State Farm Insurance, Bloomington, IL. Nov 2019 to Mar 2021 Role: Full Stack Java Developer

Project Title: Insurance Claims Platform Modernization Project

Description:

Modernized the companys claims platform to streamline how claims are filed, reviewed, and resolved. Unified customer and staff experiences so information flows cleanly from first report through settlement. Reduced handoffs and manual steps, cutting delays and improving accuracy across the process. Strengthened protection of personal data and improved system reliability and uptime. Created a flexible foundation that supports faster feature releases and future business needs.

Responsibilities:

Developed distributed systems using Java, JavaScript, Spring Boot, and Spring Cloud, integrating REST APIs, GraphQL, and secure authentication with OAuth2, JWT, and CSRF for efficient and secure client-server communication.

Deployed containerized applications using Docker, orchestrated their lifecycle with Kubernetes, and utilized Helm charts to simplify multi-environment deployment, ensuring high availability with automated scaling and load balancing.

Automated CI/CD pipelines using Jenkins, integrated test frameworks like JUnit, Mockito, and Karma, and enforced static code analysis with SonarQube to ensure high-quality builds and seamless production deployments.

Designed distributed data pipelines with Apache Spark and Scala, integrating Cassandra for distributed database storage.

Built real-time messaging systems enabling TDD practices using Kafka for distributed streaming, implementing Reactive Programming patterns to handle high throughput and backpressure efficiently.

Configured serverless workflows using Azure Logic Apps, Azure Blob Storage, and Azure Functions, automating deployment with Terraform and securing access with Azure Active Directory (AAD).

Created APIs with Node.js, implementing event-driven architecture to optimize performance, integrated documentation using Swagger, and validated endpoints with Postman to ensure proper functionality and compliance.

Designed secure applications by implementing OAuth2, JWT, and multi-factor authentication, securing sensitive data operations with CSRF protection and encrypted session management in a role-based access control environment.

Developed graph-based solutions for complex fraud detection scenarios, automated ETL pipelines with Python, and processed large datasets for real-time analytics.

Built backend services using Kotlin with Spring Boot and utilized Maven for efficient dependency management and build automation.

Designed analytics workflows with Apache Spark for large-scale data processing, stored datasets in Cassandra, reducing latency in real-time processing pipelines.

Developed high-concurrency RESTful APIs using PHP, Ruby, and Python, ensuring seamless scalability and reliable database operations in microservices environments.

Automated infrastructure deployment using Terraform, configured Kubernetes clusters with Helm, and built real-time, scalable applications using Azure Kubernetes Service (AKS).

Optimized queries and transactions in Oracle.

Integrated Cassandra for distributed database storage.

Developed responsive front-end applications with Angular, JavaScript, integrating WebSocket to deliver real-time updates and ensure an enhanced user experience across devices.

Created reusable UI components in TypeScript, validated functionality with Jasmine and Karma, and managed front-end dependencies to ensure consistency across development teams and environments.

Automated cross-browser compatibility testing with Selenium, integrating the testing pipeline into CI/CD workflows to validate dynamic web applications across multiple platforms and devices with comprehensive reporting.

Implemented event-driven architecture using Kafka and Node.js consumers to process transactions and trigger notifications.

Implemented asynchronous messaging systems, configured Websockets for bi-directional real-time updates, and ensured reliable communication in high-concurrency scenarios for interactive business dashboards.

Monitored application logs and system health with Elastic Stack, configured dashboards and visualizations using Kibana, and integrated Splunk for proactive alerting and real-time issue resolution in production environments.

Environment: Java 11, Spring Boot, REST APIs, GraphQL, Docker, Kubernetes, Jenkins, Spark, Cassandra, Kafka, Azure Services, Terraform, Node.js, Python, Angular, Websockets, Selenium, Elastic Stack, TypeScript, Oracle, Kibana, Jasmine, Karma, Maven, Helm, Spring Cloud, Swagger, Postman.

Client: First Citizens Bank, New York, NY. Mar 2018 to Oct 2019

Role: Full Stack Java Developer

Project Title: Payments & Fraud Monitoring Platform project description:

Built a bank-wide platform that processes card and account payments, checks for suspicious activity, and alerts the review team. It brings history and context together so investigators can quickly decide whether to approve, hold, or block a payment. Clear dashboards show trends, open cases, and outcomes.

Responsibilities:

Designed and implemented RESTful APIs and GraphQL using Spring MVC, documented workflows with Swagger, enabling live data updates using WebSockets, improving system interactivity and performance in distributed applications.

Automated builds and deployments with Maven for dependency management and pipelines, and provisioned infrastructure with Terraform, deploying containerized applications on Docker-based environments in Azure Cloud.

Developed scalable microservices using Java, Spring Boot, and Kotlin, integrated with Apache Kafka for event-driven messaging, and secured communication channels with OAuth 2.0 and JWT; deployed applications using Helm on Kubernetes.

Built robust event-driven systems using Apache Kafka, enabling synchronized communication across microservices, and integrated streaming pipelines with Spark and Scala for large-scale processing in production.

Developed batch processing workflows using Spring Batch, integrated ETL pipelines with YARN, and ensured reliability through comprehensive unit and integration testing using JUnit, Mockito, and API testing with Postman.

Designed and optimized database schemas for Oracle (SQL) and Cassandra (NoSQL), ensuring efficient query execution and indexing to enhance response times for high-traffic systems.

Built ETL pipelines using Apache Spark, Scala, and Spring Batch, transforming large datasets into analytical formats, and stored results in Cassandra to support advanced querying and reporting.

Enhanced data processing and analytics capabilities with search indexing and retrieval integrated with backend systems developed using Spring Boot, supporting timely query responses.

Developed automated data transformation workflows with Python, Perl, Maven, and YARN, extracting and transforming data from multiple sources and storing the results in Oracle and Cassandra for analysis and reporting.

Configured streaming data pipelines with test-first practices using Kafka; processed high-throughput event streams with Spark and persisted transformed data in Cassandra to ensure availability and scalability for analytical workflows.

Built dynamic single-page applications using React.js and TypeScript, focusing on responsive layouts and accessible components to improve user experience and application interactivity.

Tested frontend components and workflows using Jasmine, Karma, and Selenium, ensuring high reliability and crossbrowser compatibility, while validating API workflows using Postman and comprehensive test cases. Built reusable UI components with React.js, integrated with backend services developed in Spring Boot, and enabled live updates with WebSockets for enhanced interactivity.

Environment: Java 11, Spring Boot, Microservices, React.js, Node.js, Kubernetes, Docker, Kafka, RabbitMQ, GraphQL, REST,

Jenkins, Terraform, Elasticsearch, Redis, Cassandra, DynamoDB, Oracle, Apache Spark, Scala, Python, OAuth 2.0, JWT,Azure, Maven, Junit.

Client: AT&T, Dallas, TX. Dec 2016 to Feb 2018

Role: Java/J2EE Developer

Project Title: Telecom Customer Self-Service Platform Project Description:

Built a self-service experience that guides customers through everyday needs account updates, payments, plan changes, and support using simple steps and clear language to speed up completion and cut down on confusion.

Responsibilities:

Built and operated services on AWS, using ECS and Lambda where appropriate; monitored availability and performance with CloudWatch.

Designed REST and GraphQL APIs with Spring Boot/Spring Cloud, documented with Swagger, and validated integrations with Postman.

Implemented Apache Kafka for asynchronous messaging and Kafka Streams for high-throughput event pipelines.

Processed large datasets with Apache Spark (Scala) and scheduled Spring Batch jobs; persisted results to SQL Server (SQL) and MongoDB (NoSQL).

Containerized applications with Docker, deployed on Kubernetes, and managed releases and scaling using Helm; infrastructure defined with Terraform.

Ensured code quality with JUnit/Mockito/TestNG and enforced test-first development practices.

Developed a responsive Angular front end (HTML/CSS), integrating with backend APIs and supporting live updates where needed.

Secured services with OAuth2/JWT and Spring Security, including role-based access controls and audit logging.

Managed source control and reviews and supported automated pipelines for build, test, and deploy using Gradle.

Environment: Java 8, Spring Boot, Spring Cloud, REST, GraphQL, Swagger, Postman, AWS, Docker, Kubernetes, Terraform, Apache Kafka, Apache Spark (Scala), Spring Batch, HTML, CSS, SQL Server, MongoDB, OAuth 2.0, JWT, Spring Security, Gradle, JUnit, Mockito.

Client: Airtel (Bharti Airtel), Bangalore, India. Aug 2013 to Nov 2015 Role: Java Developer

Project Title: Telecom Event Streaming & Analytics Platform Project

Description:

Built a system that collects high volumes of activity from many sources, organizes it, and highlights unusual patterns. It gives operations and support simple views to track what’s happening, investigate issues, and measure outcomes helping reduce delays and improve decisions.

Responsibilities:

Built Java/Spring Boot microservices and used Kafka for publish/subscribe between modules.

Implemented data processing with Apache Spark (Scala) and Spring Batch for usage processing and analytics.

Modeled data in Oracle (SQL) for transactions and Cassandra (NoSQL) for high-throughput/time-series access; optimized queries, indexes, and stored procedures.

Exposed REST APIs with Spring MVC; added robust validation, pagination, and error handling; secured endpoints with OAuth2/JWT.

Containerized services with Docker and deployed to Kubernetes 1.0 on GCP (GKE) with environment-specific configs and rolling updates.

Automated builds and dependency management using Gradle; added unit/integration tests with JUnit/Mockito/TestNG.

Instrumented services for latency/throughput metrics and centralized logs; set alerts for SLOs to support quick triage.

Developed a single-page UI in AngularJS with HTML/CSS, including live updates via WebSockets for operational dashboards.

Defined infrastructure using Terraform on GCP (networks, clusters, service accounts) to standardize environments.

Managed source control and reviews with Git/Bitbucket; enforced coding standards through pull requests.

Environment: Java 8, Spring Boot, Spring MVC, Spring Cloud, REST, OAuth 2.0, JWT, Docker, Kubernetes, Google Cloud Platform (GCP), Gradle, Apache Kafka, Apache Spark, Scala, Spring Batch, Terraform, AngularJS, HTML, CSS, WebSockets, Git, Bitbucket, JUnit, Mockito, TestNG, Oracle (SQL), Cassandra (NoSQL).

Contact this candidate