Everything I've built and shipped.

An agent that applies to jobs end to end.

It reads the posting, fills the application, answers the employer's open-ended questions from the user's real background, and submits on real ATS portals.

• Stateful LangGraph workflow that resolves every field through tool calls and escalates rather than guessing.
• RAG over each user's resume and history so answers come from real background — 88% autonomous answer coverage, 28% lower LLM cost.
• A FactGuard layer blocks the model on any field with no retrieved fact, so it never fabricates on a submission the user cannot take back.
• Idempotency keys and crash-safe replay guarantee no duplicate applications.

AI outreach that researches a person before it writes.

Drafts personalized connection requests, DMs and cold emails using LLMs, behind a provider architecture with automatic fallback chains.

• Plug-and-play provider architecture — Claude, OpenAI and Gemini behind interfaces with automatic fallback chains, swappable from a single config line.
• Hardened against prompt injection: untrusted data isolated in delimiters so the model treats it as data, never instructions, with a typed-error retry loop.
• Eval harness with deterministic auto-checks plus an LLM-as-judge scoring four subjective axes, using baseline/diff modes to catch prompt regressions before merge.
• Go backend (Gin, PostgreSQL) with errgroup-orchestrated parallel fetches behind a 75s pipeline timeout, per-IP and per-user rate limiting, and daily usage caps.
• Manifest V3 Chrome extension in TypeScript using a closed Shadow DOM overlay, with WorkOS OAuth/SSO and a signed handoff that never exposes tokens to JavaScript.

Agents that trade surplus food between restaurants.

Settling on real payment rails, where money moves only after delivery is verified.

• A hard LLM boundary: the matching engine is fully deterministic and agent tools accept no model-supplied numbers. The model chooses which check to run; Python computes every value.
• Idempotent settlement protocol keyed on (listing, delivery) — the charge row is written pending before any network call, so a provider timeout retries instead of silently reporting success.
• Card rails with network-enforced spending caps and partial capture: the buyer approves a ceiling once by passkey, and a charge above it is refused by the network.
• Cut Redis command volume ~15× (2.6M → 173K/month) by replacing a polling scheduler with a Lua timer wheel that sleeps until the next deadline.

Civic transparency for ~800 Lok Sabha MPs.

Surfaces self-declared affidavit data with interactive D3.js charts, an India choropleth and per-MP profile pages.

• Concurrent Go ingestion pipeline (goroutines, token-bucket limiter) writing to Postgres via idempotent upserts, refreshing the full dataset in under 10 minutes.
• Frontend in Next.js, React and Tailwind with per-MP profile pages indexed for search, serving 500+ monthly visitors.

Live AI agent product with paying customers. The agent applies to jobs end to end — it reads the posting, fills the application, answers the employer's open-ended questions from the user's real background, and submits.

• Built an autonomous job-application agent in Python (FastAPI, LangGraph) that plans and executes a full application as a stateful multi-step workflow, resolving each field through tool calls, recovering cleanly on step failure, and escalating to the user when it cannot proceed safely.
• Built a RAG pipeline over each user's resume and history (embeddings + Pinecone) so open-ended employer questions are answered from the user's actual background instead of generated from scratch. This raised autonomous AI answer coverage 88% and cut LLM cost 28% by retrieving facts rather than re-prompting a large model per question.
• Enforced a hard anti-hallucination boundary: a FactGuard layer blocks the model on any field with no retrieved fact, so the agent answers from real data or escalates. It never fabricates on a submission the user cannot take back.
• Built the API layer with FastAPI and Pydantic, validating every model output against typed schemas so malformed LLM responses fail fast instead of reaching a live employer form.
• Built the browser-automation engine that submits on real ATS portals (Greenhouse, Ashby, Lever), with idempotency keys and crash-safe replay guaranteeing no duplicate applications, plus anti-bot and CAPTCHA handling for reliable submission.
• Instrumented the full agent path with LangSmith and OpenTelemetry, tracing every model call, tool invocation and decision, plus a queryable outcome taxonomy and dead-letter queue, so agent behavior is measurable and failures are debuggable.

Intent-driven, multi-chain stablecoin clearing & settlement network letting payment providers move value across chains through one API.

• Built core Go services for an intent-driven, auction-based settlement platform — payment gateway, solver gateway and on-chain verification — within a ~10-microservice system behind one REST API.
• Built an off-chain quote-auction pipeline on Apache Kafka using per-source topics plus ephemeral per-request correlation topics with TTL-based cleanup, decoupling services into an event-driven flow.
• Implemented a gRPC service (7 RPCs over Protocol Buffers) with a resumable server-streaming feed using monotonic sequence IDs, heartbeat liveness checks and replay-on-reconnect for reliable delivery across disconnects.
• Architected an event-sourced PostgreSQL store with a race-free, two-phase work queue using SELECT FOR UPDATE SKIP LOCKED, giving crash-safe, idempotent settlement across a 20-worker pool.
• Designed a write-only key-custody layer with a pluggable signing backend (encrypted storage plus GCP KMS / HashiCorp Vault / Fireblocks adapters), keeping private keys non-retrievable and signing isolated.
• Containerized the service fleet with Docker, authored Kubernetes manifests and built GitHub Actions CI/CD promoting the exact staging-tested image to production by commit-SHA re-tag.

A derivatives trading protocol with a Go off-chain execution engine — order matching, position lifecycle, margin accounting and liquidation.

• Architected a Go off-chain execution engine for a derivatives trading protocol from scratch, covering order matching, position lifecycle, margin accounting and liquidation logic.
• Built a concurrent order-processing pipeline using goroutines for parallel matching and mutex-protected account state under simultaneous leverage constraints.
• Implemented the liquidation engine and funding-rate mechanism; validated across 10K+ simulated leveraged trades with zero false liquidations in testing.
• Built a low-latency WebSocket server propagating real-time state to 500+ concurrent users; grew to 500+ MAU and a 1,000+ member Discord, and won a $1,000 Soonami Venturethon grant.

NFT-marketplace smart contracts and the React frontend that drove them.

• Engineered NFT-marketplace smart contracts with state-machine logic for ownership, settlement and transfer; built the React frontend with wallet connection and on-chain interactions.
• Implemented gasless approvals (ERC-2612 permit), removing a separate approval transaction to cut onboarding friction and user gas costs.
• Wrote test suites covering authorization, ownership transfer and failure paths to 95%+ functional coverage.