I'm a staff software engineer with 20+ years building production systems. I partner with organizations that want to move past AI experiments into deployments they can actually depend on — with thoughtful architecture, proper monitoring, and a clear answer to "what happens when this breaks?"
Best fit for mid-market teams in regulated or data-sensitive industries — logistics, financial services, healthcare, legal — where running AI on your own infrastructure matters.
Getting AI into a demo is easy. Getting it to run reliably inside a real business — with production traffic, sensitive data, and real consequences when something goes wrong — is a different problem. That's the work I enjoy, and it's what I've spent my career building toward.
If you've already shipped something that's fragile or giving you pause, I can help. I'll audit what's there, walk you through the failure modes, and work with you to shore it up or rebuild where it makes sense.
Building AI into your existing systems with the same rigor you'd apply to any production service — structured outputs, validation, retries, observability. Components you can depend on, not just things that work on a good day.
Running LLMs on your own hardware so your data stays yours. Model selection, optimization, and deployment tuned to your workload. Especially valuable for teams in regulated industries or organizations with strict data privacy requirements.
Sometimes the most useful thing I can do is help you think clearly about where AI actually fits. I'll look at your infrastructure, data, and goals and give you an honest roadmap — including the places where AI isn't the right answer.
Enterprise SaaS vendors needed to understand which technologies were deployed across their entire addressable market — roughly 515,000 organizations — and detect the leading indicator of customer churn: dual-vendor deployments that precede a switch. The challenge wasn't the crawler. It was building a reliable, resumable, multi-stage pipeline that could process a market at scale, deliver clean data to enterprise partners on a monthly cadence, and handle the messy reality of websites that break in every way imaginable.
As co-founder and CTO, I architected the full pipeline: a Python async Playwright crawler (10–20 concurrent headless browsers with slot isolation, checkpointing, and backpressure) feeding a Go signal processor (1,000+ regex and text fingerprints, batched inserts with circuit-breaker and exponential backoff) into a Go exporter with MD5 deduplication and atomic file writes, delivered monthly to partner S3 buckets. The v2 ML account matcher was the technically interesting piece — a Random Forest classifier with 15+ feature vectors across four parallel matching strategies, tuned to 92% accuracy while running 73% faster and using 60% less memory than v1. Operational maturity mattered as much as the algorithms: per-stage alerting, dry-run mode, retry-failed mode, and status monitoring that let the team sleep at night.
Built from scratch: a production AI agent runtime that treats agents as real services rather than chatbot demos. The goal was an answer to questions most agent platforms don't ask — what happens when a provider goes down, how do you prevent an agent from touching files it shouldn't, how do you give it memory that doesn't drown in duplicates, how do you update its capabilities without restarting it.
The architecture has four pillars. Context management with content-aware token estimation and LLM-based compaction. Vector memory with hash-plus-semantic deduplication and importance decay over time. Progressive skill disclosure so agents load capabilities on demand instead of front-loading everything into context. And autonomy primitives — boot hooks, cron and heartbeat scheduling, hot-reloadable skills. Security is layered: bearer auth at the API, per-agent tool policies with path allowlists and command blocklists, execution isolation (host/Docker/strict), and an approval workflow with TTL and fingerprint deduplication. Provider abstraction wraps Anthropic, OpenAI, and Gemini behind a circuit breaker with configurable failover.
A media organization needed 15,000+ videos made searchable across three languages — with semantic understanding rather than keyword matching, and with AI running on their own hardware to control costs at scale. I designed and built the pipeline end to end: automated ingestion, transcription with faster-whisper, multi-language translation, and a three-pass LLM analysis that extracts themes, validates content against a domain-specific reference corpus, and produces search-ready tags that match how users actually look for things.
The hard problems were the unglamorous ones. GPU memory budgeting to run 14 parallel transcription workers in 21GB of VRAM without contention. A two-phase scheduling model that separates network-bound work from GPU-bound work so neither starves the other. Deterministic confidence scoring — rule-based, not LLM-generated — so content with low-confidence claims gets flagged for human review before publishing. Streaming audio-only extraction from cloud storage to cut bandwidth by 90%. And the batch work that actually proves a pipeline is production-grade: 5,522 AI jobs processed overnight with zero failures.
A multi-location nonprofit operating in a regulated environment needed a coordination platform for staff and field volunteers — with cert-aware eligibility rules, per-facility compliance requirements, and credential expirations that couldn't be tracked in a spreadsheet. The brief was clear: no bolted-on AI chatbot, no CRUD app with a "summarize" button. They needed AI integrated where it saves real time, in a system that runs reliably for people doing real work.
The platform is a multi-tenant production system on FastAPI, React, and PostgreSQL, covering staff coordination, client registry, timesheets with grant-reporting hour valuation, mileage logging mapped to funding sources, broadcast messaging with recipient filters, and reporting. AI shows up throughout: a natural-language query layer that lets staff ask questions across their data without writing reports, automated document and compliance report generation, and LLM-powered eligibility logic that checks certifications and matches volunteers to events against facility-specific rules. Everything is tenant-scoped. Every AI call has fallback behavior. Shipped to real organizations under a real deadline and running in production today.
Researchers working with primary sources need something different from generic document retrieval. A question about a specific passage might need to pull in original-language morphology, two or three commentary perspectives, a relevant historical citation, and a modern treatment of the same material. Keyword search doesn't help. Generic RAG over a pile of source documents doesn't help either — it collapses distinctions between source types that actually matter to the reader.
This is a production RAG system with a deliberate architecture. PostgreSQL with pgvector handles semantic similarity across a multi-source corpus. The LLM strategy is hybrid on purpose: Claude Sonnet via OpenRouter for primary inference where reasoning quality matters, local Ollama for embeddings — because sending every private research query to a cloud embedding API is a privacy problem most RAG systems ignore. The ingestion pipeline handles different source types with different prompt profiles (lexicons, public-domain commentaries, primary historical sources, modern treatments) so retrieval preserves the distinctions instead of blending them. Users ask questions in natural language and get synthesis back with citations traceable to primary sources. Deployed as Docker microservices with health checks and dependency ordering, running in production.
Every engagement starts with a written scope — nobody gets a surprise invoice, and nobody gets a surprise deliverable. Most work falls into one of four shapes:
Short-form assessment when you're not sure where to start. I look at your infrastructure, data, and goals and produce a prioritized roadmap — including honest guidance on where AI isn't the right answer. Usually the entry point to a larger engagement, but works as a standalone.
For defined builds. Paid discovery produces a written scope document; I quote a fixed price against it. Change orders handle anything outside the scope so we both stay on the same page. Typical engagements run six to twelve weeks.
For AI systems that are fragile, unreliable, or underperforming. I audit what's there, walk you through the failure modes, and work with you on a clear path forward — shore up, rebuild, or replace. The decision is yours once you have real information.
For teams with ongoing AI work who want priority access to a senior engineer. Architecture review, code review, planning help, and on-call judgment for decisions that matter. Monthly, quarterly contracts.
Twenty years of building production systems across startups and enterprise. I've led teams, architected distributed platforms, and shipped through acquisitions, migrations, and scaling moments. The AI work I do now is built on top of that foundation — not instead of it.
I take on a small number of engagements at a time so I can give each one real attention. Whether you're looking at an ambitious project or just want a second set of eyes on something, send a note and we'll figure out if there's a fit.