Distributed Systems
Architecting resilient distributed systems and scalable microservice patterns for enterprise workloads.
Java Backend Engineer & System Architect
Build scalable, secure, high-performance backend systems using Java, Spring Boot, Microservices, REST APIs, SQL, Docker, and Cloud technologies.

I am an MCA graduate and Java Backend Developer specializing in the Java & Spring Boot ecosystem. I focus on building production-grade microservices, secure REST APIs, and AI-powered RAG systems. My engineering approach is built on three pillars: Clean Code, Reliability, and Performance.
My work spans enterprise domains — hospital management, fintech expense tracking, ticket booking and distributed order systems — where correctness, authentication and query performance matter more than surface polish. I ship with Docker, PostgreSQL, Redis and CI pipelines wired in from day one.
Education
Master of Computer Applications (MCA)
Dr. A.P.J. Abdul Kalam Technical University
2022 — 2024 · Uttar Pradesh, India
Architecting resilient distributed systems and scalable microservice patterns for enterprise workloads.
Designing high-throughput APIs and robust server-side logic using modern Java and Spring ecosystems.
Engineering efficient data flows and high-performance storage solutions using PostgreSQL and Redis.
Implementing secure-by-design principles and fault-tolerant patterns for mission-critical apps.
A multi-layered ecosystem optimized for high throughput, maintainable microservices, and secure distributed data flows.
Jspider Private Limited
Developed production-grade Spring Boot microservices, secure REST APIs, and automated deployment pipelines.
Independent / GitHub
Shipping 69 public repositories, focused on Spring Boot services, Spring AI RAG pipelines and DSA practice in Java.
Live metrics pulled from GitHub on every render — stars, forks, languages and last activity are real.
Web Platform
IntermediateSpring Boot web application for online food ordering — browse menus, manage a cart and place orders, with an admin surface for menu and order management.
Restaurant ordering flows break under concurrent traffic — carts drift out of sync and admins lose visibility of incoming orders.
A layered Spring MVC application where ordering, menu and admin concerns are isolated behind services, with multithreaded order processing so concurrent placements never block each other.
Request flow
Spring MVC + Thymeleaf•Server-rendered flows keep cart state authoritative on the server.
Multithreading•Concurrent order handling without serialising the checkout path.
Spring Data JPA•Repository abstraction over the order and menu aggregates.
Enterprise Systems
ExpertFull-stack enterprise financial dashboard built on Spring Boot 3 and React 19, with JWT security, PostgreSQL persistence and Redis caching.
Finance dashboards aggregate the same expensive queries on every page load, and expense data must stay scoped per role.
A stateless Spring Boot 3 API secured by a JWT filter chain, with PostgreSQL as system of record and Redis caching the dashboard aggregates.
Request flow
JWT + Spring Security•Stateless auth that scales horizontally with no session store.
Redis•Read-through cache removes repeated aggregate scans on the dashboard.
PostgreSQL•Indexed reporting queries over transactional expense data.
Distributed Systems
ExpertHigh-performance movie ticket booking system built with Java, Spring Boot and React — premium dark-mode UI over a transactional seat-booking core.
Seat inventory is a classic race condition — two users must never book the same seat.
Transactional seat locking inside the booking service, so reservation and payment confirmation happen inside one atomic boundary.
Request flow
Transactional locking•Prevents double booking under concurrent seat selection.
PostgreSQL•ACID guarantees on the shows, seats and bookings tables.
REST + React•Real-time seat state rendered from a single API contract.
Enterprise Systems
AdvancedComprehensive, secure backend for hospital operations built with Spring Boot 3.x — users (patients, doctors, nurses, admins), appointments and medical records.
Hospital data is inherently multi-tenant by role — patients, doctors, nurses and admins must never see each other's records.
A role-partitioned domain model where every endpoint is authorised through Spring Security, with appointments and medical records isolated as independent service modules.
Request flow
Spring Security•Authorisation enforced at the endpoint, not in UI code.
Docker Compose•Reproducible environment parity across dev and staging.
PostgreSQL•Relational integrity for appointments and clinical records.
AI / RAG
ExpertRetrieval-Augmented Generation application built with Spring AI — document ingestion, vector search and AI-powered question answering over PDFs.
LLM answers over private documents hallucinate without grounded retrieval.
An ingestion pipeline that chunks and embeds PDFs into pgvector, plus a retriever that grounds every model response in the retrieved passages.
Request flow
Spring AI•First-class embedding and retrieval abstractions inside the Spring stack.
pgvector•Vector search next to relational data — one database to operate.
Chunked embeddings•Keeps retrieval precise on long documents.
Microservices
IntermediateSpring Boot service that generates unique short links for long URLs, exposing REST APIs for creation, retrieval and redirection.
Redirects are a hot read path — code generation must be collision-safe while resolution stays sub-millisecond.
A stateless REST service with a collision-safe short-code generator and a dedicated redirect controller kept off the write path.
Request flow
Stateless service•Horizontally scalable behind any load balancer.
Spring Data JPA•Simple, indexed lookups on the short-code column.
Dedicated redirect path•Read path isolated from creation logic.
Five areas that decide whether a backend holds up in production.
Contract-first endpoints that stay predictable under load.
The defaults I reach for when a service has to grow past a single instance.
01
Stateless services, horizontal scaling and clear bounded contexts per domain.
02
Single entry point for routing, auth propagation and cross-cutting concerns.
03
Read-through Redis layers on aggregate-heavy endpoints, with explicit invalidation.
04
Index design, query plans and connection pooling over premature sharding.
05
Idempotency, retries and failure isolation between service boundaries.
Interactive visualization of a production-grade Java microservice stack. Click components to inspect internal state or trigger a request flow.
Spring
Microservice
Redis
PostgreSQL
Select a component to view internal architectural details.
An interactive look at the Retrieval-Augmented Generation pipeline powering the AI assistant on this site.
The natural language request enters the system.
Text is converted into high-dimensional numerical vectors using an embedding model.
The vector is compared against a pgvector store to find relevant knowledge chunks.
Retrieved context + user query are passed to the LLM to generate a grounded response.
This simulation demonstrates how the backend uses pgvector for vector storage and Spring AI to orchestrate the retrieval flow, ensuring the AI assistant doesn't hallucinate and stays grounded in Rajeev's actual professional data.
Fetched server-side from the GitHub API — nothing here is hardcoded.
0
Public repositories
0
Stars earned
0
Followers
0
Recent Contributions
0
Last 12 months
0
Current streak
0
Best day
* Real-time client-side telemetry captured during current session initialization.
Automatic adjustment based on device capabilities and system preferences is enabled.
Each certificate links to its HackerRank verification page.
Have an idea, opportunity, or project in mind?
Let's connect.