sv.

hey, i’m sonu.

building, breaking, figuring it out.

I’m a backend & AI engineer based in India. Most days, you’ll find me somewhere between a Python script, a stubborn bug , and an idea that seemed simple an hour ago.

I like the bits you don’t usually see. How a document becomes an answer. How a message finds its way through a queue. What an AI agent actually did before it confidently got something wrong.

So I build things to find out. Some turn into useful tools. All of them give me another question to chase. This is my little corner of that process.

Have something interesting in mind? Let’s talk.

a few things I’ve put my heart into.

Start with these three. Open one for the story behind it.

TraceLab

An AI agent got it wrong. Now what?

An agent can sound sure of itself and still take the wrong turn. I built TraceLab to follow those turns: inspect the trace, find the failure, and compare a proposed fix with the original run.

A Python tracing SDK connects a branching support agent to evidence-linked evaluations. Workflows cover refunds, shipping, cancellations, retries, and human handoffs.

  1. Trace
  2. Inspect
  3. Evaluate
  4. Compare

19 evaluation scenarios. Scripted fixtures improve from 9/19 to 19/19 passing cases; real-model improvement and production validation pending.

  • Python
  • FastAPI
  • PostgreSQL
  • React
  • TypeScript
Try it out

TraceLab / demo

Player unavailable? Open original demo ↗

Agentic RAG

Answers are better when you can follow the trail.

Getting an AI to answer a question is the easy part. I wanted to see what happens when it has to plan, find the right sources, and check its work. This is my attempt to make that journey a little less mysterious.

NeMo Guardrails filters inputs. Portkey handles retries, caching, and model fallbacks. Logfire and LangSmith trace the path from question to answer.

  1. Plan
  2. Retrieve
  3. Rerank
  4. Respond

Evaluation setup: 15 golden Q&A pairs, 6 RAGAS metrics, and adversarial noise tests. Project-reported; production validation pending.

  • Python
  • LangGraph
  • Qdrant
  • RAGAS
  • Portkey
Source code

Agentic RAG / demo

Player unavailable? Open original demo ↗

LexGuard

The upload worked. The worker crashed. What next?

A document upload is only the start of the story. LexGuard is about everything that happens after: getting the file through a queue, making it searchable, and picking up the pieces when a worker stops halfway.

RabbitMQ queues ingestion, a transactional outbox coordinates delivery, and pgvector indexes the documents. Prometheus and Grafana expose service health.

  1. Ingest
  2. Queue
  3. Index
  4. Retrieve

Project-reported: an eight-service Docker stack and 0.48s p99 in a concurrent benchmark; not a production SLA.

  • Java
  • Spring Boot
  • RabbitMQ
  • pgvector
Source code

LexGuard / demo

Player unavailable? Open original demo ↗

and a few more rabbit holes.

Different questions. Same habit of building something to answer them.

AI & retrieval4 projects

SQL Database Agent

Talk to a database. Keep the dangerous bits gated.

Natural-language database queries are useful. Accidental writes are less fun. This agent checks queries, asks for confirmation before writes, and keeps a record of what happened.

Reads are allowlisted, writes require confirmation tokens, and DDL is blocked. Schema caching keeps repeated queries efficient.

  1. Generate
  2. Validate
  3. Execute
  4. Audit

Project-reported: 29 tests covering query safety and an audit log.

  • FastAPI
  • LangChain
  • SQLAlchemy
Source code

VaultLearn

For when the documentation has its own documentation.

I wanted a way to turn a mountain of docs into something I could work through. VaultLearn crawls the pages, organizes a study plan, and keeps questions scoped to what I’m learning.

LangGraph coordinates crawling and learning workflows. Generated notes remain compatible with Obsidian.

  1. Crawl
  2. Organize
  3. Retrieve
  4. Learn

Project-reported ingestion: 152 pages, six modules, and 3,493 chunks.

  • LangGraph
  • FastAPI
  • ChromaDB
Source code

VaultLearn / demo

Player unavailable? Open original demo ↗

LLM Cost Router

Does every question need the expensive model?

Probably not. This project explores routing by complexity, reusing similar answers, and falling back when a model takes too long. The savings below came from a synthetic benchmark, so there’s more to test.

FAISS and Redis support semantic caching, with timeouts, fallback models, and benchmark telemetry.

  1. Classify
  2. Cache
  3. Route
  4. Fallback

93.19% cost reduction in a controlled synthetic benchmark; production validation pending.

  • Python
  • FastAPI
  • FAISS
  • Redis
Source code

LLM Cost Router / demo

Player unavailable? Open original demo ↗

Financial RAG API

Long filings. Short questions. Sources attached.

Financial filings aren’t light reading. I built a retrieval API that pulls relevant passages from 10-K documents and keeps citations close to the answer.

Docling parses filings; hybrid retrieval finds relevant passages and RAGAS evaluates the answers.

  1. Parse
  2. Index
  3. Retrieve
  4. Cite

Project-reported: 0.82 faithfulness over an index of 453+ chunks.

  • FastAPI
  • Docling
  • ChromaDB
  • RAGAS
Source code
Evaluation & ML1 project

Fraud Detector

Taking a model out of the notebook.

Training the classifier was one part. Turning it into something you could actually call was the other. This project connects XGBoost training and validation to a small FastAPI service.

XGBoost training uses stratified cross-validation and feature analysis. FastAPI and Docker package the serving layer.

  1. Train
  2. Validate
  3. Package
  4. Serve

Project-reported F1: 0.859; not independently verified.

  • Python
  • XGBoost
  • FastAPI
  • Docker
Source codeTry it out
Backend engineering2 projects

TaskFlow

A task manager with a lot going on behind the list.

A shared to-do list sounds simple, until you add permissions, caching, background jobs, and people editing at the same time. TaskFlow let me put those moving parts together.

JWT refresh tokens and roles control access. Redis caches data, RabbitMQ handles asynchronous messages, and WebSockets deliver live updates.

  1. Authorize
  2. Update
  3. Publish
  4. Sync

Focus: access control, caching, background messages, and keeping clients in sync.

  • Java
  • Spring Boot
  • PostgreSQL
  • Redis
  • RabbitMQ
  • WebSockets
Try it outSource code

TaskFlow / demo

Player unavailable? Open original demo ↗

ShopSpree

The less glamorous half of “add to cart”.

Behind a checkout button are permissions, stored data, and payments that need to fit together. ShopSpree was my way of working through that backend.

Spring Security and JWT protect the API. PostgreSQL on Amazon RDS stores data and Stripe handles payments.

  1. Authenticate
  2. Browse
  3. Checkout
  4. Pay

Focus: authentication, data persistence, and payment integration.

  • Spring Boot
  • PostgreSQL
  • Stripe
Source codeTry it out
See the whole collection

what’s usually on my desk.

Mostly Python and Java. The rest depends on the question.

Languages
PythonJavaTypeScriptJavaScriptSQL
Backend & data
FastAPISpring BootPostgreSQLRedisRabbitMQ
AI systems
RAGLangChainLangGraphQdrantFAISSGuardrailsModel APIsPrompt & context engineering
Evaluation & operations
RAGASLogfirePrometheusGrafanaDockerGit

still early. still curious.

I’m in the 2026 computer science batch at Manav Rachna University. Building these projects has been my way of going past “I get the idea” and finding out what I actually understand.

Right now, I’m looking for a remote junior role in backend or AI engineering. A place to build useful things, ask better questions, and learn from people who care about the details.

Open to opportunities · India / IST