A production-oriented, distributed microservices platform providing intelligent resume parsing, semantic vector retrieval (RAG), AI-driven job discovery, and secure authentication across independent backend services and a modern React client.

                           TALENTPREP CLIENT
                        (React 18 + Vite + TS)
                                   │
                                   │ HTTPS / REST
                                   ▼
                         ┌───────────────────┐
                         │    API GATEWAY    │
                         │ (Spring Cloud GW) │
                         └─────────┬─────────┘
                                   │
                ┌──────────────────┴──────────────────┐
  /api/auth/**  │                                     │  /api/resumes/**
                ▼                                     ▼
     ┌─────────────────────┐               ┌─────────────────────┐
     │ AUTHENTICATION SVC  │               │ RESUME-RAG SERVICE  │
     │  (Spring Boot 3)    │               │  (Spring AI 2.0)    │
     └──────────┬──────────┘               └──────────┬──────────┘
                │                                     │
        ┌───────┴───────┐                     ┌───────┴───────┐
        ▼               ▼                     ▼               ▼
 ┌─────────────┐ ┌─────────────┐       ┌─────────────┐ ┌─────────────┐
 │  Supabase   │ │    Redis    │       │  Supabase   │ │    Redis    │
 │ PostgreSQL  │ │  (OTP/Auth) │       │  (pgvector) │ │ (Job Cache) │
 └─────────────┘ └─────────────┘       └─────────────┘ └─────────────┘
        │                                     │
        ▼                                     ▼
 ┌─────────────┐                       ┌─────────────────────────────┐
 │ Brevo SMTP  │                       │ Google Gemini / SerpAPI     │
 └─────────────┘                       │ (Embeddings & Job Search)   │
                                       └─────────────────────────────┘

• Microservices Architecture & Gateway Routing: Designed independent, decoupled services unified under a Spring Cloud Gateway with centralized route management, CORS handling, and WebClient-based downstream service health checks.
• Trusted Identity Header Propagation: Gateway validates incoming JWT tokens and injects trusted identity headers (X-User-Id, X-User-Email, X-User-Roles) to downstream microservices, ensuring internal service security without redundant auth checks.
• Enterprise Authentication & Token Lifecycles: Implemented dual-token authentication (short-lived access tokens and refresh tokens in HTTP-only SameSite cookies), Redis-backed OTP expiration, Redis JWT blacklisting, and Google/GitHub OAuth2 integration.
• Document Text Extraction Pipeline: Integrated Apache Tika to parse multi-format resumes (PDF, DOCX) into clean text streams for downstream AI processing.
• Semantic Vector Search & RAG: Built an embedding and vector retrieval pipeline using Spring AI 2.0, Google Gemini embeddings, and PostgreSQL pgvector to ground an AI Career Agent with user resume context.
• Target-Role Derivation & Cached Job Discovery: LLM extracts structured professional profiles and generates target roles, which are queried against SerpAPI (Google Jobs) and cached in Redis with TTLs to optimize external API quota.
• Resume Builder & Snapshot Versioning: Engineered versioned resume drafting and snapshot restoration workflows backed by Supabase PostgreSQL.
• Client Integration & Wake-Up UX: Developed a full-featured React 18 / TypeScript frontend with ATS score visualizations, interactive resume builder, PDF export, and health probe handling for cloud cold starts.

Java 17 Spring Boot 3 Spring Cloud Gateway Spring AI 2.0 Spring Security 6 PostgreSQL (Supabase) pgvector Redis Apache Tika Google Gemini SerpAPI React 18 TypeScript Vite

• 🌐 Live Application: talent-prep-frontend.vercel.app
• 🔗 Backend Monorepo: TalentPrep-Microservices — API Gateway, Authentication-Service, Resume-RAG-Service
• 🔗 Frontend Repository: TalentPrep-Frontend — React 18, TypeScript, Tailwind CSS client
• 🔗 Event-Driven Repository: TalentPrep-Backend — Kafka event-driven auth & email service modules
• 🖼️ Architecture Diagram: TalentPrep Overview
• 📌 Status: Microservices & Frontend Implemented; Deployed on Render & Vercel

A high-integrity financial backend engineered to execute concurrent monetary transactions with strict ACID guarantees, deterministic deadlock prevention, pessimistic locking, and post-commit event publishing.

  REST API Request (Deposit / Withdraw / Transfer)
                        │
                        ▼
            AccountController & DTO Layer
                        │
                        ▼
      AccountService (@Transactional Boundary)
                        │
       ┌────────────────┴────────────────┐
       ▼                                 ▼
 AccountRepository              TransactionRepository
 (PESSIMISTIC_WRITE Lock)       (Audit Log Persistence)
       │                                 │
       ▼                                 ▼
   MySQL DB                          MySQL DB
       │
       ▼ (On Successful Commit)
 TransactionSynchronizationManager ──► Kafka EventPublisher

• ACID Transaction Boundaries: All balance modifications wrapped in Spring declarative @Transactional boundaries with automatic rollback on runtime exceptions or business constraint violations.
• Pessimistic Concurrency Control: Implemented @Lock(LockModeType.PESSIMISTIC_WRITE) via findByIdForUpdate queries to lock account records at the database level, eliminating race conditions and lost updates during concurrent transfers.
• Deterministic Lock Ordering (Deadlock Prevention): Designed transfer logic to sort account IDs (Math.min(fromId, toId) then Math.max(fromId, toId)) before acquiring pessimistic locks, breaking circular wait conditions and eliminating database deadlocks.
• Precision Monetary Arithmetic: Enforced BigDecimal (precision 19, scale 4) throughout all entities, DTOs, and calculation services to prevent floating-point precision loss.
• Post-Commit Event Publishing: Integrated TransactionSynchronizationManager.registerSynchronization to publish Kafka audit events strictly after successful database commit, preventing ghost events on transaction rollback.
• Automated Testing & Mocking: Comprehensive unit and integration test suite using JUnit 5 and Mockito covering concurrent operations, boundary conditions, and insufficient balance scenarios.

Java 17 Spring Boot 3.1.5 Spring Data JPA Hibernate MySQL Apache Kafka JUnit 5 Mockito Lombok REST APIs

• 🔗 Repository: banking-transaction-system
• 📌 Status: Implemented & Tested

An asynchronous, multi-module backend demonstrating decoupled microservice communication via Apache Kafka for user lifecycle management and event-driven email delivery.

  Client Request ──► Auth Service ──► PostgreSQL / Redis (OTP)
                          │
                          ▼ (Publish UserRegisteredEvent / OtpGeneratedEvent)
                     Apache Kafka
                          │
                          ▼ (Consume Event)
                    Email Service ──► SMTP Mailer

• Multi-Module Maven Architecture: Structured as a modular monorepo containing auth-service, email-service, and a shared common-events contract module.
• Asynchronous Workload Offloading: Offloaded email generation and OTP notification delivery from the critical authentication path to Apache Kafka topics, reducing HTTP request latency.
• Shared Event Contracts: Maintained strong typing and schema consistency across producer and consumer services using the common-events shared library.
• Redis OTP Caching: Implemented time-to-live (TTL) expiration policies in Redis for secure, ephemeral OTP storage and verification.
• Containerized Orchestration: Configured multi-container local environments using Docker Compose for Kafka, Zookeeper, Redis, and PostgreSQL.

Java 17 Spring Boot Spring Security Apache Kafka Redis PostgreSQL Docker Compose Maven Multi-Module

• 🔗 Repository: TalentPrep-Backend
• 🔗 Standalone Auth Project: Authentication-System
• 📌 Status: Implemented

A full-stack AI-assisted content verification platform featuring a Spring Boot security backend, an NLP classification microservice powered by FastAPI, and an interactive React client.

  React Frontend ──► Spring Boot Backend (JWT Filter & RBAC) ──► MySQL
                            │
                            ▼ (REST Inference Request)
                     FastAPI ML Service (Hugging Face Spaces)

• Stateless JWT Security Architecture: Built custom JWT authentication filter integrated into the Spring Security filter chain with role-based access control (ROLE_USER, ROLE_ADMIN).
• Polyglot Service Integration: Connected Spring Boot API with a dedicated Python FastAPI service running ML classification models.
• Input Validation & Structured Exceptions: Comprehensive request payload validation with Hibernate Validator and centralized error handling via @RestControllerAdvice.
• Cloud Deployment: FastAPI ML inference engine hosted and deployed on Hugging Face Spaces Docker container.

Java Spring Boot 3.2.3 Spring Security Spring Data JPA JWT MySQL Python FastAPI Hugging Face React

• 🌐 Live Application: fake-news-frontend-ebon.vercel.app
• 🔗 Backend Repository: fake-news-backend
• 🔗 ML Microservice: fake-news-fastapi-ml  (Hugging Face Space)
• 🔗 Frontend Repository: fake-news-frontend
• 📌 Status: Implemented & Deployed (Vercel + Hugging Face)