React Developer Frontend

Sai Venkata Surendra Kondreddy

Sr. Frontend React Developer

Mobile: +1-774-***-****

Email: *************@*****.***

LinkedIn: www.linkedin.com/in/sai-venkata-surendra-kondreddy

PROFESSIONAL SUMMARY

I am an experienced Frontend React Developer with a decade of expertise in designing scalable enterprise applications. My focus is on backend microservices, cloud-native solutions, and building responsive React frontends that drive business efficiency.

Over 10 years of experience in designing, developing, and deploying enterprise-grade applications.

Strong expertise in Java 8–17, J2EE, Spring Boot, Spring MVC, Spring Cloud, Hibernate, JPA.

Skilled in microservices architecture with REST, gRPC, Kafka, and RabbitMQ communication.

Proficient in React (v15–18) for building responsive, modular, and scalable frontend applications.

Hands-on experience with JSP, Servlets, JSTL for legacy application modernization.

Expertise in REST API design, versioning, and GraphQL endpoints.

Experienced in Spring Security, OAuth2, JWT for authentication and authorization.

Implemented TLS/SSL for secure data transmission.

Worked extensively with SQL databases: Oracle, MySQL, PostgreSQL.

Experienced with NoSQL databases: MongoDB, Cassandra, DynamoDB.

Applied caching strategies using Redis and Hazelcast to optimize performance.

Built CI/CD pipelines using Jenkins, GitHub Actions, GitLab CI, and ArgoCD.

Skilled in containerization with Docker and orchestration with Kubernetes and Helm.

Developed serverless and event-driven solutions using AWS Lambda and Azure Functions.

Applied Agile Scrum and Kanban methodologies in project planning and execution.

Conducted unit testing using JUnit and Mockito, following TDD practices.

Implemented frontend testing with Jest, React Testing Library, Jasmine, and Karma.

Executed end-to-end testing with Selenium and Cypress for robust workflows.

Integrated third-party APIs and payment gateways in enterprise applications.

Applied SonarQube and static code analysis to ensure high code quality.

Monitored applications using CloudWatch, Prometheus, Grafana, and Azure Monitor.

Designed and maintained GraphQL endpoints for flexible frontend queries.

Mentored junior developers in React, Spring Boot, and microservices best practices.

Optimized SQL queries and NoSQL access patterns for high-volume transactions.

Implemented logging strategies using Log4j, SLF4J, and ELK Stack for observability.

Managed version control using Git, GitHub, GitLab, Bitbucket, SVN, CVS.

Designed modular React components with state management using Redux/Context API.

Applied responsive design principles using CSS3, Tailwind, and Material UI.

Worked on backend migrations, API refactoring, and legacy application modernization.

Ensured secure handling of secrets using AWS KMS and Azure Key Vault.

Built dashboards and reporting modules using React, TypeScript, and Material UI.

Applied performance profiling and optimizations on backend services and frontend UIs.

Implemented asynchronous messaging and event-driven workflows using Kafka and RabbitMQ.

Automated deployments with Terraform and CloudFormation for infrastructure provisioning.

Participated in cross-functional team collaborations with QA, BA, and DevOps.

Conducted code reviews and enforced coding standards and best practices.

Optimized batch jobs and background processes for high throughput.

Designed scalable REST APIs with proper exception handling and logging.

Maintained multi-environment deployments (Dev, QA, Staging, Production).

Adept at problem-solving, analytical thinking, and mentoring teams to achieve enterprise SLAs.

TECHNICAL SKILLS

Category

Technologies

Programming Languages

Java 8/11/16/17, SQL, PL/SQL, TypeScript, JavaScript, C, C++

Frameworks

Spring Boot, Spring Cloud, Spring Security, Spring Batch, Spring MVC, Hibernate 5, JPA, MyBatis, Struts 2.5, Node.js, JSP/Servlets, GraphQL, RESTful APIs, Microservices

Databases

PostgreSQL, Oracle, MySQL, MongoDB, Redis, Cassandra, DynamoDB, Azure SQL, Cosmos DB

Cloud Platforms

AWS (EC2, S3, RDS, Lambda, API Gateway, CloudFormation, CloudWatch, EKS, DynamoDB, IAM), Azure (AKS, API Management, Functions, SQL, Cosmos DB, Blob Storage, Key Vault), GCP

DevOps / CI-CD

Jenkins, GitHub Actions, GitLab CI, Azure DevOps, Travis CI, AWS CodePipeline, ArgoCD, Terraform, CloudFormation, ARM Templates

Containerization

Docker, Kubernetes (EKS, AKS), Helm, OpenShift

Security

Spring Security, OAuth2, JWT, SSO, RBAC, PCI-DSS, HIPAA, GDPR, TLS/SSL, AWS KMS, Azure Key Vault

Messaging / Streaming

Apache Kafka, Kafka Streams, Kafka Connect, JMS, AWS SQS, AWS SNS, RabbitMQ, Azure Service Bus

Monitoring / Logging

ELK Stack (Elasticsearch, Logstash, Kibana), Grafana, Prometheus, AWS CloudWatch, Azure Monitor, Application Insights, OpenTelemetry

Testing

JUnit 5, Mockito, Cucumber (BDD), Postman, JMeter, Selenium, Cypress, Jasmine, Karma, Jest, React Testing Library

Version Control

Git, GitHub, GitLab, Bitbucket, SVN, CVS

Application Servers

Apache Tomcat, IBM WebSphere, JBoss, WebLogic

Methodologies

Agile Scrum, Kanban, Waterfall, DevSecOps, Test-Driven Development (TDD), Behavior-Driven Development (BDD)

PROFESSIONAL EXPERIENCE

Client: New York Life Insurance, NYC, NY. October 2023 – Current

Role: Senior Frontend React Developer

Responsibilities

Developed RESTful microservices using Java 17, Spring Boot 3.x, Spring Cloud 2021.x.

Built React 18 dashboards with TypeScript and Material UI for responsive UI (frontend 30%).

Designed GraphQL APIs for flexible data queries and integration.

Implemented Spring Security with OAuth2 and JWT for secure API communication.

Enforced TLS 1.3 encryption for all inter-service communication.

Developed PostgreSQL schemas and optimized high-volume queries.

Integrated Redis caching to improve API response times.

Applied Apache Kafka for event streaming and RabbitMQ for messaging.

Built CI/CD pipelines with Jenkins, GitHub Actions, ArgoCD for automated deployments.

Containerized microservices with Docker and orchestrated using Kubernetes and Helm.

Provisioned AWS resources: EC2, RDS, Lambda, S3, API Gateway, EKS.

Automated infrastructure setup using Terraform and CloudFormation.

Conducted unit testing using JUnit 5 and Mockito following TDD principles.

Performed frontend unit testing with Jest and React Testing Library.

Executed end-to-end testing using Selenium across critical workflows.

Applied SonarQube for static code analysis and quality gates.

Monitored applications with CloudWatch, Prometheus, and OpenTelemetry.

Mentored junior developers on React, Spring Boot, and microservices best practices.

Designed API versioning strategy for backward compatibility.

Implemented exception handling and logging using Log4j and SLF4J.

Optimized database access and batch jobs for high throughput.

Integrated third-party payment and insurance APIs.

Participated in Agile Scrum ceremonies including sprint planning, retrospectives, and demos.

Refactored legacy services to adopt microservices architecture.

Implemented CI/CD rollback strategies and automated build validation.

Maintained API documentation using Swagger.

Collaborated with cross-functional teams to meet enterprise SLAs.

Developed reusable React components with state management using Redux/NgRx.

Conducted performance profiling and optimized server/frontend efficiency.

Ensured secure handling of secrets with AWS KMS and Azure Key Vault.

Environment: Java 17, Spring Boot 3.x, Spring Cloud, Hibernate 5, JPA, Microservices, Spring Security, OAuth2, JWT, TLS 1.3, REST API, GraphQL, React 18, Node.js, TypeScript, Material UI, PostgreSQL (AWS RDS), Redis, Kafka, RabbitMQ, AWS (EC2, S3, RDS, Lambda, API Gateway, EKS), Docker, Kubernetes, Helm, Terraform, CloudFormation, Jenkins, GitHub Actions, ArgoCD, SonarQube, JUnit 5, Mockito, Jest, React Testing Library, Selenium, Prometheus, CloudWatch, OpenTelemetry, Agile Scrum.

Client: Citizens Bank, Pittsburg, PA April 2020 – Oct 2023

Role: Senior Frontend React Developer

Responsibilities

Developed scalable microservices using Java 8, Spring Boot, and Spring Cloud.

Built React 17 dashboards with TypeScript and Material UI for responsive UI.

Designed RESTful APIs and GraphQL endpoints for claims processing.

Configured Spring Data JPA with PostgreSQL and MongoDB for structured and metadata storage.

Built Spring Batch jobs for nightly reconciliation and reporting.

Implemented Kafka pipelines and Kafka Streams for event-driven processing.

Deployed services on AWS EKS using Docker and Helm charts.

Applied Spring Security with OAuth2 and JWT for secure communications.

Optimized React components for performance and modularity.

Conducted unit testing using JUnit 5, Mockito, and applied TDD principles.

Executed frontend testing with Jest and React Testing Library.

Performed end-to-end testing using Cypress for UI and API integration.

Built CI/CD pipelines using Jenkins and GitLab for automated deployments.

Applied SonarQube for code quality checks and static analysis.

Implemented Redis caching for frequently accessed data.

Monitored application performance using AWS CloudWatch.

Mentored junior developers on Spring Boot, React, and microservices.

Collaborated with QA, BAs, and product owners in Agile Kanban environment.

Ensured compliance with TLS encryption and OAuth2 standards.

Designed REST API versioning strategy for backward compatibility.

Implemented exception handling and logging with Log4j and SLF4J.

Optimized database queries and performance tuning for high throughput.

Maintained Swagger API documentation.

Refactored legacy code for microservices adoption.

Automated deployment scripts with rollback mechanisms.

Integrated third-party payment and verification APIs.

Conducted sprint planning, backlog grooming, and daily standups.

Implemented caching strategies to reduce latency and improve scalability.

Tracked service metrics and Kafka stream performance for SLA compliance.

Environment: Java 8, Spring Boot, Spring Cloud, hibernate 5, JPA, Microservices, Spring Security, OAuth2, JWT, TLS 1.2, REST API, GraphQL, React 17, Node.js, TypeScript, Material UI, PostgreSQL, MongoDB, Redis, AWS (EKS, Lambda, S3, CloudWatch), Docker, Kubernetes, Helm, Jenkins, GitLab, JUnit 5, Mockito, Jest, React Testing Library, Cypress, SonarQube, Agile Kanban.

Client: State of Utah, Salt Lake City, Utah. October 2019 – February 2020

Role: Senior Frontend React Developer

Responsibilities

Developed microservices using Java 8 and Spring Boot for insurance claims.

Built React 16 dashboards with TypeScript and Material UI.

Designed REST APIs and GraphQL endpoints for claims portal.

Configured Spring Data JPA with PostgreSQL for structured data storage.

Built Spring Batch jobs for nightly reconciliation and compliance reporting.

Architected Kafka pipelines with partitioning and replication.

Developed Kafka Streams applications for real-time claims validation.

Deployed services on AWS EKS using Docker containers and Helm charts.

Implemented auto-scaling and fault-tolerant deployments.

Applied Spring Security with OAuth2 and JWT for secure communication.

Enforced TLS/SSL encryption for APIs.

Conducted unit testing with JUnit 5 and Mockito.

Executed BDD tests using Cucumber for business workflows.

Conducted frontend testing with Jest and React Testing Library.

Mentored junior developers and performed code reviews.

Participated in Agile Scrum ceremonies for workflow refinement.

Optimized database queries and indexing for PostgreSQL.

Monitored applications with AWS CloudWatch.

Designed relational data schemas using JPA.

Integrated RESTful APIs for external systems.

Automated CI/CD pipelines using Jenkins.

Implemented logging using Log4j and SLF4J.

Managed microservice communication patterns and async workflows.

Maintained GitHub repositories with proper branching strategies.

Optimized batch jobs for improved runtime.

Developed asynchronous notification workflows.

Ensured HIPAA compliance for sensitive data.

Performed end-to-end testing using Selenium for portal workflows.

Environment: Java 8, Spring Boot, Spring Cloud, hibernate 5, JPA, Microservices, Spring Security, OAuth2, JWT, TLS 1.2, REST API, GraphQL, React 16, Node.js, TypeScript, RxJS, PostgreSQL, Redis, Kafka, AWS (EKS, Lambda, S3, CloudWatch), Docker, Kubernetes, Helm, Jenkins, GitHub, JUnit 5, Mockito, Jest, React Testing Library, Selenium, SonarQube, Agile Scrum.

Client: Paypal, SFO, CA. July 2017 – October 2019

Role: Frontend Developer

Responsibilities

Developed microservices using Java 8 and Spring Boot for claims adjudication.

Built React 16 dashboards with TypeScript for real-time claim analytics.

Designed and implemented RESTful APIs and GraphQL endpoints to improve processing efficiency.

Configured Spring Data JPA with PostgreSQL for structured data and MongoDB for metadata.

Built Spring Batch jobs for automated nightly reconciliation and reporting.

Architected Apache Kafka pipelines for streaming claim events and implemented Kafka Streams applications.

Deployed services on AWS EKS using Docker containers and Helm charts.

Applied Spring Security with OAuth2 and JWT for secure API communication.

Conducted unit testing using JUnit 5 and Mockito; implemented TDD practices.

Executed BDD tests using Cucumber for workflow validation.

Performed end-to-end testing with Cypress for UI and API integration.

Built CI/CD pipelines using Jenkins and GitLab for automated builds and deployments.

Applied SonarQube for static code analysis and quality gates.

Implemented Redis caching for frequently accessed data to improve performance.

Monitored application performance using AWS CloudWatch.

Mentored junior developers on React JS, Spring Boot, and microservices best practices.

Collaborated with QA, business analysts, and product owners in Agile Kanban environment.

Ensured compliance with security standards including TLS encryption and OAuth2 authentication.

Designed asynchronous event-driven services with Kafka for high availability.

Optimized MongoDB queries and PostgreSQL interactions for faster processing.

Participated in sprint planning, daily standups, retrospectives, and demos.

Implemented logging with Log4J and SLF4J for backend services.

Conducted code reviews to enforce standards and TDD practices.

Developed REST API integrations with third-party payment services.

Performed root cause analysis for production issues and applied fixes.

Coordinated cross-team deployments for microservices across multiple environments.

Documented technical designs, API specs, and data flow diagrams.

Optimized React components and service calls for improved frontend performance.

Environment: Java 8, Spring Boot, Spring Cloud, Hibernate 5, JPA, Microservices, Spring Security, OAuth2, JWT, TLS 1.2, REST API, GraphQL, React 16, Node.js, TypeScript, Material UI, MongoDB, PostgreSQL, Redis, AWS (EKS, Lambda, S3, CloudWatch), Docker, Kubernetes, Helm, Jenkins, GitLab, JUnit 5, Mockito, Cucumber, Cypress, SonarQube, Agile Kanban.

Client: Lowe’s, Morrisville, NC. April 2015 - July 2017

Role: Frontend Developer

Responsibilities

Developed insurance policy management modules using Java 8 and Spring Boot.

Migrated legacy SOAP web services to REST APIs for faster integrations.

Designed Spring Data JPA entities mapped to MySQL for structured data management.

Built Spring Batch jobs for policy renewals, billing cycles, and compliance reporting.

Deployed backend services on Azure AKS and App Services with Docker containers.

Implemented microservices architecture for modular and scalable policy management.

Configured Redis caching for frequently accessed data to improve API response times.

Built React 16 dashboards with TypeScript for policy analytics.

Conducted unit testing with JUnit 5 and Mockito.

Performed frontend testing with Jest and React Testing Library.

Executed end-to-end testing using Selenium for critical workflows.

Built CI/CD pipelines with Jenkins and Git for automated builds, tests, and deployments.

Used SonarQube for static code analysis and code quality monitoring.

Monitored applications using Azure Monitor for performance and health checks.

Collaborated with business analysts and underwriters in Agile Scrum ceremonies.

Implemented Spring Security with OAuth2 and TLS for secure communication.

Mentored junior developers on Spring Boot, React, and microservices best practices.

Designed RESTful APIs for integration with internal and external systems.

Optimized SQL queries and database interactions for high performance.

Developed asynchronous messaging workflows for policy updates.

Participated in code reviews and enforced TDD practices.

Created reusable React components and libraries.

Implemented caching strategies to reduce latency.

Configured Azure Key Vault for secure credential management.

Maintained Git repositories with proper branching and PR workflows.

Conducted performance testing and optimized backend services.

Collaborated with QA for automated regression test suites.

Monitored application logs and configured alerts.

Coordinated deployments across multiple environments and releases.

Environment: Java 8, Spring Boot, Hibernate 5, Spring Security, REST API, SOAP, React 16, Node.js, TypeScript, MySQL, Redis, Azure (AKS, App Services, Blob Storage, Key Vault), Docker, Jenkins, Git, JUnit 5, Mockito, Jest, React Testing Library, Selenium, SonarQube, Agile Scrum.

Client: Palo Alto Networks, SFO, CA. May 2014 – April 2015

Role: Frontend Developer

Responsibilities

Developed retail applications using Java, J2EE, JSP, Servlets, and Hibernate 3.0 for order management.

Designed Spring MVC controllers and DAOs to manage transaction flows across inventory and billing systems.

Implemented SOAP web services using Apache CXF and REST APIs with JAX-RS.

Built Spring JDBC modules and Hibernate mappings for Oracle 10g database interactions.

Optimized SQL queries, reducing report generation time.

Created batch jobs for periodic reconciliation of sales and inventory data.

Deployed applications on IBM WebSphere with configured JNDI datasources.

Developed React 15 frontend dashboards for sales and inventory reporting.

Implemented secure messaging using JMS.

Conducted unit testing with JUnit and collaborated with QA for API validation.

Executed frontend workflow testing using Jest and React Testing Library.

Built CI/CD pipelines using Jenkins for automated builds and deployments.

Applied Docker for containerization of legacy applications.

Monitored applications using SonarQube for code quality and static analysis.

Developed and maintained SOAP/WSDL services for enterprise integration.

Ensured compliance with SSL/TLS security standards.

Mentored junior developers on JSP, Servlets, Spring MVC, and React best practices.

Coordinated with cross-functional teams for requirement gathering.

Participated in end-to-end delivery under Waterfall methodology.

Enhanced performance and scalability of legacy applications through refactoring.

Implemented logging with Log4j and SLF4J for backend monitoring.

Conducted integration testing of SOAP and REST services.

Maintained source control using Git with proper branching strategies.

Prepared technical design documents, flow diagrams, and API specs.

Improved data processing workflows using batch optimization.

Performed root cause analysis for production issues and applied fixes.

Assisted in production deployment and troubleshooting critical modules.

Applied performance profiling and optimization for backend and frontend.

Conducted peer code reviews and enforced coding standards.

Developed error handling and exception management strategies.

Environment: Java 8, Spring MVC, JSP, Servlets, Hibernate 3.0, Oracle 10g, SQL, JavaScript, React 15, Node.js, IBM WebSphere, JMS, SOAP/WSDL, Docker, Jenkins, Git, SonarQube, Jest, React Testing Library, Waterfall.

Contact this candidate