Backend & AI Systems Engineer transitioning deep into Agentic AI — I build production backend platforms and I'm now applying that same reliability discipline to autonomous, tool-using LLM systems.
I design backend systems that stay correct under real operational load — enrollment engines, outreach automation, verification infrastructure — and I'm now pointing that same discipline at agentic AI: systems where an LLM doesn't just respond, it plans, calls tools, and carries state across steps.
I care about the boundary most AI demos skip past — the part where a system has to keep working after the happy path ends.
Reliability is a feature, not an afterthought.
Idempotency over optimism — every operation assumes it might run twice.
State transitions should be explicit — implicit state is where incidents live.
Automation should be observable, or it isn't trustworthy.
Simplicity scales. Unnecessary complexity doesn't.
I'm moving from LLM-integrated backend features toward true agentic systems — planning, tool orchestration, and multi-step autonomy, with the same production discipline I apply to backend infrastructure.
| Status | Area |
|---|---|
| 🟢 Production experience | LLM-integrated services, RAG, vector search, tool calling |
| 🟡 Actively learning | LangGraph, Model Context Protocol (MCP), multi-agent orchestration, AI evaluation |
I label these honestly on purpose — expertise claimed and expertise in progress are not the same thing.
|
Languages Python · TypeScript · Java · Elixir · SQL |
Frontend Next.js · React · Tailwind CSS |
Backend FastAPI · Phoenix · Spring Boot |
|
Databases PostgreSQL · Supabase · MySQL |
AI / LLM OpenAI · Gemini · RAG · Vector Search (pgvector) · LLM Tool Calling |
Cloud & Infra Docker · AWS · DigitalOcean · Kubernetes |
How I structure the systems I build — an agent pipeline, a backend service, a workflow engine, and an inference layer.
Agentic AI Application
flowchart TD
A[User Request] --> B[Agent Orchestrator]
B --> C[Planner]
C --> D[Retriever / RAG]
C --> E[Tool Calls]
D --> F[(Vector Store)]
E --> G[External APIs]
C --> H[FastAPI Service Layer]
H --> I[(PostgreSQL)]
H --> J[Background Workers]
H --> K[Observability & Logging]
J --> K
Backend System
flowchart LR
Client[Client] --> API[FastAPI / Phoenix Service]
API --> Auth[Auth & RBAC]
API --> DB[(PostgreSQL)]
API --> Cache[(Cache)]
API --> Queue[Job Queue]
Queue --> Worker[Background Workers]
Worker --> DB
API --> Obs[Logging & Monitoring]
Workflow / Automation Engine
flowchart TD
Trigger[Cron Trigger] --> Sched[Scheduler]
Sched --> Seq[Sequence Engine]
Seq --> Send[Delivery Layer]
Send --> Track[Reply Tracking]
Track --> Class[Classification]
Class -->|Positive reply| Suppress[Auto-Suppression]
Class -->|No reply| Retry[Next Step in Sequence]
Retry --> Seq
Track --> Dash[Analytics Dashboard]
Inference / Observability Pipeline
flowchart LR
Req[Inference Request] --> Gateway[Provider Abstraction Layer]
Gateway --> P1[OpenAI]
Gateway --> P2[Gemini]
Gateway --> Stream[Streaming Handler]
Stream --> Ingest[Ingestion Pipeline]
Ingest --> TSDB[(Telemetry Store)]
TSDB --> Dash[Observability Dashboard]
|
Student operations & cohort orchestration platform running live cohorts today. Architecture — Next.js frontend → Supabase Auth/RBAC → PostgreSQL, with cron-driven batch jobs handling cohort lifecycle transitions across a multi-portal setup.
Stack — | |
|
Campaign sequencing engine for high-volume, multi-touch outreach. Architecture — Scheduler triggers a stateful sequence engine → delivery layer → reply tracking/classification loop, feeding an analytics dashboard. See the Workflow diagram above — this is the system it models.
Stack — | |
|
Turns a Gmail inbox into structured application intelligence. Architecture — Gmail API sync → LLM classification layer → Phoenix/LiveView backend → PostgreSQL, with monitoring on the classification pipeline itself.
Stack — | |
|
AI-powered resume intelligence & career mentorship platform. Architecture — Next.js frontend → FastAPI backend → OpenAI for structured extraction/guidance, with retrieval over embedded resume + career data.
Stack — | |
|
Secure, scalable issuance & verification for digital certificates. Architecture — FastAPI service → Supabase storage/DB → QR generation & hash/signature verification, deployed as a standalone cloud-hosted verification portal.
Stack — | |
|
Lightweight AI inference observability & telemetry platform. Architecture — matches the Inference Pipeline diagram above: a provider-abstraction gateway in front of multiple model providers, feeding a streaming ingestion pipeline into telemetry storage and dashboards.
Stack — |
Small tools built to solve a real problem, not to pad a portfolio.
| Project | What it does |
|---|---|
| AI CSV Importer | LLM-powered CSV importer mapping any lead CSV into a CRM schema — semantic field mapping, streaming parse, batched + retried AI calls, SSE progress, and a golden-set eval harness. |
| RLS Inspector | Visual debugger for Supabase Row Level Security policies — catches missing WITH CHECK clauses and overly-permissive rules. |
| Competition Tracker | Automated intelligence platform tracking EdTech, Cloud/DevOps, and GenAI updates with dedup and scheduled email digests. |
LLM integration → RAG & vector search → structured tool calling → now: agentic orchestration.
Each step above is backed by a shipped system, not a tutorial. The current step — LangGraph, MCP, multi-agent design, and evaluation — is genuinely in progress, and I'd rather say that plainly than round up.
Not active yet. When there's something worth publishing about production agentic systems, it'll show up here instead of being implied.
Open to roles and collaborations at the intersection of backend engineering and agentic AI.
Design for scale. Build for reliability.