Full-stack engineer building product-grade TypeScript applications and agentic AI systems.
Most of my recent work sits where those meet — LLMs as orchestrators over real, deterministic backends.

• Agentic systems with LangGraph and the Vercel AI SDK — typed tools over deterministic backends
• Full-stack products on Next.js, tRPC and Drizzle over Postgres / Supabase

• Agent orchestration patterns — MCP, A2A and the OpenAI Agents SDK
• Running agent workloads on Dapr and Kubernetes

Next.js · TypeScript · Supabase · AI SDK

A multi-user AI finance companion. The model routes to typed tools rather than reading transactions directly, and heavy analytics are precomputed at ingest.

Decision — raw rows never enter model context. Cost and latency stay flat as a user's history grows, instead of scaling with it.

Python · FastAPI · LangGraph · Supabase

Autonomous P2P and affiliate oversight — a LangGraph agent swarm reporting into a Control Room dashboard.

Decision — findings stream over WebSockets rather than polling, so operators watch checks land as they complete.

React · Node.js · PostgreSQL

An auth and authorization reference build: JWT access with refresh rotation over HTTP-only cookies, OAuth2.0 through Google, GitHub and Keycloak, and role-based access control.

Decision — mTLS for service-to-service identity alongside tokens for users — certificates authenticate machines, tokens authenticate people.

Express · React · Vite · TanStack Query

A counselor action-center built as an npm-workspaces monorepo over a shared TypeScript contract.

Decision — feature first, hardening second and deliberately — request-ID logging, error middleware, integration and frontend tests, and CI landed as an explicit follow-up pass rather than being retrofitted under pressure.

_{Earlier ML and GenAI work: GAN-FashionGen (TensorFlow GANs) and Streamlit × GenAI projects. All repositories →}

System design is the part I actually care about — how the pieces are arranged, where state lives, and what path a request takes to reach an answer.

Agentic AI is the sharpest version of that problem I've found. A model on its own is a guess generator; what makes it useful is the system around it — typed tools instead of free-form prompting, deterministic computation instead of asking a model to do arithmetic, precomputed data instead of a stuffed context window. Most of what I build is an attempt to make the model the smallest, most replaceable part of the system.

• Spec before code. Each unit of work gets a written spec — goal, enumerated items, tests, explicit out-of-scope, and a ship gate — agreed before implementation starts. Several of my repo READMEs are design notes in the same spirit: they name the approach I rejected before the one I shipped.
• Prefer the deterministic path. If Postgres can compute it, the model shouldn't. Precompute at ingest and keep the hot path cheap.
• Test-driven where it counts. Vitest and Testing Library with MSW on the frontend, supertest against the API, Playwright end to end.
• Reviewed before it merges. Implementations go through multiple logged review rounds between two different models, with an independent verification pass. Migrations are linted and replayed against a disposable Postgres, accessibility assertions run inside the Playwright suite, and scheduled jobs guard against schema drift.
• Agents work from a written contract. An AGENTS.md pins conventions, invariants and known pitfalls, and each phase runs in its own git worktree so parallel work can't collide.
• Ship it end to end. Deployed, reachable and documented — not just a repository.

Bachelor's degree in Computer Science — Air University

If you'd like to work on something together, or you just have a question, get in touch.