I build and ship production AI. Real-time computer vision, LLM agents, and the infrastructure that keeps them reliable.

Enterprise GraphRAG observability

→ ~90% lower latency (4.5s → <500ms)

The problem. Root-cause analysis in distributed systems is slow. When something breaks, engineers end up tracing service dependencies by hand to work out what a given bug affected.

What I built. An observability platform built on a custom GraphRAG engine that maps service dependencies and automates root-cause analysis. A hybrid LLM router classifies intent using Groq Llama-3.1-8B and GLiNER for zero-shot NER, backed by LadybugDB, a custom multi-hop graph database that runs batched Cypher traversals. The React Flow frontend visualizes the blast radius of a bug across GitHub PRs and Jira tickets, with plain-English summaries.

• Batched Cypher queries in LadybugDB eliminate N+1 bottlenecks
• Sustained 13 req/s with zero errors under a 25-way concurrent load test
• Interactive blast-radius view spanning GitHub PRs and Jira tickets

AI mock-interview platform

→ Sub-millisecond session latency at scale

The problem. Interview prep tends to be either expensive coaching or a static question bank. Neither feels realistic, offers meaningful feedback, or scales.

What I built. A voice-first interview platform with a 6-phase adaptive pipeline and 4-dimensional scoring, with live proctoring via FaceNet512, MediaPipe, and YOLOv8. Session state moves through a 3-tier store, from in-memory to Redis to PostgreSQL.

• RAG over 10K+ document chunks keeps follow-up questions grounded
• Sarvam AI for STT/TTS, with a gamification engine spanning XP and 7 rank tiers

Realtime collaborative whiteboard

→ In active development

The problem. Multiplayer whiteboards like Figma and Excalidraw depend on realtime sync that doesn't conflict and clean recovery after a dropped connection. The hard part is the backend, not the canvas.

What I built. A backend-first collaborative whiteboard built around an immutable operation log, snapshot-based replay, per-room version ordering, and websocket broadcast — the same primitives behind Figma and Excalidraw multiplayer. I designed the system before implementing it, with 18+ diagrams covering architecture, schema, sequence flows, reconnect recovery, and a Redis pub/sub scaling path.

• Cursors and presence are kept off the persisted write path to keep the op-log clean
• Scaling path designed from single-instance to Redis pub/sub

RL traffic optimization

→ 30% lower average wait time

The problem. Fixed-timer traffic signals don't respond to real congestion, so an intersection can sit red over an empty lane while traffic backs up beside it.

What I built. A real-time vision pipeline tracks vehicles across 4-lane intersections, and a reinforcement-learning agent uses the live counts to adjust signal timing dynamically.

• 94% vehicle detection accuracy at 30 FPS
• Analyzes 500+ traffic patterns an hour, improving flow efficiency by 40%

AI job-application automation

→ 100+ applications tracked end-to-end

The problem. Applying to jobs manually is slow, repetitive, and rarely tailored to each specific posting.

What I built. It generates tailored LaTeX resumes, cover letters, and cold emails, with an async scheduler that polls Gmail and sends context-aware follow-ups. A human stays in the loop throughout.

• Hybrid scoring: TF-IDF 40%, keyword 35%, tech-match 25%
• Redis-cached sub-second recommendations

Semantic resume matching

→ Deployed full-stack on AWS

The problem. Manual resume screening is slow and prone to bias, and strong candidates often get filtered out over keyword mismatches.

What I built. It scores resumes against a job description using SentenceTransformers for semantic matching, with LLaMA 3 generating feedback on what's missing.

• Semantic matching rather than simple keyword overlap
• Groq generates the feedback; MongoDB tracks applications

Gesture-based audio control

→ 96% recognition across 12 commands

The problem. Hands-free audio control without wearables or extra hardware — just a webcam.

What I built. A computer-vision system that maps hand gestures to audio commands in real time, using MediaPipe landmarks and lightweight ML classifiers.

• Real-time at 30 FPS with <100ms latency