Infrastructure
LLM API vs Self-Hosting: Doing the Break-Even Math
A working standard for deciding whether to use an LLM API or self-host: the structural difference between per-token and per-GPU-hour billing, how to compute break-even from the tokens one GPU produces in a day, where utilization, batching, and quantization move the crossover, and the factors outside price — data privacy, latency, operational burden — that decide when the math is close.
SRE vs. DevOps — Where They Overlap and Where They Split
What SRE and DevOps each are, where they overlap, and where they diverge: DevOps as culture and philosophy, SRE as its concrete implementation, the tools unique to SRE (SLOs, error budgets, toil caps), how the roles actually split in organizations, and how to read job postings.
Lambda vs Fargate: Choosing Serverless Compute
A working standard for choosing between Lambda and Fargate: the structural difference between per-invocation and per-task billing, the unit-price math that makes Lambda over twice as expensive when running continuously and the utilization threshold that follows, Lambda's hard limits (15 minutes, 10GB, cold starts), the hidden costs where API Gateway and log ingestion outgrow the compute bill, and a selection order driven by workload shape.
Where Kubernetes Gets Slow — API Server, etcd, Scheduler
Diagnosing the situation where workloads are fine but kubectl crawls and rollouts lag — a slow control plane. Excessive LIST/WATCH traffic hammering the API server, etcd fsync latency and database bloat, scheduler delays, and the metrics and fixes for each.
ECS vs EKS: Choosing a Container Orchestrator
A working standard for choosing between ECS and EKS: why the real cost is bigger than the free-vs-$73/month control plane difference, the EKS upgrade cycle and the extended-support fee that multiplies by six when neglected, what Auto Mode takes off your plate and what it leaves, the conditions where the Kubernetes ecosystem is genuinely required, and how team size, portability, and hiring shape the decision.
How to Choose requests and limits — Rules That Hold Up in Operations
Not what requests and limits mean, but what numbers to write: measurement-based request sizing, the CPU limit throttling debate, why memory limits are the default, QoS classes and eviction order, using VPA in recommendation mode, and the two failure modes — over-reservation and unlimited memory.
Aurora vs RDS: The Structural Difference and When to Switch
A working standard for choosing between Aurora and standard RDS: what the separated compute/storage architecture buys (15 shared-storage read replicas, fast failover, 256TiB auto-scaling), the three-layer pricing where storage and I/O ride on an instance premium, the 25% threshold that makes I/O-Optimized cheaper, Serverless v2 with scale-to-zero, and the conditions where standard RDS remains the right answer.
When HPA Doesn't Behave — 6 Common Configuration Mistakes
Why a Kubernetes HPA fails to scale, scales too late, or oscillates all day: missing requests and what the target percentage really means, scale-up reaction time and stabilization windows, flapping, GitOps fighting over replicas, and the limits of scaling on CPU alone.
S3 Storage Classes Compared: Standard to Glacier Deep Archive
A working standard for choosing S3 storage classes: the full map of storage rates versus retrieval fees and minimum durations, the three traps in Standard-IA (retrieval fees, 30 days, 128KB), the real differences between the three Glacier classes (instant, hours, 12+ hours), why Intelligent-Tiering is the answer when access patterns are unknown, and when lifecycle transition fees eat the savings.
When a Pod Is Stuck in Pending — 7 Causes and the Order to Check Them
The causes of Kubernetes Pods stuck in Pending, ordered by real-world frequency: reading the Events in describe, insufficient resources, oversized requests, nodeSelector and affinity mismatches, taints, PVC binding waits, ResourceQuota, and the cases where Cluster Autoscaler refuses to scale up.
ECS Fargate vs EC2: Spec Combinations and Price Compared
A working standard for choosing ECS compute: the structural difference between per-task billing (Fargate) and per-instance billing (EC2), the vCPU/memory grid Fargate allows (0.25-16 vCPU, up to 120GB), what the premium actually amounts to at equal specs, the point where utilization and bin packing flip the comparison, and the levers that cut the bill — ARM, Spot, and Savings Plans.
Sizing Servers for Self-Hosted LLMs — From VRAM Math to Concurrent Users
A repeatable order for estimating the GPU scale a self-hosted LLM needs: computing VRAM from parameter count and precision, the KV cache and its relationship to concurrency, memory bandwidth and token speed, example configurations by scenario, and the break-even against API pricing.