Apps people use
Full-stack applications with Next.js, React, TypeScript, FastAPI, and Postgres, designed with care for the details users feel.
I build applications people enjoy using and the machine learning systems behind them. I studied electrical engineering at UT Austin and spent three years in computer science at Stanford, focused on AI just as transformer models were emerging, and I have worked at both large companies and startups on machine learning and software. The work below runs from a live status service and a desktop chess game up to full fine-tunes of language models on H100 clusters, and the common thread is combining models, retrieval, memory, and careful engineering into apps that do something useful.
I love making apps. The projects I keep returning to are the ones a person can open and use: a public status page that watches live services and tracks their error budgets, a transcription tool that streams who said what from a browser tab a few seconds behind live, a desktop chess game whose engine is verified against ten million reference positions. Machine learning runs through most of my work, but the model is rarely the point on its own. The point is the application around it, and most of what I build combines existing technology into something more useful than its parts, wiring pretrained models to retrieval over embeddings and giving applications persistent memory in an ordinary database so they get better the longer you use them.
That interest started in school. I studied electrical engineering at UT Austin and then spent three years in computer science at Stanford, where the timing mattered: transformer models were just emerging, and I focused my coursework on them as language, vision, audio, and speech were converging on the same architecture. Since then I have worked at both large companies and startups, building models across all of those domains, from small networks up to large transformers, and I care as much about getting them to run well in production as about training them.
The range follows from that. On one end I run full fine-tunes of 8B-parameter models across multiple GPUs, quantize them to FP8, and serve them; on the other I design the interface, the schema, and the deployment for the app a person actually touches. Evaluation ties the two ends together, whether that means a calibrated judge for model outputs or an error budget for a web service, because measurement is what separates a product from a demo.
Outside of work I am usually building apps and design projects for their own sake. If you'd like to talk or work together, feel free to reach out.
A few projects with full write-ups. Each page walks through the decisions step by step, with the measurements that back them.
Joins Whisper with a speaker-diarization pipeline assembled from open parts, scored end to end with WER and DER written from scratch, and streams speaker-labeled words from a browser tab about five seconds behind live.
A full BF16 fine-tune of Qwen3-8B for idiomatic Rust on four H100s, quantized to FP8 and served with vLLM, then improved further by reinforcement learning with the compiler as the reward.
An 800,000-application simulated portfolio with bias planted deliberately, so the fair-lending audit is tested against ground truth: it has to catch the redlining proxy, and it does, rejecting the challenger with the best Gini.
A complete C++ and SFML chess app whose move generator is verified against more than ten million published perft positions, with an alpha-beta AI, plus an AlphaZero-style network that learns the game from self-play and is measured against the engine it shares the repository with.
A live public status page backed by a service that probes endpoints on a schedule, computes availability and latency SLIs over rolling windows, and fires multi-window burn-rate alerts against per-service error budgets.
A 262M-parameter diffusion policy trained from scratch on PushT and evaluated on matched seeds against the published reference, building out a success-versus-compute scaling curve.
Full-stack applications with Next.js, React, TypeScript, FastAPI, and Postgres, designed with care for the details users feel.
Retrieval-augmented generation, embeddings and vector search, persistent memory, and calibrated LLM-as-judge evaluation for software built on language models.
Vision, audio, and language models, from CNNs and RNNs up to transformers and diffusion models.
Full fine-tunes and LoRA, multi-GPU training with FSDP, mixed precision, data pipelines, and reinforcement learning against verifiable rewards.
vLLM, FP8 and int8 quantization, CTranslate2, TensorRT, ONNX, and Triton to hit latency targets without losing accuracy.
SLOs and error budgets, multi-window burn-rate alerting, and the monitoring that keeps a live service worth trusting.
Python, C++, and TypeScript, plus the testing, Docker, Kubernetes, and CI/CD that ship software reliably.
Algorithms, systems, and the math and signal processing from computer science and electrical engineering.
Design walkthroughs of the systems behind familiar products, from URL shorteners and chat apps to payment systems and stock exchanges, each written the way an interview actually runs: requirements, sizing, architecture diagrams, and the trade-offs behind the decisions.
The NeetCode 250 organized into eighteen topics, from arrays and hashing through graphs and dynamic programming, with canonical implementations written side by side in Python, C++, Rust, and TypeScript and verified by unit tests before they appear on the page.