Java Full-Stack Developer

Sai Kodali

Lead Java Full-Stack Developer/BPM Camunda Lead

732-***-**** ************@*****.***

LinkedIn: https://www.linkedin.com/in/sai-roopa-kodali-383680175/

Professional Summary:

8+ years of experience as a Java Full-Stack Lead Developer, delivering scalable enterprise applications using Java, Spring Boot, React.js, Angular, Kafka, and REST APIs.

5+ years of hands-on expertise in Camunda BPM (7.x & 8.x), including workflow modeling, DMN decision tables, Zeebe engine, and orchestration with microservices and external systems.

Built and deployed Java-based microservices integrating with Kafka, MySQL, MongoDB, and external APIs using Feign, WebClient, and Spring Data JPA.

Developed dynamic, responsive frontends using React.js, Angular (6–16), Bootstrap, Material UI, with form validation using React Hook Form and Angular Forms.

Designed and modeled workflows with BPMN, DMN, signal/timer/call events, multi-instance subprocesses, and Camunda purge strategies.

Created custom Camunda integrations: Java Delegates, external task clients, REST API connectors, and used Camunda Modeler for visual design.

Migrated legacy BPM applications to Camunda, with full instance migration, process versioning, and external orchestration.

Strong command over SQL (Oracle, MySQL) and NoSQL (MongoDB) for complex queries, joins, procedures, and optimization.

Created custom dashboards and monitoring plugins using Camunda Cockpit and Operate; managed production workflows.

Built and consumed RESTful/SOAP services using JAX-RS, JAX-WS, Apache CXF, and Spring REST.

Hands-on with AWS (EC2, S3, Lambda) and Azure (Functions, Blob, DevOps); used Docker/Kubernetes for deployments.

Wrote unit/integration tests with JUnit, Mockito, Jasmine, and used SonarQube for code quality and test coverage.

Monitored and debugged production systems using Log4j, Splunk, Dynatrace, and created recovery scripts for critical failures.

Participated in Agile ceremonies, handled JIRA workflows, and mentored junior developers across distributed teams.

Designed and maintained Drools rule flows, Spring AOP interceptors for logging, auditing, and security enforcement.

Created and executed Camunda cleanup strategies with batch jobs, SQL scripts, and custom admin APIs.

Designed end-to-end process automation solutions, improving operational efficiency with Camunda BPM and microservices.

Integrated Camunda BPM with cloud-based workflows, allowing seamless interaction between AWS Lambda, Azure Functions, and on-premises applications.

Managed highly available, distributed systems using Docker containers, Kubernetes orchestration, and CI/CD pipelines.

Extensively worked with Kafka Streams, KSQL, and real-time data streaming to process and visualize data for decision-making.

Led performance optimization efforts using SQL tuning, indexing strategies, and caching mechanisms to reduce latency.

Involved in DevSecOps practices for security integration in deployment pipelines, ensuring secure and compliant releases.

Developed automated test suites for full-stack applications, improving test coverage and minimizing regression issues.

Provided production support, troubleshooting critical issues, and offering solutions with zero SLA breaches.

Actively participated in code reviews, providing feedback and fostering best practices in agile team environments.

Technical Skills:

Programming Languages: Java, C, C++, Python, PL/SQL, Unix Shell Scripts, JavaScript, TypeScript

Frameworks & Technologies: Spring (Boot, MVC, Data, Security, AOP), Hibernate, JPA, Struts, Drools, EJB, jBPM

Frontend & Scripting: HTML5, CSS3, JavaScript, jQuery, AJAX, Angular (6–16), React.js, Bootstrap, Node.js, Kendo UI, JSON, XML

BPM Tools: Camunda 7/8, Zeebe Engine, DMN, Modeler, Cockpit, Tasklist, Appian

Web & Application Servers: Apache Tomcat, JBoss, WebLogic, WebSphere, RESTful & SOAP Web Services, JAX-RS, JAX-WS, Apache CXF

Databases: Oracle, MySQL, SQL Server, MongoDB, KSQL, Azure SQL

Cloud & DevOps: AWS (EC2, S3, Lambda), Azure (Functions, DevOps), Docker, Kubernetes, Jenkins, GitHub Actions, SonarQube

Build & Tools: Maven, Gradle, Ant, NPM, Postman, IntelliJ, Eclipse, Git, SVN

Testing & Monitoring: JUnit, Log4j, Mockito, Splunk, Dynatrace, JIRA

Design & Methodologies: OOP, MVC, DAO, Agile (Scrum), UML, REST, Microservices

Professional Experience:

Client: LPL Financial

Project: Return Mail & Account Deactivation

Project: Feb 2024 – Till Date

Role/Title: Java Full Stack Developer (with Camunda Expertise)

Work Location: Remote

Project Description: The Return Mail & Account Deactivation system automates the handling of undelivered mail by triggering intelligent account maintenance workflows. These processes update DOCA (Documentation of Customer Addresses), notify advisors based on document type, and ensure compliance with operational policies. Upon receiving files from Broadridge, data is extracted, validated, and pushed into internal systems, followed by archival for books and records. The workflow is built on Camunda 8.3, integrated with cloud services, Kafka, and a modern Java-based backend with a React.js frontend.

Responsibilities:

Developed and deployed full end-to-end BPM workflows using Camunda 8.3, BPMN, and DMN for process and business rule automation.

Designed and implemented Java-based microservices using Spring Boot to serve business logic, API consumption, data validation, and backend processing.

Built React. JS-based user interfaces for form rendering, task handling, and status dashboards, interacting seamlessly with Camunda and Spring Boot APIs.

Implemented responsive, reusable React components for dynamic forms, tables, modals, and notifications to enhance the UI experience.

Integrated React frontends with Java RESTful APIs using Axios/Fetch, enabling real-time data sync and task completion flows.

Configured client-side routing with React Router, added validation using React Hook Form and Yup, and styled using Material UI and Bootstrap.

Connected workflows to AWS S3 for file ingestion using Java logic, parsing and storing data locally for further processing.

Leveraged Kafka with Java consumers to initiate Camunda workflows based on return mail file events.

Used Camunda timer events and cron jobs written in Java to schedule background activities and automated flows.

Upgraded Camunda from version 8.2 to 8.3, refactoring workflows and ensuring compatibility with all Java services and connectors.

Developed custom Java APIs for Camunda workflow actions, facilitating external integrations and secured endpoints.

Orchestrated multi-step processes using Camunda call activities, ensuring synchronous handling between parent and child processes.

Consumed external RESTful services through Java clients for performing CRUD operations as part of workflow activities.

Used Camunda Operate and Tasklist to monitor performance and debug process bottlenecks with Java-based metrics tracing.

Applied ILM (Information Lifecycle Management) policies using Java routines, ensuring proper data retention.

Created containerized Java services using Docker and deployed them to AWS EC2 instances for scalability.

Integrated Camunda 8.3 marketplace connectors and developed custom Java handlers for business logic.

Built AI-assisted form builders in Camunda 8.3 with backend logic in Java and UI components rendered via React.

Used Prisma ORM with Java-based services to assess and remediate application vulnerabilities.

Enabled proactive advisor communication by sending notifications from BPMN via Java messaging services.

Provided end-to-end production support, including Camunda workflow troubleshooting, CPU utilization monitoring, and log analysis using Java tools.

Environment: Java, Spring Boot, React.js, JavaScript, HTML5, CSS3, Camunda 8.2, Camunda 8.3, BPMN, DMN, RESTful APIs, AWS (S3, EC2), Docker, Kafka, Prisma, Camunda Operate, Camunda Tasklist, Git, IntelliJ, Postman, JSON, YAML, Axios, React Router, React Hook Form, Bootstrap, Material UI

Client: OPTUM - UHC

Project: OCM 2.0 Platform

Duration: Sep 2022 – Jan 2024

Role/Title: Java Full Stack Developer / Camunda Lead Developer

Work Location: Remote

Project Description: Optum serves employers, government agencies, health plans, and direct healthcare services. The OCM 2.0 platform integrates Camunda for automating healthcare workflows, leveraging Java Spring Boot for backend and React.js/Angular for frontend development to improve business processes and scalability.

Responsibilities:

Enhanced Camunda workflows and developed custom Camunda REST APIs for patient referral management.

Integrated Java Spring Boot microservices for dynamic dashboard functionalities like filtering, searching, and sorting.

Implemented asynchronous patterns in BPMN processes to handle long-running workflows, improving scalability.

Upgraded Camunda from version 7.15 to 8.3 and developed customized Camunda APIs for improved system communication.

Created delegate classes and Java expressions for extending Camunda process capabilities.

Monitored Camunda workflows and integrated RPA bot orchestration using Java connectors.

Developed and tested Java services and Camunda workflows, ensuring quality and performance.

Deployed Java applications and Camunda processes via CI/CD pipelines on Azure.

Developed thread-safe XML APIs using Java DOM Parser for data processing.

Migrated legacy Flex applications to Angular, ensuring seamless Java backend integration.

Designed responsive UIs using React.js, Angular, Bootstrap, and CSS3.

Integrated HTTP functionality in Angular to interact with backend services and display dynamic data.

Created custom React components and a reusable UI component library for consistent frontend development.

Developed search and filter functionalities using Angular and React.js.

Implemented client-side form validations using Angular to ensure accurate data entry.

Built custom npm scripts for build, deployment, and testing processes.

Conducted unit testing for React and Angular components using Jasmine and Karma.

Promoted and deployed microservices and Camunda workflows using Jenkins.

Managed WebLogic Server deployments and Dockerized Java services for scalability.

Collaborated with onshore/offshore teams, business stakeholders, and participated in Agile sprints using Jira for task tracking.

Tested APIs using Postman and SoapUI to ensure end-to-end integration.

Environment: Java, Spring Boot, React.js, Angular 16, JavaScript, HTML5, CSS3, Bootstrap, Camunda 7.15, Camunda 8.3, RESTful APIs, GraphQL, Node.js, JUnit, Prisma, Git, GitHub, Jenkins, Docker, Azure, SQL Server, Postman, SoapUI, Sonar, WebLogic, Redis, Log4j, Swagger

Client: TRUIST – Infosys

Project: Credit Card, Lending, Consumer Deposits

Duration: Aug 2021 – July 2022

Role/Title: Java Full Stack Developer with Camunda Expertise

Work Location: Remote

Project Description: Truist, one of the largest banking companies in the U.S., leveraged Camunda across credit card, lending, and account opening workflows to streamline routing logic, fraud checks, and orchestration. The project focused on integrating BPMN automation with robust Java-based backend services and modern web-based frontend systems using Angular and Node.js.

Responsibilities:

Designed and implemented Camunda BPM workflows across multiple banking use cases with BPMN, timers, message events, call activities, and listeners.

Built Camunda Spring Boot applications with integration layers to interact with microservices using REST APIs.

Developed and integrated custom delegate classes and Java listeners for handling business logic and validations within Camunda.

Managed Camunda engine instances, including migration from version 7.14 to 7.15 and transitioning running instances to new versions.

Cleaned and optimized Camunda DB using cleanup scripts, purge processes, and instance archival APIs.

Created and managed custom external task clients, configured dependencies (POM), and resolved issues related to server restarts and performance.

Utilized AWS services (EC2, Lambda) to support BPM orchestration and scalable deployment.

Built reusable UI components using Angular 6/7/8, HTML5, CSS3, Bootstrap, and integrated with backend services using AJAX and JSON.

Enabled frontend navigation using Angular Router; implemented responsive designs with Bootstrap and dynamic views with Kendo UI.

Developed frontend components and handled state using Angular and Node.js, ensuring secure communication via JWT authentication.

Built and managed real-time dashboards by creating KSQL streams and tables, feeding dynamic frontend charts.

Interfaced with MongoDB using Mongoose and developed custom data services in Node.js.

Authored RESTful APIs, unit-tested with JUnit, and handled database persistence using Hibernate with Oracle 11g and SQL Server.

Supported CI/CD workflows with Git, NPM scripts, and Azure DevOps tools; used Agile methodologies with sprint-based delivery.

Contributed to infrastructure management and cloud operations within Microsoft Azure, applying security best practices and NSG configurations.

Environment: Java, Java EE, Spring Boot, Camunda 7.14/7.15, Angular 6/7/8, Node.js, HTML5, CSS3, Bootstrap, JavaScript, REST, KSQL, MongoDB, Mongoose, Oracle 11g, SQL Server, Hibernate, AWS (EC2, Lambda), Azure, JWT, Git, Log4j, JUnit, Tomcat 9, JSON, Kendo UI, GIT, NPM, Agile, Azure DevOps

Client: PwC (Vendor: Infosys)

Project: Request It

Duration: Jan 2019 – Aug 2021

Role/Title: Java Full Stack Developer (BPM Lead)

Work Location: Tampa, Florida (Onsite)

Project Description: "Request It" is PwC’s unified procurement platform offering end-to-end visibility from requisition to payment. It supports browsing, ordering products/services, invoice tracking, and processing core billing at various client levels and billing cycles. The system automates order processing using Camunda BPM integrated with enterprise-grade Java services and responsive frontend design, enabling efficient business process orchestration.

Responsibilities:

Automated order processing workflows using Camunda BPM with BPMN and DMN for dynamic decision making.

Migrated Camunda versions from 7.6 to 7.14; created migration plans and managed process definitions.

Designed custom Camunda Cockpit plugins and developed reusable Java delegate classes and REST endpoints.

Developed RESTful microservices using Java, Spring Boot, and Hibernate, handling CRUD operations and orchestration.

Implemented Spring MVC, Spring ORM, and Spring AOP for modular application development and transaction management.

Used Kafka for real-time data streaming and integrated it with Camunda processes.

Implemented server-side validations with Hibernate validators; used JPA for ORM and database access.

Created and maintained unit tests using JUnit, integrated logging via Log4j, and handled production support.

Designed and developed responsive UI pages using HTML5, CSS3, Bootstrap, JavaScript, and AJAX.

Built hybrid mobile views using Apache Cordova; ensured cross-browser compatibility and device responsiveness.

Developed dynamic and reusable UI components using jQuery templates and handled client-side validations.

Integrated UI with backend using AJAX, JSON, and RESTful APIs to deliver a seamless user experience.

Built scalable Node.js components to handle URL routing and backend logic.

Utilized Grunt and Node.js for build automation and implemented cross-platform solutions.

Responsible for transforming Figma mock-ups to working pages and ensuring UX alignment with business goals.

Performed system integration testing, bug fixes, and participated in agile ceremonies using JIRA.

Used JDBC, Callable Statements, and SOAP/REST Web Services for backend integration with Oracle DB.

Deployed applications on Tomcat 7.2 and WebLogic and managed configuration for multi-engine transaction handling.

Maintained and configured the Camunda shared engine on Tomcat using XML-based configuration.

Environment: Java / Java EE, Spring Boot, Camunda (7.6–7.14), Hibernate, REST/SOAP Web Services, Kafka, Tomcat 7.2, WebLogic, Oracle 11g, HTML5, CSS3, JavaScript, jQuery, AJAX, Bootstrap, Node.js, Apache Cordova, Log4j, JUnit, JDBC, JSON, JSP, Servlets, GIT, JIRA.

Client: Lumen Technologies (formerly CenturyLink)

Project: Configuration data Asset management Project

Duration: Feb 2016 – Aug 2018

Role/Title: Java/J2EE & Drools Developer

Work Location: Florida/Orlando

Project Description: Lumen Technologies provides broadband, voice and wireless services to consumers and businesses across the country. This application is used to track the assets and generate quotes for the assets based on the type of assets used.

Responsibilities:

Involved in SDLC Requirements gathering, Analysis, Design, Development and Testing of application using AGILE methodology (SCRUM).

Developed various product applications using Java, J2EE and related technologies

Designed and developed the entitlement module using JBoss rules engine Drools

Handled events and runtime errors using JSF event listeners and validations.

Used Drools to handle complex business rules using Rule Sets and Rule Flows.

Created a user interface with the help of JSF for standardized display technology, which was formalized in a specification through the Java Community Process.

Spring framework is used to implement Inversion of Control (IOC) and Aspect Oriented programming (AOP)

Worked extensively on Web Services (SOAP & REST), XML, JMS and Spring Controller.

REST (JAX-RS) web services have been developed to be consumed by a middleware module to push the communication centre messages into the web module.

Experienced with Java Multithreaded programming to develop multithreaded modules and applications, used Java Collections.

Involved in configuring and integrating Spring and Hibernate frameworks as the ORM tool to develop the persistence layer.

Used Spring MVC and restful web services such as Jersey, Axis frameworks.

Responsible for testing the classes and methods using Junit test case for unit testing of the application, and Log4j to capture the logs.

Developed the application using Spring Framework that uses Model View Controller (MVC) architecture with JSP as the view.

Developed web services using HTTP, SOAP and XML technologies.

Used Git as source control management, giving a huge speed advantage over centralized systems that have to communicate with a server.

Installed and configured JBOSS/Drools server with MySQL/Oracle persistence. Extracted rules data from the database and decision tables.

Involved in creating the EAR files and deploying them in the QA/UAT environments, and deployed applications on JBOSS.

Develop test test-driven framework (TDD) using Spring/Junit and Cucumber.

Created Drool rules in both rule flow and Drools Fusion for fetching the rule data from the database.

Created relevant staging tables to load the CSV files, identified the business validation rules. Created SQL Loader script generator application using UNIX shell scripting and PL/SQL.

Automated Quality Check tasks by creating PL/SQL procedures, cursors, functions and dynamic SQL. Enhanced it by creating exceptions for error handling. Created triggers for auditing purposes and created group, tabular and form reports.

Environment: JAVA, J2EE, Camunda Maven, Spring, CXF, Hibernate, Webservices, SOAP UI, XML, Javascript, AJAX, Angularjs, Grunt, Bootstrap, SASS, JSP, WSDL, SOAP, Log4j, JUNIT, JMockit, SPRING-IOC, JDBC Template, GIT, MVC, JBoss, eclipse, LINUX.

Client: Ikshura Solutions, India

Project: Payroll benefits system.

Duration: Aug 2013 – Mar 2015

Role/Title: Java/J2EE Developer

Project Description: Worked on annual enrollment project for Ikshura Solutions, India. The purpose was to provide benefits to employees. Tasks included requirement understanding, providing and supporting the implementation of business solutions by building relationships and partnerships with key stakeholders and identifying business needs in the Benefits project.

Responsibilities:

Involvement in phases of the SDLC Software Development Life Cycle, including Requirement, Design, Implementation, Testing and Maintenance

Involved in the development of back-end logic layer using Core Java features such as Collection Framework, I/O Generics, and Exception Handling programming.

Configured Spring MVC for the data communication between front-end and mid-tier to handle requests from the user and call the back-end services

Developed code for obtaining bean references in the Spring framework using Dependency Injection DI or Inversion of Control IOC

Integrated the middle tier using the Spring framework with the Hibernate ORM framework

Responsible for maintaining tables of users’ information. Configure Hibernate Mapping in an XML file and create HQL queries for Hibernate

Implemented DAO to maintain the data layer and used stored procedures

Used Hibernate for database operations such as query, update and delete to fulfil users’ requests

Design the Graphical User Interface GUI of the project using HTML5, jQuery, JavaScript CSS3 to improve visual effects on the dynamic front-end

Validate front-end input using JavaScript, Ajax and jQuery

Created RESTful-based web services using JAX-RS to provide results and generate monthly payment details

Developed various unit tests using JUnit for Integration and Functional testing

Implemented various confirmation emails and report emails using Java Mail technology

Used SVN for version control across the common source code used by developers

Interacted with users to present the new features of the system.

Environment: Java 6 Spring 4.0 Spring MVC Hibernate 4.5 Web Service Oracle 11g JDBC PL/SQL HQL HTML5 CSS3 JavaScript JSP AJAX jQuery Eclipse JUnit SVN

Education:

Master’s in computer science, Fairleigh Dickinson University, NJ, USA- 2017

Bachelor’s in Computer Science, JNTUH, INDIA- 2013

Contact this candidate