Theme Accent
Download Resume (PDF)
Open to backend and distributed systems roles

Nikhil Sai Nambula

//Java Backend DeveloperSpring Boot MicroservicesDistributed Systems & Reliability

I build Java and Spring Boot services that stay up when a dependency does not. Three years in production on a platform serving 2 million users.

in production
users served
requests a day
LeetCode solved
production-cluster.tcs.aws
Healthy · 99.98%
Active Production Services
auth-service
14ms p9599.99% Uptime
order-orchestrator
24ms p95Circuit Protected
kafka-event-bus
0 Lag3 Partitions
P95 Cluster Latency (60s)
18.4 ms avg
-60s-30s● Real-time (18.4ms)
Redis Cache Hit Ratio

91.4%

-40% primary DB load
JPA Query Roundtrips

40 → 8

N+1 fetch elimination
Simulate failure & recovery states
Launch Lab →
JavaSpring BootMicroservicesKafkaRedisPostgreSQLKubernetesAWSDockerTerraformgRPCDistributed systemsObservabilityCircuit breakersReactSystem designJavaSpring BootMicroservicesKafkaRedisPostgreSQLKubernetesAWSDockerTerraformgRPCDistributed systemsObservabilityCircuit breakersReactSystem design

Engineering Mindset & Production Philosophy

Systems engineering grounded in measurement, resilient failure paths, and readable architectures that scale cleanly under production pressure.

I am a Java backend developer at Tata Consultancy Services, where I own three Spring Boot microservices end to end on AWS. The platform serves over 2 million users and about 50,000 requests a day.

Most of my work sits in the gap between working and keeping working. I redesigned JPA fetch strategies to kill an N+1 query pattern, which took a request from roughly 40 database round-trips down to 8. I built a Redis caching layer with per-key TTL policies that cut primary database load by 40%. I put circuit breakers, retry with exponential backoff and dead-letter queues in front of services that are allowed to fail.

Outside of work I grind DSA and design systems, which is where the 1000+ LeetCode problems and the low-level-design playground come from. AWS Certified Developer, Associate, 2026.

Current Role

Java Backend Developer · TCS

2M+ Active Users

Non-Negotiable Architecture Principles

01

Measure first

Every performance number I quote came off a query plan, a profiler or a load test.

02

Design the failure path

Timeouts, retries, poison messages and partial writes are where systems actually live.

03

Boring technology

A well-understood Postgres beats a distributed novelty at 3am.

04

Readable over clever

SOLID and named patterns exist so the next person can extend the code.

Technical Arsenal & Core Competencies

Applied in real production systems serving millions of requests, focused on backend resilience, clean architecture, and distributed data pipelines.

SP
Verified Production Impact

Spring Boot

Enterprise Backend
Key Performance Benchmark3 Microservices OwnedEnvironment: TCS Enterprise Platform
Production Implementation

Primary enterprise framework powering 3 microservices with Resilience4j circuit breakers, Spring Security, and REST APIs.

Live Inspection ActiveClick any skill to inspect

Languages

5 technologies

Low-level design

6 technologies

Frameworks & APIs

6 technologies

Distributed Architecture

8 technologies

Data stores

5 technologies

AWS Infrastructure

9 technologies

DevOps & Testing

11 technologies

Distributed Systems & Reliability Lab

Interactive models demonstrating resilience patterns, caching strategies, and event-driven architecture designed for high-availability production.

Resilience4j Pattern Simulation

Downstream Dependency Fault Tolerance

Adjust simulated failure rates to observe the state transition between normal execution, fail-fast circuit opening, and canary probing.

Circuit Breaker StatusSTATE: CLOSED
15%
0% (Healthy)50% (Trip Threshold)100% (Critical)
System Healthy (Traffic Passed)

Downstream failure rate is under the 50% threshold. Requests are passed directly to database and external services with full throughput.

Simulation Presets● Normal Active (15% Failures)
Real-time Circuit Topology & Wire State
SWITCH CLOSED · TRAFFIC FLOWING
Order ServiceInbound TrafficDownstream DBHealthy · 200 OKRedis & SQS DLQStandby Queue
Latency: ~16ms (Normal)Availability: 99.98% guaranteed
Live Service Telemetry
P95 Latency

16 ms

Normal processing
Availability

99.98%

Zero unhandled 500s
Active Strategy

Direct DB Connection

Synchronous
Live Traffic Stream
[REQ-101] GET /orders/984 → 200 OK (16ms) · DB Direct
[REQ-102] GET /orders/985 → 200 OK (18ms) · DB Direct
[REQ-103] GET /orders/986 → 200 OK (15ms) · DB Direct
Spring Boot Resilience4j Config

@CircuitBreaker(name = "orderService", fallback = "fallbackOrder")

@Retry(name = "orderRetry", maxAttempts = 3)

public OrderResult process(OrderReq req) { ... }

Java Backend Engineering & Microservices

Three years building and maintaining high-throughput Spring Boot services on AWS, serving over 2 million users and 50,000+ daily requests.

Full-time Java Backend RoleJune 2023 to present

Java Backend Developer

Tata Consultancy Services (TCS)·Hyderabad, India

Latency-30%JPA Redesign
Primary DB-40% LoadRedis Caching
Traffic Scale2M+ Users50K+ req/day
Event Stream0 LagKafka Decoupled

Core Platform Mandate

Three Spring Boot microservices owned end to end, from design through deployment and monitoring. Serving 2 million active users and 50,000+ requests daily.

Architectural Win: N+1 Query Elimination

Checkout endpoints suffered from excessive database roundtrips due to default Hibernate EAGER entity relations. Redesigned query strategies using batching and JPQL JOIN FETCH to preserve database health under peak burst traffic.

Legacy JPA Strategy
  • • ~40 database roundtrips / req
  • • N+1 query loop on items
  • • P95 Latency: 165ms
  • • DB Connection pool exhaustion
Optimized Fetch Strategy
  • • 8 database roundtrips / req
  • • LAZY + @BatchSize(25)
  • • P95 Latency: 24ms (-30%)
  • • 40% reduction in DB pool wait

Production Architecture Achievements

  • Reduced API latency by 30% by redesigning JPA and Hibernate fetch strategies, cutting database round-trips per request from about 40 to 8.
  • Cut primary database load by 40% with a distributed Redis caching layer using custom per-key TTL policies, which also improved P99 throughput under burst traffic.
  • Decoupled three downstream services by moving them onto a Kafka event-driven architecture instead of synchronous calls.
  • Implemented JWT and role-based access control across the REST APIs, and wrote the JUnit 5 and Mockito suites for the services I own.
Core Technologies Owned
JavaSpring BootAWSKafkaRedisPostgreSQLKubernetes

Engineering Projects & System Designs

Systems built from first principles focusing on concurrency, high availability, fault-tolerance, and practical architectural patterns.

Distributed SystemsEvent-Driven

ShopVerse

Distributed e-commerce backend platform

A distributed commerce platform built from scratch. Orders move through an explicit finite state machine rather than mutable status flags, and sessions live in Redis cluster with token-bucket rate limiting.

  • Java, Spring Boot and MongoDB on the backend, structured strictly around SOLID and clean architecture.
  • Stateless JWT authentication paired with Redis session management and automatic token revocation.
  • Optimistic locking mechanism on inventory models preventing duplicate deductions during high concurrency.
  • Automated CI/CD deployment pipeline with GitHub Actions, containerized with Docker.
JavaSpring BootMongoDBRedisJWTDockerReact
Computer VisionEncoder-Decoder CNN-LSTM Architecture

Recipe generation from food photos

Computer vision & deep learning pipeline

An end-to-end vision pipeline that parses raw dish images and predicts ingredient compositions. InceptionV3 and Xception convolutional feature encoders feed an LSTM sequential decoder.

  • Achieved 87% top-5 accuracy on a custom-annotated subset of the Food-101 benchmark.
  • Implemented transfer learning with fine-tuned top layers over dual frozen convolutional backbones.
  • Sequence decoding optimized using beam search with a width of 3 to output coherent ingredient lists.
PythonTensorFlowKerasInceptionV3XceptionLSTM
AI & ToolingDeterministic FormIR

ApplyPilot

AI Job Application Autofill Chrome Extension (Manifest V3)

A deterministic autofill Chrome extension (Manifest V3) with semantic field ontology and dynamic verification. Automatically identifies and accurately fills multi-page job applications using an intermediate representation (FormIR) and per-kind filling strategies without blind auto-submitting.

  • Built as a modular monorepo with Manifest V3 (background worker, content scripts, React side panel) paired with a Fastify API backend.
  • Engineered a deterministic 5-step pipeline: FormIR page scanning, semantic FieldMatcher ontology lookup, and per-kind AutofillExecutor.
  • Validated against a golden-question benchmark suite (126 entries across 35 intents) achieving >=95% accuracy, <5ms latency, and zero false positives.
  • End-to-end browser test automation with Playwright against a synthetic 7-page ATS simulator handling CAPTCHA, OTP, and dynamic DOM mutations.
TypeScriptChrome Extension (MV3)FastifyReactPlaywrightVitestZod

Credentials, Problem Solving & Education

Strong theoretical fundamentals in algorithms and distributed computing backed by recognized certifications and continuous problem solving.

Competitive Problem Solving

LeetCode: 1,000+ Algorithmic Problems Solved

View LeetCode Profile
Total Solved

1042+

Across all categories
Medium / Hard Ratio

656

63% advanced difficulty
Global Ranking

Top 3.8%

Top competitive percentile
Contest Rating

1860+

Biweekly & Weekly Contests
Difficulty DistributionEasy: 386 · Medium: 532 · Hard: 124
Algorithmic Mastery (Click to inspect patterns)
Core Paradigms & Invariants: Dynamic ProgrammingO(log N) & O(N) optimizations
Mastered Sub-patterns
  • • 0/1 & Unbounded Knapsack
  • • Longest Common Subsequence (LCS)
  • • Matrix Exponentiation & State DP
  • • Interval & Tree DP
Notable Problem Benchmarks
  • • Coin Change & Knapsack variations
  • • Edit Distance & Regular Expression Matching
  • • Burst Balloons (Hard)
2019 to 2023

SRKR Engineering College

B.Tech, Computer Science and Engineering

Bhimavaram, Andhra Pradesh · GPA 8.0 / 10.0

Key Computer Science Coursework

  • Data structures and algorithms
  • Operating systems
  • DBMS & Transaction Management
  • Computer networks
  • Object-oriented analysis and design
  • Distributed computing
  • Cloud computing
  • Design and analysis of algorithms
2026Amazon Web Services

AWS Certified Developer, Associate

Core cloud mastery covering EC2, Lambda serverless, DynamoDB, API Gateway, SQS queues, and IAM least-privilege security.

OngoingLeetCode Competitive

1000+ LeetCode Solved

Top 3.8% globally. Deep focus on dynamic programming, topological sorting, graph cycle detection, and memory-efficient algorithms.

Direct Engineering Channel & Collaboration

Actively open to full-time backend and distributed systems engineering roles. Send a direct message or connect across professional channels.

Send a Direct Message

Opens your email app with the message pre-filled and addressed to Nikhil.

Direct Channels

Preferred for immediate contact or recruiter outreach.

Current Base

Hyderabad, India (IST / UTC+5:30)

Available for Hire