Let's Build Together
Flexible With Timezones
Availability
Work type
Focus areas
Tech Stack
Let's Connect
I'm Ayush — a Backend Engineer & Product Builder based in Bihar, currently driving core systems at AlgoTutor. I don't just write APIs; I design the infrastructure that powers them. My flagship impact includes architecting a high-performance custom SQL compilation engine that reliably handles 30k+ daily critical runs.
I specialize in bridging the gap between robust backend architectures (Java/Spring Boot) and modern AI capabilities, leveraging OpenAI, Elevenlabs and Groq for intelligent product features. With a strong grip on Azure DevOps for bulletproof deployments, a LeetCode rating of 1735, and a passion for full-stack engineering, I transform complex technical bottlenecks into clean, scalable production realities.
AlgoTutor
Backend Developer · Bengaluru
Java · Spring Boot · Azure · OpenAI · PostgreSQL
3+
Years Backend Experience
Java · Spring Boot · Cloud
1735
LeetCode Rating
Problem Solver
Education
Rayat Group of Institutions
B.Tech · Computer Science & Engineering
2019 – 2023
8.10 CGPA
AlgoTutor · Remote
Careerjetty · Remote
AlgoTutor · Bengaluru, India
Freelance · Remote · Contract
Real-time query validation and scoring, running 30+ concurrent assessments a day with zero downtime.
Java 17 · Spring Boot · PostgreSQL · Azure
AlgoTutor
Secure code execution with SSO and shared-code tracking, built for high concurrency and audit-ready workflows.
Spring Boot · Docker · Redis
AlgoTutor
ATS resume scoring, JD matching and AI-content detection to keep evaluations fair and code quality high.
OpenAI API · Grok API · Spring Boot
AlgoTutor
Moved a legacy C# codebase to a modular Spring Boot architecture with full feature parity and better performance.
Java · Spring Boot · Azure CI/CD
AlgoTutor
Google Calendar integration for 1,000+ daily sessions, plus a real-time chat service for coordination.
Spring Boot · Kafka · RabbitMQ · AWS
Careerjetty
End-to-end ATS with status tracking, notifications and an ElasticSearch analytics dashboard across thousands of applications.
ElasticSearch · MySQL · Redis · JWT
Careerjetty
Built and shipped an online store for a friend's business, from catalogue to checkout.
Connected a family business's online store with its in-shop point-of-sale system.
Languages
Backend & Security
AI & LLM Integration
Cloud & DevOps
Messaging & Data
Tools & Testing
A production-ready JWT auth setup in Spring Boot — filter chain, token validation, refresh tokens, and the common mistakes that make your API insecure.
Two pointers is one of the most versatile DSA patterns. Here's every variant — opposite ends, fast-slow, and multi-array — with Java solutions and when to reach for each.
Designing a URL shortener end-to-end — Base62 encoding, hash collisions, database choice, caching layer, and how to handle 100M+ URLs at scale.
The N+1 query problem silently kills performance in Spring Boot apps. Here's how to detect it with Hibernate stats, and three strategies to eliminate it — JOIN FETCH, @EntityGraph, and projections.
Designing a rate limiter from scratch — three algorithms compared, Redis-based distributed implementation, and how Spring Boot API Gateway handles it in practice.
Sliding window is the go-to pattern for subarray and substring problems. Here's the fixed-size and variable-size templates, plus the counter trick that solves 'at most K' problems.
From a naive 900MB image to a lean 180MB multi-stage build — Dockerfile best practices, environment config, health checks, and Docker Compose for local dev.
Most people use binary search only on sorted arrays. But the real power is binary search on the answer space — solving problems in O(log n) that look like they need O(n) or brute force.
Beyond @Cacheable — TTL strategies, cache-aside vs write-through, cache warming, and how to handle cache invalidation without shooting yourself in the foot.
Designing a Kafka-like message queue — partitioning, consumer groups, offset management, at-least-once vs exactly-once delivery, and where each guarantee breaks down.
Stop memorizing DP solutions. Learn these 5 patterns and you'll recognize DP problems on sight — with Java implementations for each.
How I wired Kafka into a Spring Boot microservice — configuration, serialization, error handling, retries, dead letter topics, and the pitfalls that bit me in production.
After building both, here's my honest take — microservices are not always better. The decision framework I use, the hidden costs nobody talks about, and when a modular monolith wins.
BFS, DFS, Dijkstra, Union-Find, and topological sort — the templates and problem-recognition patterns you need to solve graph problems under interview pressure.
Stop returning 500s with stack traces. Here's a clean, centralized exception handling setup using @ControllerAdvice, custom exceptions, and structured error responses.
When a single DB instance isn't enough — horizontal sharding strategies, choosing a shard key, cross-shard queries, and the rebalancing problem nobody warns you about.
Monotonic stack is one of those patterns that looks magical until you understand the invariant it maintains. Next greater element, largest rectangle in histogram, daily temperatures — all solved with the same idea.
Wiring OAuth2 login, SSO with LinkedIn and Google, custom JWT issuance after OAuth handshake, and the session vs stateless trade-off you need to make early.
PriorityQueue in Java, max-heap vs min-heap, the K closest points trick, merge K sorted lists, and finding the Kth largest element — patterns and templates.
CompletableFuture patterns that actually appear in production code — parallel API calls, fan-out/fan-in, custom thread pools, timeout handling, and when to use Virtual Threads instead.
Designing Google-style search autocomplete — Trie data structure, prefix frequency ranking, caching layers, and how to serve 10,000 suggestions/sec with sub-50ms latency.
A testing strategy that actually works — when to use @WebMvcTest vs @SpringBootTest, mocking with Mockito, testcontainers for real DB tests, and the test pyramid for Spring Boot.
A production-ready JWT auth setup in Spring Boot — filter chain, token validation, refresh tokens, and the common mistakes that make your API insecure.
Two pointers is one of the most versatile DSA patterns. Here's every variant — opposite ends, fast-slow, and multi-array — with Java solutions and when to reach for each.
Designing a URL shortener end-to-end — Base62 encoding, hash collisions, database choice, caching layer, and how to handle 100M+ URLs at scale.
The N+1 query problem silently kills performance in Spring Boot apps. Here's how to detect it with Hibernate stats, and three strategies to eliminate it — JOIN FETCH, @EntityGraph, and projections.
Designing a rate limiter from scratch — three algorithms compared, Redis-based distributed implementation, and how Spring Boot API Gateway handles it in practice.
Sliding window is the go-to pattern for subarray and substring problems. Here's the fixed-size and variable-size templates, plus the counter trick that solves 'at most K' problems.
From a naive 900MB image to a lean 180MB multi-stage build — Dockerfile best practices, environment config, health checks, and Docker Compose for local dev.
Most people use binary search only on sorted arrays. But the real power is binary search on the answer space — solving problems in O(log n) that look like they need O(n) or brute force.
Beyond @Cacheable — TTL strategies, cache-aside vs write-through, cache warming, and how to handle cache invalidation without shooting yourself in the foot.
Designing a Kafka-like message queue — partitioning, consumer groups, offset management, at-least-once vs exactly-once delivery, and where each guarantee breaks down.
Stop memorizing DP solutions. Learn these 5 patterns and you'll recognize DP problems on sight — with Java implementations for each.
How I wired Kafka into a Spring Boot microservice — configuration, serialization, error handling, retries, dead letter topics, and the pitfalls that bit me in production.
After building both, here's my honest take — microservices are not always better. The decision framework I use, the hidden costs nobody talks about, and when a modular monolith wins.
BFS, DFS, Dijkstra, Union-Find, and topological sort — the templates and problem-recognition patterns you need to solve graph problems under interview pressure.
Stop returning 500s with stack traces. Here's a clean, centralized exception handling setup using @ControllerAdvice, custom exceptions, and structured error responses.
When a single DB instance isn't enough — horizontal sharding strategies, choosing a shard key, cross-shard queries, and the rebalancing problem nobody warns you about.
Monotonic stack is one of those patterns that looks magical until you understand the invariant it maintains. Next greater element, largest rectangle in histogram, daily temperatures — all solved with the same idea.
Wiring OAuth2 login, SSO with LinkedIn and Google, custom JWT issuance after OAuth handshake, and the session vs stateless trade-off you need to make early.
PriorityQueue in Java, max-heap vs min-heap, the K closest points trick, merge K sorted lists, and finding the Kth largest element — patterns and templates.
CompletableFuture patterns that actually appear in production code — parallel API calls, fan-out/fan-in, custom thread pools, timeout handling, and when to use Virtual Threads instead.
Designing Google-style search autocomplete — Trie data structure, prefix frequency ranking, caching layers, and how to serve 10,000 suggestions/sec with sub-50ms latency.
A testing strategy that actually works — when to use @WebMvcTest vs @SpringBootTest, mocking with Mockito, testcontainers for real DB tests, and the test pyramid for Spring Boot.
A production-ready JWT auth setup in Spring Boot — filter chain, token validation, refresh tokens, and the common mistakes that make your API insecure.
Two pointers is one of the most versatile DSA patterns. Here's every variant — opposite ends, fast-slow, and multi-array — with Java solutions and when to reach for each.
Designing a URL shortener end-to-end — Base62 encoding, hash collisions, database choice, caching layer, and how to handle 100M+ URLs at scale.
The N+1 query problem silently kills performance in Spring Boot apps. Here's how to detect it with Hibernate stats, and three strategies to eliminate it — JOIN FETCH, @EntityGraph, and projections.
Designing a rate limiter from scratch — three algorithms compared, Redis-based distributed implementation, and how Spring Boot API Gateway handles it in practice.
Sliding window is the go-to pattern for subarray and substring problems. Here's the fixed-size and variable-size templates, plus the counter trick that solves 'at most K' problems.
From a naive 900MB image to a lean 180MB multi-stage build — Dockerfile best practices, environment config, health checks, and Docker Compose for local dev.
Most people use binary search only on sorted arrays. But the real power is binary search on the answer space — solving problems in O(log n) that look like they need O(n) or brute force.
Beyond @Cacheable — TTL strategies, cache-aside vs write-through, cache warming, and how to handle cache invalidation without shooting yourself in the foot.
Designing a Kafka-like message queue — partitioning, consumer groups, offset management, at-least-once vs exactly-once delivery, and where each guarantee breaks down.
Stop memorizing DP solutions. Learn these 5 patterns and you'll recognize DP problems on sight — with Java implementations for each.
How I wired Kafka into a Spring Boot microservice — configuration, serialization, error handling, retries, dead letter topics, and the pitfalls that bit me in production.
After building both, here's my honest take — microservices are not always better. The decision framework I use, the hidden costs nobody talks about, and when a modular monolith wins.
BFS, DFS, Dijkstra, Union-Find, and topological sort — the templates and problem-recognition patterns you need to solve graph problems under interview pressure.
Stop returning 500s with stack traces. Here's a clean, centralized exception handling setup using @ControllerAdvice, custom exceptions, and structured error responses.
When a single DB instance isn't enough — horizontal sharding strategies, choosing a shard key, cross-shard queries, and the rebalancing problem nobody warns you about.
Monotonic stack is one of those patterns that looks magical until you understand the invariant it maintains. Next greater element, largest rectangle in histogram, daily temperatures — all solved with the same idea.
Wiring OAuth2 login, SSO with LinkedIn and Google, custom JWT issuance after OAuth handshake, and the session vs stateless trade-off you need to make early.
PriorityQueue in Java, max-heap vs min-heap, the K closest points trick, merge K sorted lists, and finding the Kth largest element — patterns and templates.
CompletableFuture patterns that actually appear in production code — parallel API calls, fan-out/fan-in, custom thread pools, timeout handling, and when to use Virtual Threads instead.
Designing Google-style search autocomplete — Trie data structure, prefix frequency ranking, caching layers, and how to serve 10,000 suggestions/sec with sub-50ms latency.
A testing strategy that actually works — when to use @WebMvcTest vs @SpringBootTest, mocking with Mockito, testcontainers for real DB tests, and the test pyramid for Spring Boot.
Open to full-time roles, contract work, or freelance gigs. Drop me a message — I reply within 24 hours.
ayushraj12009@gmail.com