Technical blog by Shan Valleru covering Kubernetes, distributed systems, AI, and business strategy. Deep dives into platform engineering, agentic coding, emergence, disruption theory, and infrastructure economics.
Every new cloud tenant got a new primitive: apps got VMs, microservices got containers, events got functions. AI agents are getting the sandbox. Why agents are a workload unlike anything the cloud has hosted—and why isolate, snapshot, fork is becoming a unit of compute.
Giga, Salient, F2, and Kanu look like four different companies. Under the hood they've all converged on one pattern. A component-by-component walk through the generic architecture every vertical AI agent ships—and the startups selling each piece.
Strip away the hype and an AI agent is a while loop wrapped around a model call. If you can build a system, you can build an agent. Here's the architecture, the hard parts, and the mistakes—from an engineer's perspective.
Top-down transformation mandates get funded fast and adopted slowly. Bottom-up innovations get adopted fast and funded never. The gap between imposed change and chosen change explains why most enterprise transformations produce dashboards, not outcomes.
Markowitz portfolio theory applied to engineering teams—why the generalist is often the better hire when your team is already concentrated.
Organizations implicitly reward visibility—Slack presence, meeting participation, PR volume—while the work that actually moves products forward is quiet, slow, and hard to attribute. The result: developers who look busy but nothing ships.
Infrastructure has no finish line. But budgets are annual, projects have deadlines, and promotions require shipped artifacts. The mismatch between infrastructure's infinite nature and business's finite framing is the root cause of most platform dysfunction.
GPU scheduling, model loading, token-aware routing, autoscaling — every core Kubernetes abstraction breaks when you run LLM inference on it. Here's why, and the emerging stack (Gateway API Inference Extension, llm-d, Kueue, Ray) being built to fix it.
OpenAI, Anthropic, and Google are pricing their AI models completely differently. GPT-5 at $1.25, Claude Opus at $5, Gemini Flash-Lite at $0.10. Each price is a bet on whether LLMs stay differentiated or commoditize.
iptables sync taking 30 seconds. DNS timeouts. Annotations too long. API server 429s. A cheatsheet of symptoms that tell you you've crossed into large-scale Kubernetes territory.
Double the compute, get predictable improvement. Scaling laws turned AI from alchemy into engineering—and changed who can compete.
The workflow behind these posts: Claude Code, filesystem access, outline-first drafting, and the editing dance that turns generic AI output into something worth reading.
Individual ants are simple. Ant colonies solve optimization problems. Individual neurons fire. Brains become conscious. Individual parameters multiply. LLMs reason. The pattern is emergence—and it might be the most important concept for understanding AI.
The progression from chat to agent to agent team mirrors how you'd delegate to humans. Here's how to delegate effectively at each level—and when to level up.
You read The Innovator's Dilemma. You built the monitoring systems. You locked two doors. But Schumpeter's creative destruction has five. Here's what's behind the ones you're not watching.
Companies cut innovation time to boost efficiency. Then they wonder why they get disrupted. The exploration-exploitation tradeoff explains why slack isn't waste—it's survival insurance.
Applying the classic MBA strategy framework to OpenAI, Anthropic, and the LLM industry reveals useful insights—but also exposes fundamental limitations when analyzing fast-moving, platform-based, talent-driven markets.
Should your platform be one integrated offering or a menu of components? Microeconomic bundling theory—correlation of valuations, extraction of surplus, and reduction of variance—provides a framework for deciding.
Toyota's seven wastes (muda) apply directly to platform engineering. Identifying waste in your developer platform—waiting, overprocessing, defects—reveals where to focus improvement efforts.
Gresham's Law says bad money drives out good. The same mechanism—adverse selection—explains why codebases accumulate technical debt. Understanding the economics of code quality reveals how to break the cycle.
Platform ROI calculations capture cost savings but miss consumer surplus—the value developers receive beyond what they 'pay.' Understanding surplus explains why platforms feel essential even when ROI is hard to prove.
Cloud capacity is inventory. Applying classic inventory theory—safety stock, EOQ, newsvendor models—to reserved instances, spot buffers, and capacity planning reveals how much headroom you actually need.
Multi-cloud is sold as hedging against vendor lock-in. But hedges have costs. Applying portfolio theory to cloud strategy reveals when multi-cloud creates value—and when you're paying for optionality you'll never use.
Platform and infrastructure teams are often seen as cost centers. Reframing them as leverage—profit enablers that multiply the output of product teams—changes how they're funded, measured, and valued.
10x users doesn't mean 10x costs. Understanding the shape of your infrastructure cost curve—economies of scale, step functions, and diseconomies—is essential for financial planning and strategic decisions.
Platform investments follow a J-curve: costs come first, returns come later. Understanding this pattern helps set expectations and survive the period before ROI materializes.
Open source software has a $0 license fee but it's not free. Understanding the true total cost of ownership helps make better build vs buy decisions.
Your infrastructure can become the ceiling on your revenue. Understanding infrastructure as a growth constraint helps justify investment before it becomes a crisis.
Kubernetes clusters lose value over time even if you don't touch them. Understanding infrastructure depreciation helps make the business case for continuous upgrades and avoid the hidden costs of standing still.
How Kubernetes schedules GPUs and other hardware accelerators. Covers device plugins, the limitations of the current model, Dynamic Resource Allocation (DRA), fractional GPUs, and topology-aware scheduling.
How WebAssembly (Wasm) runs on Kubernetes as a lightweight alternative to containers. Covers Wasm fundamentals, containerd shims, SpinKube, use cases, and when to use Wasm vs containers.
How Kubernetes DNS becomes a bottleneck at scale, and how NodeLocal DNSCache fixes it. Covers CoreDNS architecture, the thundering herd problem, debugging DNS issues, and deployment strategies.
How Kubernetes controllers achieve high availability with leader election. Covers the leader election algorithm, implementation with client-go and controller-runtime, debugging leader issues, and split-brain prevention.
Understanding CPU throttling in Kubernetes. Covers CFS bandwidth control, how limits cause latency spikes, diagnosing throttling, and strategies to fix it.
Deep dive into the Kubernetes scheduler. Covers the scheduling cycle, filtering, scoring, preemption, scheduler extenders, and how to debug scheduling failures.
Deep dive into Kubernetes garbage collection. Covers OwnerReferences, cascading deletion, finalizers, and how to build controllers that clean up properly.
Deep dive into client-go's controller building blocks. Covers Informers, SharedInformers, work queues, rate limiting strategies, and production patterns for building robust Kubernetes controllers.
Why kube-proxy becomes a bottleneck at scale and how eBPF-based solutions like Cilium replace it. Covers iptables limitations, IPVS mode, eBPF fundamentals, Cilium's implementation, and migration strategies.
Tracing the path from pod creation to running process. Covers kubelet, CRI, containerd, shim, runc, and OCI specs. Includes debugging at each layer with crictl, ctr, and nsenter.
Demystifying containers at the Linux level. Covers namespaces (pid, net, mnt, uts, ipc, user), cgroups for resource limits, cgroups v1 vs v2, and building a container from scratch with unshare.
Common bottlenecks when scaling Kubernetes to 50+ clusters. Covers hub cluster pressure, ArgoCD at scale, image registry thundering herd, observability overhead, and diagnosis strategies.
Tracing a packet through Kubernetes from pod to service to pod. Covers iptables, kube-proxy, VXLAN overlay networks, and systematic debugging for networking issues.
Deep dive into Kubernetes watch mechanics from etcd to client. Covers MVCC, resourceVersion, the API server watch cache, 410 Gone errors, bookmarks, and debugging watch failures.
Diagnosing and fixing Kubernetes admission webhook problems. Covers webhook latency, timeout configuration, failurePolicy trade-offs, and maintaining consistency across multi-cluster fleets.
Managing Kyverno policies across a multi-cluster Kubernetes fleet. Covers audit mode rollouts, PolicyExceptions, fleet propagation with KubeFleet, and production-ready policy examples.
Understanding informer cache architecture in Kubernetes controllers. Covers the lag window, read-after-write hazards, cross-informer races, and patterns to handle eventual consistency.
Deep dive into Kubernetes scalability limits at 5,000 nodes per cluster. Covers etcd bottlenecks, API server constraints, and how multi-cluster architecture with KubeFleet solves them.
Step-by-step tutorial on building a Kubernetes operator using Kubebuilder. Covers CRD design, controller implementation, reconciliation loops, and production best practices.
Deep dive into Go concurrency internals. Covers the G-M-P scheduler, channel semantics, fan-out/fan-in patterns, common bugs like goroutine leaks and deadlocks, and when concurrency hurts performance.
Understanding Python's parallelism options: threading, multiprocessing, and asyncio. Covers the GIL, when each approach works, real costs like process creation and pickling, and common gotchas.