I build end-to-end ML systems, from raw data to a service in production.
Machine Learning Engineer focused on shipping models to production with engineering rigor: reproducible pipelines, honest evaluation, and deployable services. I come from full-stack development, so I design the model and the infrastructure that serves it.
My approach blends two worlds: the rigor of machine learning (honest evaluation, reproducibility, data at scale) with the software-engineering discipline that turns a model from an experiment into a reliable service.
Design and production deployment of end-to-end machine learning models, from data ingestion to a deployed service.
Applied ML in the financial domain, focused on numerical correctness, traceability, and reliable deployment.
Player segmentation and geospatial recommendation for location-based mobile games.
End-to-end ML system for a synthetic Pokémon GO-style game. It generates realistic behavior data, segments players into archetypes via clustering, and ranks geographic hexes (H3) by visit probability using learning-to-rank. Built as a demonstration of production-grade ML engineering.
AI-native financial analyst.
Upload your bank statements and chat with an agent that reasons over your finances. Built determinism-first: the LLM decides and explains, deterministic code does the math, and money is handled as currency-aware integers so there is no floating-point drift.
Cohere-native enterprise agent for warranty-claims triage, with grounded citations and a security-first design.
A Cohere-native agent that triages warranty claims over a simulated multi-tenant domain. It runs a Command tool-use loop that retrieves policy with RAG, reads claims scoped to the caller’s tenant, and proposes status changes behind RBAC and a deterministic state machine. Scoping lives below the model, citations are produced by Cohere over the final answer, and every action is written to an append-only audit log.
Local-LLM coach for Pokémon VGC replays: it grounds every fact in real game mechanics and flags your misplays.
Takes a Pokémon Showdown replay, reconstructs the battle turn by turn, computes the hard facts that decide each turn, and lets a local language model reason over those facts to write a short coaching report. Damage, speed order, type effectiveness, and usage priors are computed deterministically and handed to the model as ground truth, so the analysis stays accurate, reproducible, and explainable. It runs entirely on your machine through Ollama, with no API keys and no cost.
A model only matters if it can be served, versioned, and reproduced. I design the full pipeline: ingestion, features, training, registry, and a deployable service.
Temporal splits respect time: features are computed only over the training period. If a metric looks too good, there is almost always leakage.
I report what the model actually does, including its limits. I document the plateau, the discarded features, and why one algorithm beats another.
In sensitive domains (finance), the LLM decides what to compute and explains; pure functions compute the numbers. Correctness is never delegated to a probabilistic model.
Lint, strict types, tests, and evals run in CI and block the merge. Quality is a property of the pipeline, not a good intention.
I come from web development, so I don’t stop at the model: I also build the API, the UI, and the infrastructure that put it in front of users.
// The model decides; a pure function computes the money.
function netBalance(tx: Transaction[]): Money {
return tx.reduce((sum, t) => sum.add(t.amount), Money.zero());
}Open to Machine Learning Engineering opportunities and collaborations. Email is the best way to reach me.
Also at: [email protected]