Five years across two disciplines that rarely share a desk: agentic systems in LangGraph and LangChain, and the React interfaces that let a person review, approve, and override what those systems decide.
I started in frontend and moved toward AI without leaving the interface behind. Each marker is coloured by the discipline the role actually leaned on.
Architected an enterprise bid intelligence platform on LangGraph — structured tool calling, retrieval, business-rule validation, stateful orchestration — then built the React interface where users review and intervene at the decisions that matter.
Evaluated model behaviour across long multi-turn conversations and built the datasets and frameworks to measure grounding, hallucination, and task completion. Shipped two conversational platforms end to end.
Built client-facing analytics interfaces in React and the Python microservices behind them — interactive data views over AI-generated output, wired to FastAPI through asynchronous retrieval.
Turned Figma wireframes into production interfaces across multiple modules, working directly with UI/UX designers on layout, interaction behaviour, and usability. Cut load time roughly 10% through lazy loading, code splitting, and caching.
Built a real-time quiz application on Microsoft Kaizala, with WebSocket pipelines pushing instant UI updates and reusable state patterns that sped up delivery across the team.
Where it started — image classification and sentiment models served through Flask APIs and visualised in React dashboards. The pairing has followed me ever since.
A confident paragraph with nothing behind it is worse than no answer at all. Citations belong in the default view, not behind a disclosure arrow.
Automation should run freely right up to the point where a mistake costs something. That is where the interface stops and asks.
Ambiguous intent, lost context, a tool that times out. These are the common cases, not the edge cases, and they deserve real screens.
What the agent knows, what it assumed, and what it is waiting on should all be visible. If a user can see the state, they can correct it.
Multi-turn dialogue orchestration, conversation state, agent workflow design, tool and function calling, human-in-the-loop patterns, prompt chaining, context management.
Prompt engineering, LLM evaluation, response grounding, hallucination detection and mitigation, retrieval-augmented generation.
LangChain, LangGraph, CrewAI, Hugging Face, PyTorch, TensorFlow, scikit-learn.
React, TypeScript, component architecture, state management, responsive interfaces, Figma, design systems.
Python, FastAPI, REST and JSON APIs, async processing, ChromaDB, Pinecone, FAISS, MongoDB, semantic search, chunking, reranking.
AWS, Docker, Git, Postman, Claude Code, Cursor.
I spent my first years building interfaces and my last few building the systems behind them. That combination is the whole point: I can argue about retrieval strategy in the morning and about where a confirmation dialog belongs in the afternoon, and I think those are the same argument.
Most of my work now lives in regulated, high-stakes workflows — bids, contracts, legal documents — where an AI system has to be transparent enough that a person will actually sign off on what it produced. Making that legible is a design problem at least as much as an engineering one.
Outside of work I sing, mostly Hindustani classical, occasionally in front of people.