A · Day job
Leading a full-stack & DevOps team at ESAB India, owning end-to-end infrastructure for a large-scale industrial platform.
I design and run the systems that put AI agents into production — and the infrastructure they stand on.
Senior DevOps engineer working toward AI solutions architect. I own the infrastructure layer — Kubernetes, pipelines and hardware test rigs — and I architect what runs on top of it: autonomous code review, AI-executed test suites, project automation, and the shared model-routing, MCP and retrieval platform underneath them. Eight years across cloud architecture, SRE, IoT and embedded systems is what makes the AI part deployable rather than merely demonstrable.
What is actually on my desk right now — not a wish list.
Leading a full-stack & DevOps team at ESAB India, owning end-to-end infrastructure for a large-scale industrial platform.
Architecting the shared agent platform — model routing, MCP tools, retrieval — that three production agents run on.
Hardware-in-the-Loop test rigs, wired into the same pipelines as the software.
Kubernetes, Helm and VM estates — AKS in the cloud, k3s and Proxmox on the floor.
Two of the agents are public on GitHub. The platform work mostly isn't mine to publish.
I care about the compounding return of small, boring automation — the runbook that prevents a 3am page, the pipeline that makes a Friday deploy feel safe, the Helm chart a new joiner can read in ten minutes.
Production agents I designed and shipped. Not demos — these run against real merge requests, real test suites and real hardware, on a schedule, with metrics.
↓ the part I'd want to talk about
Autonomous code review that learns from its own history
A review agent that sits on GitLab merge requests. It parses the unified diff, decides where it needs more context, and goes and gets it — pulling whole files, searching the codebase semantically, and recalling how similar changes were reviewed before. Findings land as inline comments with one-click GitLab suggestion blocks, deduplicated across review iterations so it does not repeat itself when a developer pushes a fix.
Manual test cases, executed by an agent, with no scripts written
QA writes a test case in plain English in TestRail. TestFlow reads it, works out what the steps mean, drives a real Chromium browser through them with Playwright, validates the outcome, captures screenshots, and writes pass/fail back to TestRail. Nobody writes a selector. Nobody sits and watches it run.
Project management without the status-ping tax
An agent wired into the issue tracker and the pipelines. It follows tasks across boards, notices when something has quietly stalled, correlates it against build and deploy state, and raises the blocker — so the standup is about decisions rather than reading tickets aloud.
MCP servers, RAG indexes and local inference the agents share
Three agents in production means one shared substrate, not three copies of it: MCP servers that wrap internal systems once, a retrieval index over repositories and engineering docs, self-hosted models for anything confidential, and the same observability every other service on the platform gets.
Where I'm heading: from building individual agents to designing the systems they live in. Below is the platform the three agents actually share, and the decisions that shaped it.
DevOps → platform → AI solutions architect
Most automation requests are a script with good error messages. I keep agents for work where the input is genuinely unstructured — a diff, a test case written in prose, a board that has quietly stalled. Everything else gets a deterministic pipeline, because it is cheaper to run and far easier to debug at 3am.
Frontier models for reasoning over unfamiliar code; small self-hosted models for classification, extraction and anything touching internal data. The provider sits behind a factory, so switching is a config change. Cost per merge request is a design constraint, not a bill you read at the end of the month.
Chunking strategy, index freshness and deciding what not to index moved review quality more than any prompt rewrite did. The biggest single win was episodic memory of past reviews — consistency across merge requests beat a larger context window.
Each internal system gets wrapped once as an MCP server, not once per agent. That decision is why the third agent was cheap to build and the fourth will be cheaper. Getting the tool surface right is most of the architecture work.
Agents ship in shadow mode, then as an assigned reviewer, then as the default. Regression runs over real historical merge requests before each promotion, deduplication so a re-run never spams a thread, and a human who can always overrule the machine.
Self-hosted inference wherever data cannot leave the network, managed APIs where it can. In a manufacturing setting that one constraint shapes more of the design than model selection does — and it is the question I get asked first in every review.
The same SLOs, the same dashboards, the same on-call rotation. Token spend, latency and failure rate live on the cluster boards next to node pressure and pod restarts — because when an agent misbehaves at 2am, it pages the person who already carries the platform. Eight years of running infrastructure is what makes the AI part deployable rather than merely demonstrable.
Six roles over eight years — healthcare operations, freelance cloud architecture, SRE, DevOps, and now infrastructure leadership.
End-to-end infrastructure ownership for a large-scale industrial platform. Leading a full-stack and DevOps team, standing up Hardware-in-the-Loop test rigs, and designing the AI agents above — CodeSentinel, TestFlow and PM-Agent. Increasingly the architecture role rather than the build: choosing where inference runs, designing the MCP tool contracts and retrieval layer the agents share, and setting the evaluation gates an agent has to pass before it is trusted with a merge request.
Cluster migrations between on-premise and cloud. Built out a library of production Helm deployments — Odoo, ERPNext, Supabase, Zitadel, Airbyte, Spark, Longhorn storage, Elasticsearch and the kube-prometheus stack — and ran the containerised dev and production estates on top of them.
Managed AKS clusters and the surrounding Azure estate end to end. Built and maintained CI/CD on GitLab and Jenkins, including the IoT firmware build pipelines.
Full-lifecycle CRM development and deployment on Odoo, dev through production, plus provisioning and maintenance of the on-premise cluster it ran on.
Architected cloud infrastructure for monolith-to-microservices migrations. Built the CI/CD on GitLab and Jenkins, and the Python + Pytest automation frameworks that covered the new service surface.
Healthcare process and claims adjudication. Where I first saw how much of an enterprise runs on undocumented manual steps — which is more or less why I ended up automating things for a living.
The platform work underneath — clusters, pipelines, migrations and test rigs. Most of it lives in private repositories, so this is the shape rather than the source.
Twenty-plus production Helm deployments, written and maintained as a reusable internal catalogue: Odoo and ERPNext for business systems, Supabase and Zitadel for app platform and identity, Airbyte and Spark for data, Longhorn for storage, Elasticsearch and the kube-prometheus stack for search and observability, plus SonarQube, n8n, Appsmith, Retool, Redis and GitLab Runner. One chart pattern, one values convention, so a new service is a config change rather than a project.
Embedded test automation on real hardware, wired into CI so firmware changes get the same gate as application code. Reproducible fixtures, bare-metal runners, results that a firmware engineer can read without a debugger attached.
Consolidated a fragmented set of small services back into one deployable unit. Deploy time down about 60%, three layers of inter-service auth deleted, ops surface shrunk — module boundaries kept in the code rather than in the network.
Multi-stage GitLab and Jenkins CI on AKS producing firmware artefacts and software services in one reproducible flow, with signed outputs and promotion between environments.
Kubernetes for services, Proxmox VMs for the legacy workloads that were never going to containerise, k3s for edge and constrained nodes — and a single CI surface that ships to all three. Trade-offs written down, a runbook per component.
Private PyPI publishing pipeline and language-agnostic build templates, so internal libraries get versioned, tested and released the same way every time instead of being copied between repositories.
The migration in the other direction, for a platform that genuinely needed it: API gateway, Node service backends and an async messaging tier, with cloud infrastructure, CI/CD and Pytest coverage designed alongside the split rather than bolted on after.
Prometheus, Grafana and Loki across the estate, with the AI agents emitting to the same boards — token spend and agent failure rate sit next to node pressure and pod restarts, because in practice they page the same person.
Length of the pencil line is depth, roughly. Honest rather than flattering.
Open to AI solutions architect, platform and senior DevOps roles — full-time or contract. Happy to go deep on any decision in section 03.