Java Backend Developer with Spring Boot & REST APIs

Name – Vaishnavi B

Email - ********.****@*****.***

LinkedIn - www.linkedin.com/in/vaishnavi-b-1281803a3

Phone - 616-***-****

Professional Summary:

Java Developer with 2+ years of hands-on experience in designing, developing, and maintaining backend applications using Core Java, Spring Boot, Spring MVC, Hibernate/JPA, and RESTful APIs. Experienced in building microservices-based applications for insurance and digital banking domains, supporting customer onboarding, policy management, account management, and payment processing.

Strong understanding of service-layer architecture, database design, and data persistence using PostgreSQL and Oracle, with experience writing optimized SQL queries and managing entity relationships. Hands-on experience in implementing JWT-based authentication and using Spring Security (basic) to secure APIs and restrict access based on user roles.

Worked with Apache Kafka (basic) for asynchronous event processing such as notifications and transaction workflows. Experienced in writing unit tests using JUnit 5 and Mockito, performing API testing with Postman, and fixing bugs related to validation, performance, and security.

Familiar with AWS EC2 and S3, Docker (basic), Git/GitHub, and Maven for build and source control management. Comfortable working in Agile/Scrum environments, collaborating with frontend developers, QA, senior engineers, and product owners to deliver stable and secure applications.

A motivated team player with a strong willingness to learn, improve code quality, and contribute to scalable, reliable, and user-focused backend systems.

Technology Stack

Backend Technologies: Core Java, Spring Boot, Spring MVC, Spring Security (basic), Hibernate / JPA, RESTful Web Services.

Frontend Technologies: HTML5, CSS3, JavaScript, Angular (basic), React (basic), SPA fundamentals.

Databases: PostgreSQL, Oracle (basic SQL queries and joins).

Security: JWT-based authentication (basic understanding).

Messaging (Exposure): Apache Kafka (basic producer/consumer concepts).

Version Control & Build Tools: Git, GitHub, Maven.

Testing: JUnit 5, Mockito (basic unit testing), Postman (API testing).

Cloud & DevOps (Exposure): AWS (EC2, S3 – basic), Docker (basic).

Methodologies: Agile / Scrum, SDLC fundamentals.

Professional Experience

Company: RMI Systems Pvt. Ltd. Duration: Feb 2021 – Mar 2022

Role: Java Developer

Project 1: Insurance Policy Administration & Customer Management System

Project Overview

This project involved building a cloud-based insurance policy administration system that supports the complete customer lifecycle. The application was used to manage customers, insurance policies, premium payments, renewals, claims initiation, and notifications. The system was designed to handle high transaction volumes securely while complying with insurance regulations.

The application followed a microservices-based architecture, where each business module was developed as an independent service and exposed through REST APIs.

Key Contributions & Responsibilities

Worked on the development of backend services for an insurance policy and customer management system using Core Java and Spring Boot to support daily business operations.

Designed and developed RESTful APIs for key features such as customer management, policy creation, policy updates, and payment processing, enabling smooth communication between frontend and backend systems.

Implemented CRUD operations for customers, policies, nominees, and policy benefits using Hibernate and JPA, ensuring accurate and reliable data storage.

Used Spring MVC to manage API requests, controller logic, and application flow in a clean and organized way.

Designed service-layer components to separate business logic from controller code, improving code readability and ease of maintenance.

Designed and maintained database tables and schemas using PostgreSQL and Oracle for storing customer, policy, and payment information.

Wrote efficient SQL queries and joins to retrieve customer and policy data quickly and accurately.

Used JPA annotations to define database relationships such as One-to-Many and Many-to-One, ensuring proper data mapping between Java objects and tables.

Improved system performance by optimizing database queries, which reduced response times for policy searches and customer lookups.

Implemented JWT-based authentication to secure REST APIs and protect sensitive insurance information.

Used Spring Security (basic) to restrict API access based on user roles such as Admin, Agent, and Customer.

Ensured that sensitive customer and policy data was accessed only by authorized users, following basic security best practices.

Worked closely with frontend developers using HTML, CSS, JavaScript, Angular, and React (basic) to integrate backend services with user interfaces.

Supported Single Page Application (SPA) behavior by enabling smooth API communication without page reloads.

Integrated Apache Kafka (basic) to publish events for policy creation, policy renewals, and payment completion.

Consumed Kafka messages to trigger email and SMS notifications, improving system responsiveness.

Helped implement asynchronous processing so that notifications were sent in the background without slowing down main application flows.

Wrote unit test cases using JUnit 5 and Mockito for controller and service layers to ensure code quality and reduce errors.

Tested APIs using Postman to verify correct request and response handling.

Fixed issues related to data validation, API errors, and security problems, improving overall system stability.

Used Git and GitHub for source code management, following proper branching strategies and resolving merge conflicts.

Managed project dependencies and builds using Maven, ensuring consistent and reliable builds.

Assisted in deploying backend services on AWS EC2 (basic) and stored policy-related documents in AWS S3.

Used Docker (basic) to containerize applications for easier local development and testing.

Worked in an Agile/Scrum environment, actively participating in daily stand-ups, sprint planning, and sprint reviews.

Collaborated with QA, frontend, and DevOps teams to deliver stable and high-quality application releases.

Impact & Achievements

Reduced policy onboarding time by around 30% by automating customer and policy creation APIs.

Improved API response time by approximately 25% through database query optimization.

Enabled secure access for Admin, Agent, and Customer users using JWT-based authentication.

Successfully supported thousands of policy records without affecting system performance.

Reduced manual notification efforts by 40% by using Kafka-based asynchronous messaging.

Improved system reliability by writing unit tests that helped reduce production defects.

Contributed to smoother and faster deployments by using Docker containerization and Maven builds.

Company: RMI Systems Pvt. Ltd. Duration: Apr 2022 – May 2023

Role: Java Developer

Project 2: Cloud-Based Digital Banking & Payment Processing Platform

Project Overview

This project involved developing a cloud-native digital banking platform that supports customer onboarding, account management, fund transfers, bill payments, and transaction tracking. The system was designed to handle high-volume concurrent users while maintaining strict banking security and compliance standards.

The platform was built using microservices architecture, where each business capability was implemented as a separate service.

Key Contributions & Responsibilities

Designed and developed backend services for a cloud-based digital banking and payment processing platform using Core Java and Spring Boot, supporting critical banking operations such as customer onboarding, account management, fund transfers, bill payments, and transaction tracking.

Built and exposed RESTful APIs for banking functionalities, ensuring secure, reliable, and scalable communication between backend services and frontend applications.

Implemented layered architecture by designing Controller, Service, and Repository layers using Spring MVC, ensuring proper separation of concerns and maintainable code structure.

Utilized Hibernate and JPA to map Java entities to relational database tables, managing data persistence and transactional consistency across banking operations.

Developed clean, reusable, and maintainable business logic by following coding standards, best practices, and design principles, improving readability and long-term maintainability.

Worked extensively on payment processing workflows, including transaction initiation, validation, processing, and confirmation, ensuring accurate financial operations and proper transaction status handling.

Implemented data validations and business rules to prevent incorrect or duplicate transactions and to ensure secure and accurate processing of financial data.

Designed and maintained database schemas and tables using PostgreSQL and Oracle, supporting large volumes of transactional and customer data.

Wrote optimized SQL queries, joins, and filters to fetch transaction details, account balances, and customer information efficiently.

Improved application performance by optimizing frequently used database queries, reducing API response times and improving system responsiveness during high-volume transactions.

Ensured data integrity and consistency by handling transactional boundaries and error scenarios during concurrent financial operations.

Implemented JWT-based authentication to secure REST APIs and protect sensitive banking operations.

Configured Spring Security (basic) to enforce authentication and authorization, ensuring that only authenticated users could access protected banking features.

Assisted in securing APIs against unauthorized access by implementing role-based access controls and secure API communication practices.

Gained hands-on experience with Apache Kafka for asynchronous messaging and event-driven processing.

Developed and worked with Kafka producers and consumers to handle non-blocking operations such as transaction notifications and system events.

Understood and applied event-driven architecture concepts to improve system scalability, fault tolerance, and performance.

Collaborated with frontend teams using HTML, CSS, JavaScript, and basic Angular/React, ensuring smooth backend–frontend integration.

Supported SPA (Single Page Application) behavior by providing optimized API responses for seamless user experiences.

Resolved backend issues impacting UI behavior and addressed integration defects identified during functional and integration testing.

Wrote unit test cases using JUnit 5 and Mockito to validate business logic, improve code quality, and reduce regression issues.

Performed API testing using Postman to verify request/response payloads, error handling, and security validations.

Fixed bugs identified during unit testing, integration testing, and regression testing, ensuring stable releases.

Used Git and GitHub for version control, creating feature branches, managing pull requests, resolving merge conflicts, and following proper commit practices.

Managed project builds and dependencies using Maven, ensuring consistent builds across environments.

Gained hands-on exposure to AWS EC2 and S3, assisting in deploying backend services and managing application-related storage.

Containerized applications using Docker (basic) to support local development and testing environments.

Developed an understanding of CI/CD concepts, contributing to smoother build and deployment processes.

Worked in an Agile/Scrum environment, actively participating in daily stand-ups, sprint planning, sprint reviews, and retrospectives.

Collaborated closely with senior developers, QA teams, and product owners throughout all stages of the Software Development Life Cycle (SDLC), from requirement analysis to deployment and support.

Impact & Quantifiable Achievements

Supported high-volume banking transactions while maintaining stable performance and system reliability.

Reduced transaction processing failures by approximately 20% by improving validation logic and error handling mechanisms.

Enhanced API reliability and maintainability by implementing structured exception handling and standardized response formats.

Reduced manual effort in payment workflows by introducing Kafka-based asynchronous event processing.

Improved developer productivity by building reusable service components and common utility modules.

Strengthened application security by implementing JWT-based authentication and Spring Security configurations.

Successfully supported multiple production releases with minimal issues, contributing to smooth deployments and reliable banking operations.

Education:

Bhoj Reddy Engineering College for Women (BRECW), Bachelor's degree, Information Technology -2022

Franklin University Master’s degree, Information Technology - 2025

Contact this candidate