All Articles

123 articles on engineering, leadership, and career growth.

123 articles

Application Availability: How Many Nines Do You Need?

Application Availability: How Many Nines Do You Need?

Application availability decoded honestly: what 99%, 99.9%, 99.95%, 99.99%, and 99.999% actually allow in downtime, the two formulas that calculate it, why every extra nine costs roughly 10x the last, how dependencies in series cap your ceiling before your effort does, and SLA/SLO/SLI/error budgets. The argument underneath it all: past four nines for most teams, the number that saves your night isn't a bigger percentage — it's how fast you recover.

·20 min readRead now
Software Architecture·13 min read

The Codebase Only AI Understands: Why 3am-Fixability Is the Metric Nobody's Tracking

AI coding assistants roughly doubled code duplication while cutting refactoring in half, and experienced developers report AI tools make them slower, not faster. The fix isn't banning AI-authored code — it's gating on one question: if the person who wrote this isn't on the call, can the on-call still fix it at 3am? A concrete diagnostic, not a moral panic, with three guardrails an architect can put in place this quarter.

Software Architecture·15 min read

Multi-Agent Architecture Is Premature Optimization With a New Name

Teams are reaching for planners, critics, and orchestrators before a single well-scoped agent has been pushed to its limit — the same over-engineering mistake wearing an agent diagram. A constraint-aware framework for the four costs coordination has to pay off (state handoff, failure-mode multiplication, non-deterministic debugging, cost/latency compounding) before multi-agent earns its complexity, from someone who built the orchestrator and still says most teams don't need it yet.

Technical Leadership·16 min read

From AI Adoption to AI Accountability: Why Cost, Not Quality, Is the Leadership Problem

A 2026 survey put cost, not quality or security, as engineering leaders' #1 AI concern at roughly 42%. Agent runs, retries, and context bloat compound quietly and surface on an invoice instead of a design review — the same mechanism that once burned $5,350 out of a forgotten Lambda. The fix isn't a vendor cost calculator or 'measure what matters.' It's a budget ceiling made at design time, tracked against one metric: cost-per-verified-unit-of-work, not cost-per-token.

Software Architecture·14 min read

Retrieval Failure vs Generation Failure: How to Diagnose Which Layer Is Killing Your RAG System

A retrieval-augmented system that answers wrong failed in exactly one of two places — the retriever handed the model garbage, or the model had good material and still wrote garbage. They look identical from the outside and need completely different fixes. This is the diagnostic discipline that stops teams from rewriting prompts for six weeks while retrieval is quietly broken: measure retrieval on its own, then generation on its own, in that order — and fix the layer that's actually failing instead of the one that's cheapest to edit.

Career & Life Design·9 min read

How to Find a Software Architecture Mentor (Without Wasting a Year)

A good software architecture mentor reviews your real decisions and tells you the truth early — not a famous name or a $200/hour booking. How to spot the right mentor, where to find one, and how to ask without getting ignored.

Software Architecture·12 min read

I Over-Engineered a SaaS for Millions. It Got 3 Users.

I built a SaaS with multi-tenancy, event-driven architecture, and elaborate domain abstractions — for millions of users that never arrived. The product now serves two or three internal people in the same building. This is the architecture post-mortem, and the operating patterns that would have changed the outcome.

Software Architecture·24 min read

Scaling to Millions of Users: A Real-World Architecture Teardown

An anonymized teardown of a consumer platform I scaled to several million users. The architecture that carried ~30K req/s at peak, the four walls we hit on the way up — database connections, a cache stampede that caused a 19-minute outage, payment double-charges, and a credential-stuffing attack that looked like organic growth — and the trade-offs behind each fix. Topology, layered caching, the data tier, WAF and rate-limiting stack, and four real ADRs. No vendor named; the engineering is exactly as it happened.

Developer Productivity·19 min read

SpecLoom: Deterministic Context for Coding Agents

Most agent SDLC setups use the LLM as the runtime for everything—including deciding which files to read—which is the biggest source of token waste and non-determinism. SpecLoom flips this: write your spec as typed blocks with IDs and dependencies, and a deterministic compiler emits a minimal, hash-stamped bundle for one task. A real engineer bundle compiles to ~370 tokens instead of 20–60k, the same task always produces a byte-identical bundle, and @spec:ID#hash anchors turn spec/code drift into a CI failure. Covers the .loom format, the Deterministic Context Compiler, tiered budget degradation, the drift gate, engine-enforced persona gates, and a 60-second loop to try it.

Developer Productivity·22 min read

Shipping an AI Feature Right: A 7-Day Production Walkthrough

Most teams ship an LLM call in an afternoon and spend the next month firefighting. This walkthrough shows the correct order — spec, architecture decision, eval criteria, implementation, CI gate, production observability — using a real cloneable repo (spec-to-ship-workflow) that runs in 10 minutes with zero API keys. Covers the retrieval-confidence floor that prevents most RAG hallucinations, two-mode providers for CI reproducibility, golden test cases before implementation, and the eval drift alert that catches regressions no other metric sees.

Developer Productivity·12 min read

MCP Servers Explained: Giving Your AI Tools Real Context (A Practical Setup)

The number one reason AI coding agents produce confident, wrong code is they're guessing about your system. MCP (Model Context Protocol) fixes that — a standard way for agents to pull real context from real sources instead of you copy-pasting it. What MCP is (a USB-C port for AI tools), how to set up your first server, which context to expose (schema, docs, issues) and what to keep out, and the security model you must get right.

Software Architecture·18 min read

Software Architecture Patterns: A Reference Catalog with Diagrams, Failure Modes, and Code

A practical reference catalog of the eight architectures worth knowing — layered, modular monolith, hexagonal, event-driven, CQRS + event sourcing, microservices, serverless, and the strangler fig. Each with a diagram, the forces that make it the right call, the failure mode that makes it the wrong one, and a link to runnable reference code. Plus a decision flowchart so you pick on fit, not hype.

Software Architecture·11 min read

Evals for LLM Features: Building the Regression Net for a Non-Deterministic Dependency

You can't ship a reliable LLM feature on vibes. Evals are the regression net for a dependency that's non-deterministic, drifts when the provider updates the model, and fails silently. How to build one without boiling the ocean: start with 30 real examples, layer three kinds of checks (assertion, LLM-as-judge, human), measure faithfulness, and run it on every prompt, model, and retrieval change.

Developer Productivity·11 min read

Autonomous PRs: Letting Agents Open, Review, and Merge — Safely

Autonomous PRs are real leverage and a real way to drown your best engineers in review debt. The operating model: autonomy scales inversely with blast radius, you can only generate as many PRs as you can genuinely review, the three gates every autonomous PR must pass, and the metrics that tell you it's working instead of quietly rotting your codebase.

Software Architecture·15 min read

LLM Architecture in Production: RAG, Vector Databases, and the 7-Point System-Design Checklist

Adding an LLM to your product is a distributed-systems problem with a non-deterministic dependency, not a single API call. When RAG actually helps (and when a prompt will do), how to think about vector databases and chunking without cargo-culting, the retrieval pipeline that separates demos from products, and the seven-point production checklist — evals, guardrails, cost ceilings, latency budgets, fallbacks, observability, and a human-in-the-loop boundary — to put in place before a real user touches it.

Software Architecture·11 min read

RAG in Production: Chunking, Re-ranking, and Hybrid Search (The Deep Dive)

Naive RAG gets you a 70%-quality demo and a plateau. The gap to production is three retrieval levers most teams never pull: chunking on structure (not character counts), hybrid search (vector + keyword), and re-ranking an over-fetched candidate set. The deep dive on each, plus citations and the metrics that tell you where retrieval is failing. Retrieval quality beats model quality.

Technical Leadership·14 min read

AI Engineering Team Structure: The Generation–Review Ratio

AI moved the engineering bottleneck from writing code to reviewing it — and most org charts haven't caught up. The Generation–Review Ratio, why cutting junior hiring is a five-year trap, the four roles every AI-native team needs, and how to rewrite hiring and leveling for 2026.

Technical Leadership·11 min read

The Engineering Career Ladder: Writing Leveling Rubrics That Survive Calibration

Most career ladders are decorative — vague adjectives that fall apart the moment ten managers try to agree in a calibration room. A good ladder lets different managers reach the same level decision about the same engineer. How to build one that survives calibration: define levels by scope and autonomy (not years or output), make every rung observable, separate IC and management tracks as equals, and rewrite the rungs for the AI era.

Technical Leadership·11 min read

Blameless Postmortems That Actually Change Behavior

Most postmortems are theater — a root cause of 'human error', action items nobody owns, and zero change to the system that produced the failure. A real postmortem makes the same class of incident less likely. How: make it genuinely blameless (so you get the truth), hunt for systemic causes, write action items with owners and dates that actually ship, and treat the incident as a gift of information about your system.

Technical Leadership·11 min read

Hiring for Judgment in the AI Era: An Interview Playbook

The classic coding interview is now theater — it tests a skill AI commoditized and misses the one that matters: judgment. Can this person tell when AI-generated code is subtly wrong? The playbook: interview by having candidates critique and correct AI output, probe judgment under realistic conditions, separate 'uses AI as a crutch' from 'uses AI as a tool', and stop rewarding what a model does for free.

Developer Productivity·14 min read

AI-Driven Development: The Spec-First Workflow That Makes Agents Actually Useful

Vibe coding — prompt, accept, repeat — produces fast demos and slow disasters. The senior move is spec-first development: invest in a precise specification, let agents implement against it with MCP for real context, and gate everything behind tests, types, and human review of intent. The four-phase loop, why the spec becomes the asset when code is cheap, where autonomous PRs actually fit, and the failure modes (context rot, confident wrongness, review debt) that bite teams who skip the discipline.