Application Performance Tuning in Microservice Environments with Istio
Why timeouts, retries, and connection pools can turn a slow dependency into a cascading failure — and how to keep that from happening.
16 posts
Articles
New Relic as the Interface, Terraform as the Engine: A Self-Service Approach to Observability
How New Relic entity tags, Terraform, and GitHub Actions let observability administrators manage alerting without touching the infrastructure behind it.
The Queryable Platform Part 1: Your Platform Is a Graph — You're Just Not Querying It Yet
The knowledge to answer 'which services are exposed to the internet, and who owns them?' already exists — it's just scattered across a half-dozen tools that don't talk to each other. A knowledge graph is how you make it queryable.
The Queryable Platform Part 2: .From kubectl to SPARQL -- Build a Queryable Map of Your Platform in an Afternoon
A walkthrough of platform-kg: extract facts from ArgoCD, Kubernetes, Helm, GitHub, Terraform, Vault, and Istio, turn them into RDF triples, and load them into GraphDB — a graph of your actual cluster you can query in a browser.
The Queryable Platform Part 3: Blast Radius Is Just Topology Read in Reverse
Once you have a graph of your platform, the obvious question is: now what? It turns out there's a ladder of answers — inventory, ownership, dependencies, blast radius — each rung built on the one below, with real SPARQL at every step.
The Queryable Platform Part 4: The Context Layer AI Agents Have Been Missing Is Your Infrastructure Graph
In 2026, the hard part of putting an AI agent on your infrastructure is no longer the AI — it's giving the agent something trustworthy to reason over. A platform knowledge graph is exactly that context layer, wired in over MCP.
Common Gotchas When Working with HPAs in Kubernetes
The Horizontal Pod Autoscaler looks simple, but missing metrics, unset requests, averaging behavior, and stabilization windows can make it quietly do the wrong thing.
Learn How to Learn Linux: Part II
A practical tour of man page sections, local documentation paths, and command-line discovery techniques for learning Linux from the system itself.
Creating an Automated RPM Build Pipeline using GitHub Actions
How to connect traditional RPM packaging with GitHub Actions so packages can be built, archived, and distributed through a repeatable CI pipeline.
Debugging Bash Scripts with $PS4
Using Bash's PS4 prompt with set -x to add timestamps, file names, line numbers, and useful context to shell trace output.
Your Helm Chart Is Really an Abstract Syntax Tree
Reframing the Helm chart as an abstract syntax tree and the platform as a compiler: the idea behind Application-Driven Infrastructure.
Building a Self-Describing Platform
One service model, and the dashboards, alerts, catalogs, docs, and internal APIs that fall out of it — a platform that can describe itself.
Generating Terraform from Helm
Rendering, discovering, validating, and applying Terraform straight from your Helm chart, with a copy-pasteable CI pipeline and sane state layout.
Your Helm Chart Already Knows More Than Terraform Does
Why duplicated service metadata is where platform drift begins — and why your Helm chart already knows more about the service than Terraform does.
Learn How to Learn Linux: Part I
A deep look at Linux's built-in documentation culture, from the Unix Programmer's Manual to the man page system, and why learning how to use it changes how you learn Linux.
Creating an Ansible user in Linux
Creating a dedicated non-root Ansible user with sudo access and SSH key authentication for more secure Linux host management.