I'm actively moving toward Forward Deployed Engineering and GenAI Engineering — the intersection of real customer problems, working prototypes, and shipping things that hold up.
Understand the problem → Prototype → Integrate → Debug → Deploy → Iterate
What pulls me toward FDE specifically: it's the closest engineering role to the actual problem. You can't abstract your way out of a broken integration at 2am. That's the work I want to get better at.
Right now: finishing the Graph RAG assistant, deepening agent evaluation, and getting comfortable with Kubernetes past the basics.
🤖 GenAI
⚡ Backend
🗄️ Databases
🐳 DevOps
📊 Analytics
🔭 Going Deeper
A knowledge assistant that goes beyond flat vector search — it uses Neo4j graph relationships alongside semantic embeddings to understand how documents connect, not just what they say.
Built specifically to answer: does adding graph structure actually improve retrieval quality, and when?
PDF → Chunking → Embeddings → Graph Relationships → Retrieval → LLM → Grounded Answer
FastAPI · Neo4j · Embeddings · Vector Search · RAG · LLM
🤖 AI Agent Patterns · LangGraph · LangChain
Built and compared four agent architectures to understand where each pattern breaks down and why — not as a benchmark, but as a way to develop intuition for which architecture fits which problem.
| Pattern | Key Question Explored |
|---|---|
| Simple Agent | How does a basic tool loop actually behave? |
| Tool-Using Agent | What does Pydantic structured output change? |
| Router Agent | When does conditional branching make sense? |
| ReAct Agent | What does a reasoning trace actually show? |
LangChain · LangGraph · Pydantic · Tool Calling · LangSmith
🐳 Docker Full-Stack Service · Multi-Container
Containerized a multi-service application — FastAPI backend, PostgreSQL, Redis, Nginx reverse proxy, and pgAdmin — to understand how services discover each other, where health checks actually matter, and what silently fails when networking config is wrong.
FastAPI · PostgreSQL · Redis · Nginx · pgAdmin · Docker Compose
☸️ FastAPI on Kubernetes · Deployment
Deployed a containerized FastAPI app to Kubernetes using Deployments and Services — a first real run at the orchestration layer beyond Compose, where the primitives are different and the failure modes are less obvious.
Kubernetes · Docker · YAML · kubectl · NodePort
I document the work on YouTube — not polished demos, but real technical walkthroughs: what I built, what broke, what I had to look up, and what I now understand differently. Current content covers the Graph RAG build, agent pattern comparisons, and containerization.
The discipline of explaining what you built forces clarity you don't get from building alone. That's why I do it.
| 🔍 | Understand | What is the actual problem — not the stated one |
| 🧪 | Prototype | Build the smallest thing that answers it |
| 🔗 | Integrate | Where assumptions meet reality |
| 🔧 | Debug | Where real learning happens |
| 🚀 | Deploy | Make it real — local doesn't count |
| 🗣️ | Explain | If you can't explain it, you don't own it |
| 🔁 | Iterate | What would you build differently now? |
The gap between a working prototype and a working integration
is where most ideas die — and where I want to work.
Engineering isn't about knowing the answer.
It's about building your way to one — and being honest about what broke along the way.
📊 Earlier Foundations — Data & Analytics
Before moving toward backend and GenAI engineering, I worked on data analysis and visualization. That work shaped how I think about schemas, query design, and working with structured outputs — it feeds directly into retrieval work now.
Not finished. Actively building.
The best way to understand what I'm working on is to look at the repos and watch the build log.