Sr. Java full stack developer

Name: Punna sai teja

Sr. Java Full Stack Developer

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

Ph no: 954-***-****

PROFESSIONAL SUMMARY:

Proficient in Java with 10+ years of hands-on experience in Spring Boot, Spring Core, Spring MVC, Spring Data JPA, and Spring Batch, developing scalable and high-performance applications.

Skilled in building interactive and responsive user interfaces using React, Angular, Bootstrap, jQuery, JavaScript (ES6+), TypeScript, and AJAX, ensuring seamless user experiences.

Extensive experience in AWS (Lambda, EC2, S3, RDS, DynamoDB, Aurora, ELB, EBS, CloudFormation, CodePipeline, CodeBuild, CodeDeploy), GCP (App Engine, Cloud SQL, GKE, Cloud Storage), and Azure (App Service, Storage, DevOps, Data Factory, Logic Apps), ensuring cloud-native application development and deployment.

Strong experience developing RESTful APIs, GraphQL, and SOAP services using Spring Boot, Node.js (Express.js), and Java EE frameworks like JSF, Struts, and EJB, enabling smooth system integrations.

Adept at designing, developing, and deploying microservices-based applications with API Gateway, Netflix OSS components (Eureka, Hystrix), and event-driven architecture using RabbitMQ and Kafka.

Proficient in Terraform and Ansible for automated provisioning, configuration management, and IaC across cloud environments.

Hands-on experience with relational (MySQL, PostgreSQL, Oracle, Amazon Aurora, SQL Server) and NoSQL (MongoDB, DynamoDB), focusing on query optimization and performance tuning.

Deeply understand asynchronous messaging and real-time data streaming using Kafka, RabbitMQ, and JMS to build scalable and event-driven applications.

Proficient in Git, GitHub, BitBucket, and CI/CD pipelines using Jenkins, AWS CodePipeline, Azure DevOps, and Gradle/Maven for streamlined development and automated deployments.

Experienced in Agile (Scrum) methodologies, collaborating with cross-functional teams, ensuring efficient software development life cycle (SDLC) management, and delivering high-quality software solutions.

Proficient in Docker, Kubernetes (EKS, GKE, ECS), and containerized deployments for scalable and efficient application management in cloud and on-premise environments.

Strong background in Test-Driven Development (TDD) and Behavior-Driven Development (BDD) using JUnit, Mockito, Selenium, JEST, and Cucumber, ensuring high test coverage and application reliability.

Experienced in centralized logging, monitoring, and alerting using ELK Stack, Splunk, and AWS CloudWatch, ensuring application performance, security, and proactive issue resolution.

Adept at troubleshooting complex technical challenges, optimizing performance, and implementing best practices to ensure system efficiency and seamless functionality.

Strong collaborator in diverse teams, effectively communicating technical concepts and aligning development with business objectives for smooth project execution and stakeholder satisfaction.

TECHNICAL SKILLS:

Java Development: Java, JavaScript (ES6+), TypeScript, SQL, Spring Framework (Spring Core, Spring Boot, Spring MVC, Spring Data JPA, Spring Batch), Hibernate ORM, React, Angular, Bootstrap, jQuery, Express.js, Node.js, JSF, Struts, EJB

Cloud Technologies: AWS (Lambda, EC2, S3, RDS, DynamoDB, Aurora, ELB, EBS, CloudFormation, CodePipeline, CodeBuild, CodeDeploy), Google Cloud Platform (GCP - App Engine, Cloud SQL, GKE, Cloud Storage), Azure (Azure App Service, Azure Storage, Azure DevOps, Azure Data Factory, Azure Logic Apps)

DevOps and CI/CD: Jenkins, AWS CodePipeline, Docker, Kubernetes, ECS, EKS, Terraform, Ansible, Gradle, Maven, ANT

Web Technologies: HTML5, CSS3, LESS, SASS, JSP, AJAX, XML, JSON

Messaging and Streaming: RabbitMQ, Kafka, JMS

Version Control and Collaboration: GIT, GitHub, BitBucket, JIRA, Confluence

Database Management: MySQL, PostgreSQL, MongoDB, Oracle, Amazon Aurora, DynamoDB, JDBC

Microservices and APIs: Microservices Architecture, RESTful APIs, GraphQL, SOAP, Netflix OSS components (Eureka, Hystrix), API Gateway

Development Methodologies: Agile (Scrum), Software Development Life Cycle (SDLC), Requirement gathering and analysis, Documentation, TDD (Test-Driven Development)

Testing and Monitoring: JUnit, Mockito, Selenium, JEST, Cucumber (BDD), Log4j, ELK Stack, Splunk, CloudWatch

WORK EXPERIENCE:

Client : Newegg, CA

Sr. Java Full Stack Developer march 2023 - Present

Roles & Responsibilities:

Developed and optimized CRUD operations using Hibernate ORM, improving data persistence, transaction management, and query performance.

Designed and maintained relational and NoSQL databases, leveraging Amazon Aurora for structured data and DynamoDB for high-speed key-value storage.

Built serverless applications using AWS Lambda, reducing infrastructure costs while maintaining performance and scalability.

Designed and developed scalable microservices using Spring Boot and RESTful APIs, ensuring modular, high-performance applications.

Implemented Spring Batch to handle batch processing tasks, optimizing workflows for large-scale data processing and job scheduling.

Integrated Apache Kafka to enable event-driven architecture, ensuring seamless asynchronous data streaming and system communication.

Configured and optimized AWS EC2 instances, ensuring application availability with Auto Scaling and Elastic Load Balancer (ELB) configurations.

Developed dynamic front-end applications using React, with state management handled through Redux and React Router for smooth navigation.

Designed APIs supporting JSON and XML formats, ensuring compatibility with diverse client applications and third-party integrations.

Leveraged Netflix OSS components such as Eureka for service discovery, Zuul for API gateway management, and Hystrix for circuit breaking.

Implemented Spring Security with Role-Based Access Control (RBAC), enforcing granular authentication and authorization policies.

Enhanced development collaboration and efficiency through interactive API documentation created with Swagger.

Performed unit and integration testing using JUnit and Cucumber, ensuring high code coverage and system reliability.

Automated CI/CD pipelines using Jenkins, Git, and Ansible, streamlining code deployments and reducing manual intervention.

Maintained and migrated JavaServer Faces (JSF) applications, refactoring legacy systems for improved performance and maintainability.

Orchestrated containerized deployments using AWS ECS, AWS EKS, and Kubernetes, ensuring high availability and fault tolerance.

Configured and deployed JBoss application servers, fine-tuning performance for large-scale enterprise applications.

Developed Express.js microservices, implementing lightweight, efficient backend services for enhanced API performance.

Monitored and analyzed system logs using the ELK Stack (Elasticsearch, Logstash, Kibana) to detect and resolve issues proactively.

Implemented AWS CloudFormation templates, enabling automated and repeatable cloud infrastructure provisioning.

Designed scalable solutions using microservices architecture, enabling high performance, fault tolerance, and rapid feature deployment.

Optimized application performance, using caching strategies, database indexing, and API response time improvements.

Mentored junior developers, conducting regular code reviews, knowledge-sharing sessions, and enforcing best coding practices.

Followed Agile methodologies such as Scrum, actively participating in Sprint Planning, daily stand-ups, and backlog refinement.

Generated Jasper Reports, extracting business insights from structured data and supporting executive decision-making.

Utilized JIRA for project tracking, managing sprints, user stories, and bug fixes in an organized and efficient manner.

Environment: Hibernate, Spring Boot, RESTful APIs, Spring Batch, Apache Kafka, AWS, React, Redux, React Router, Netflix OSS (Eureka, Zuul, Hystrix), Spring Security, Swagger, JUnit, Cucumber, Jenkins, Git, Ansible, Kubernetes, JBoss, Express.js, ELK Stack (Elasticsearch, Logstash, Kibana), AWS CloudFormation, Jasper Reports, JIRA.

Client :StockX,NJ

Java Full Stack Developer Feb 2022 - March 2023

Roles & Responsibilities:

Designed and developed microservices-based architectures using Java, Spring Boot, and RESTful APIs, ensuring scalability and high performance.

Utilized Spring Framework, IoC, and DI to create modular, loosely coupled, and maintainable applications.

Developed interactive web applications by engineering front-end components with React and integrating them with backend microservices.

Developed and deployed backend services using Node.js, optimizing API performance and enabling real-time data processing.

Managed cloud infrastructure with AWS EC2, S3, and Lambda, ensuring reliable and cost-effective deployment solutions.

Developed and scheduled Spring Batch jobs to efficiently process large volumes of data and ensure robust ETL workflows.

Implemented Aspect-Oriented Programming (AOP) in Spring Boot, improving logging, security, and transaction management.

Configured and optimized AWS Elastic Load Balancer (ELB) and API Gateway, enhancing traffic management and security.

Optimized application performance using multi-threading and parallel processing, enhancing data computation and request handling.

Built and integrated SOAP Web Services for seamless system communication, improving interoperability between legacy and modern applications.

Implemented GraphQL APIs to optimize data retrieval, enabling clients to fetch only the required data and improving application efficiency.

Created dynamic, responsive UIs (HTML5, CSS3, SASS) for cross-browser compatibility and user-friendly experiences.

Implemented JWT Authentication for secure user access control, ensuring data protection and compliance with industry standards.

Containerized applications with Docker and orchestrated deployments using Kubernetes, improving system scalability and resource management.

Developed and executed unit tests using JUnit and Jest, ensuring code reliability and reducing bugs before production releases.

Automated UI and end-to-end testing with Selenium, improving test coverage and reducing manual QA efforts.

Deployed enterprise applications on WebLogic Server, optimizing configurations for high availability and performance.

Actively participated in Agile methodologies, contributing to sprint planning, backlog grooming, and daily standups for efficient project execution.

Utilized Gradle for dependency management and build automation, optimizing project efficiency and reducing build times.

Designed relational and semi-structured data schemas using PostgreSQL and explored graph-based data modeling approaches (Neo4J) to evaluate complex relationships and dependencies within system entities.

Defined and enforced security policies using AWS IAM, ensuring proper access management across cloud resources.

Monitored system performance with AWS CloudWatch, automating alerts to identify and resolve issues proactively.

Leveraged BitBucket for source code management, following Git branching strategies and enabling collaborative development.

Automated CI/CD pipelines using Jenkins, streamlining code integration, testing, and deployment processes.

Collaborated with cross-functional teams to enhance DevOps practices, ensuring seamless development-to-deployment workflows.

Environment: Java, Spring Boot, RESTful APIs, SOAP, GraphQL, Microservices, Spring Framework, IoC, DI, AOP, Spring Batch, Multi-threading, React.js, Node.js, HTML5, CSS3, SASS, PostgreSQL, AWS EC2, S3, Lambda, RDS, IAM, ELB, API Gateway, CloudWatch, JWT Authentication, Kubernetes, Docker, BitBucket, Git, Jenkins, WebLogic Server, Selenium, JUnit, Jest, Gradle, Agile, Scrum.

Client: Regions financial corporation, SC

Java J2EE Developer Jan 2020 - Jan 2022

Roles & Responsibilities:

Designed and developed scalable microservices using Java, Spring Boot, and RESTful APIs, ensuring efficient communication between services.

Developed single-page applications (SPAs) using Angular, TypeScript, Material UI, and RxJS, ensuring dynamic and interactive user experiences.

Designed and optimized NoSQL databases using MongoDB, improving data retrieval speed and scalability.

Implemented Spring Data JPA for seamless data access, optimizing queries and improving application performance.

Applied Aspect-Oriented Programming (AOP) to enhance logging, security, and transaction management while improving code modularity.

Integrated RabbitMQ for asynchronous messaging, enhancing system responsiveness and decoupling microservices.

Implemented JDBC and integrated Google Cloud SQL, enabling secure and high-performance relational database interactions.

Deployed, managed, and scaled applications on Google Cloud Platform (GCP) using Google App Engine and Google Kubernetes Engine (GKE).

Leveraged Google Cloud Storage for cost-effective and secure storage of unstructured data.

Actively participated in Agile and Scrum methodologies, contributing to sprint planning, backlog grooming, and daily stand-ups for seamless project execution.

Designed CI/CD pipelines using Jenkins to automate build, test, and deployment workflows, ensuring faster release cycles.

Monitored application performance and logs using Splunk, enabling real-time issue tracking and debugging.

Managed Maven for project dependencies and build automation, enhancing developer productivity.

Conducted unit and integration testing using JUnit, ensuring code reliability and reducing production defects.

Deployed and maintained Java applications on WebLogic Server, ensuring high availability and scalability.

Utilized Angular CLI for efficient project scaffolding, build automation, and dependency management.

Designed and developed responsive UI components using HTML5 and CSS3, enhancing front-end user experience.

Utilized Git for source code management, ensuring collaboration and code integrity.

Fostered high-quality coding standards through code reviews, constructive feedback, and mentorship of junior developers.

Integrated various third-party APIs, ensuring seamless data exchange and system interoperability.

Created comprehensive technical documentation, improving knowledge transfer and ensuring maintainability of applications.

Implemented OAuth 2.0 and token-based authentication, ensuring secure API access and user authorization.

Environment: Java, Spring Boot, Microservices, RESTful APIs, Spring Data JPA, AOP, RabbitMQ, Angular, TypeScript, Material UI, RxJS, Angular CLI, MongoDB, JDBC, Google Cloud SQL, GCP App Engine, GKE, Cloud Storage, OAuth 2.0, Splunk, Agile, Scrum, Jenkins, CI/CD, Maven, JUnit, WebLogic Server, HTML5, CSS3, Git.

Client: KeyBank, OH

Java Software Engineer May 2016 - Dec 2019

Roles & Responsibilities:

Developed and maintained Java-based applications using the Spring Framework, leveraging Dependency Injection (DI) and Inversion of Control (IoC) to build modular and maintainable code.

Deployed and managed cloud-based applications on Microsoft Azure, leveraging Azure App Service for hosting and Azure Storage for scalable data management.

Developed and orchestrated ETL workflows using Azure Data Factory (ADF) to automate data transformation and integration across various sources.

Built highly available, fault-tolerant distributed systems, implementing strategies to improve resilience, scalability, and system reliability.

Wrote unit tests with Mockito and JUnit, ensuring high code coverage, early bug detection, and maintaining software reliability.

Designed, built, and exposed RESTful APIs and SOAP Web Services, enabling seamless data exchange and integration between distributed applications.

Implemented robust messaging solutions using Java Message Service (JMS) to ensure reliable, asynchronous communication across microservices.

Created interactive and responsive web applications with HTML, CSS, JavaScript, Angular, AJAX, and jQuery, enhancing the user experience.

Utilized Hibernate ORM for efficient database management, optimizing queries, caching, and ensuring smooth transactional operations.

Automated build and deployment processes using CI/CD pipelines in Azure DevOps, ensuring efficient delivery and integration.

Applied the Spring MVC framework and Model-View-Controller (MVC) pattern, developing structured and scalable enterprise applications.

Worked with Apache ANT to automate build processes, ensuring consistency, repeatability, and reducing manual intervention.

Leveraged Visual Studio Code and other IDEs for efficient coding, debugging, and optimizing Java applications.

Troubleshot and optimized application performance, identifying bottlenecks and improving response times for a seamless user experience.

Managed version control using Git and GitHub, following best branching, merging, and repository maintenance practices.

Performed peer code reviews, providing constructive feedback to enhance code quality, maintainability, and adherence to industry standards.

Developed Java-based web components using JSP and Java Standard Tag Library (JSTL) to enhance server-side UI logic.

Utilized Agile methodologies (Sprint Planning, Standups, Retrospectives) for continuous improvement and timely deliveries.

Environment: Java, Spring Framework, DI, IoC, MVC, RESTful APIs, Microservices, SOAP Web Services, JMS, Hibernate, HTML, CSS, JavaScript, Angular, AJAX, jQuery, Azure App Service, Storage, ADF, ETL, JUnit, Mockito, Azure DevOps, Git, Agile, Apache ANT, GitHub, Visual Studio Code.

Client: Andhra Bank - Hyderabad

Jr. Java Developer June 2014 - July 2015

Roles & Responsibilities:

Built dynamic and interactive web pages using JavaServer Pages (JSP) and integrated Custom Tag Libraries to improve code reusability and maintainability.

Worked with the Struts Framework to develop enterprise-grade web applications following industry best practices.

Deployed, managed, and monitored applications on AWS EC2 instances to ensure high availability and performance.

Developed and maintained Java-based applications using the Model-View-Controller (MVC) architecture to ensure modular and scalable software design.

Designed and implemented Enterprise JavaBeans (EJB) for robust business logic processing and efficient transaction management.

Created and deployed Java Servlets to handle HTTP requests, enhancing web application functionality and performance.

Designed and implemented AWS Lambda functions for serverless computing, improving scalability and reducing infrastructure costs.

Managed and optimized relational databases using AWS RDS, ensuring high-performance data storage and retrieval.

Developed and executed optimized SQL queries while focusing on database indexing, query tuning, and normalization to enhance database performance.

Implemented Log4j for efficient logging and error handling, enabling better debugging and application monitoring.

Monitored application performance, identified bottlenecks, and optimized overall system efficiency.

Integrated AWS S3 for secure and scalable data storage, implementing best practices for data retrieval and lifecycle management.

Created and consumed SOAP Web Services for seamless system integration and data exchange between distributed applications.

Followed version control best practices using Git, collaborating with teams to maintain a clean and efficient codebase.

Environment: Java, MVC, EJB, Java Servlets, JSP, Custom Tag Libraries, Struts Framework, AWS EC2, Lambda, RDS, S3, SQL, SOAP Web Services, Git, Log4j.

Contact this candidate