From Full-Stack to Multi-Agent Systems: What Nobody Tells You About Pivoting Into DevOps and AI

From Full-Stack to Multi-Agent Systems: What Nobody Tells You About Pivoting Into DevOps and AI

Nobody warns you that the hardest part of a technical pivot isn't the technology. It's the moment you realize you have to start feeling incompetent again, on purpose, after finally feeling competent at something else.

I was a full-stack developer before any of this. Next.js on the frontend, FastAPI on the backend, MongoDB holding it together, Nginx routing traffic, everything wrapped in Docker because that's what the tutorials said "real" projects looked like. I was comfortable there. And then I got curious about what happened to my code after I shipped it — who kept it alive, what happened when it broke at 2 a.m., why "it works on my machine" was somehow both a joke and a diagnosis. That curiosity is what ended the comfort.

Learning infrastructure with no one watching

I taught myself Kubernetes the only way I knew how: badly, at first, and alone. Kube-prometheus-stack. Grafana dashboards I didn't fully understand yet, staring at metrics I couldn't yet interpret. ArgoCD running on a Kind cluster on my own laptop, GitHub Actions workflows pushing images to Docker Hub with a matrix strategy and semantic versioning I looked up three times before I trusted myself to use it.

Nobody told me if I was doing it right. There was no senior engineer glancing over at my terminal to say "actually, do it this way." Just documentation, error messages, and the slow, humiliating process of being wrong until I wasn't.

Eventually that turned into something more deliberate: a full GitOps promotion pipeline using Kargo and ArgoCD on a k3s cluster, moving a real application a todo app, unglamorous by design through dev, staging, and production. I built tutorial content around it, narrated it, documented every decision. Not because anyone asked. Because I needed proof, even if only for myself, that the pivot had actually taken.

Where AI entered the picture

Somewhere in that infrastructure work, a different question started forming: if I could build systems that deployed and promoted code safely, could I build a system that noticed when something was wrong and reasoned about what to do next?

That question became my AI Logging System — a multi-agent architecture built with the OpenAI Agents SDK, using LiteLLM to route between Gemini as primary and Groq as fallback, Temporal handling durable execution so the system could recover gracefully instead of silently failing, a FastAPI backend, a Next.js frontend, and MCP tools connecting the pieces together.

The architecture itself was the hardest part to get right, and the part I'm proudest of. I built it as an orchestrator working alongside specialist agents, each handling a narrow slice of the triage process. Remediation decisions were split into three category boundaries actions the system could take autonomously, actions requiring human sign-off, and actions it should never take without explicit escalation. I built prompt injection guardrails into the design early, not as an afterthought, because I'd learned the hard way from my infrastructure work that safety retrofitted after the fact is usually safety that doesn't hold.

I eventually presented this system at an Oz Lunara community session, where it held up under real scrutiny questions about failure modes, about why I drew the remediation boundaries where I did, about what happens when the orchestrator itself is wrong. That session is what convinced me the work was actually sound, not just something that ran on my machine without complaint.

What the pivot actually cost

I want to be honest about the part that doesn't fit neatly into a growth narrative: pivoting from full-stack into DevOps and AI didn't feel like leveling up. For a long time, it felt like starting over, except now with higher stakes, because infrastructure mistakes don't just break a UI they break the thing everything else depends on.

Being self-taught meant I couldn't lean on a bootcamp cohort or a mentor to tell me which of my architectural instincts were sound. Every design decision the orchestrator pattern, the remediation boundaries, the guardrails I had to defend to myself first, with no one to catch me if the reasoning was wrong. That's a particular kind of loneliness that doesn't show up in a portfolio.

What I'd tell someone standing where I stood

The pivot from full-stack to DevOps and AI isn't really about learning new tools. Tools are the easy part; documentation exists for a reason. It's about being willing to feel incompetent in public or at least in front of yourself long enough for the competence to actually rebuild.

I don't think I "arrived" anywhere with this work. I think I built one system that holds up, learned what it cost me to build it, and understood, maybe for the first time, that the discomfort of not knowing was never a sign I was in the wrong field. It was just the actual shape of learning something real.