// Topics / Reliability

Reliability

Definition

Reliability coverage in this archive spans 18 posts from Jul 2016 to Jan 2026 and focuses on reliability, delivery speed, and cost discipline as one system, not three separate concerns. The strongest adjacent threads are architecture, sre, and ai. Recurring title motifs include production, ai, outage, and taught.

Key claims

  • Most posts prioritize predictable operations over feature breadth or stack novelty.
  • Early posts lean on systems and production, while newer posts lean on engineering and outage as constraints shifted.
  • This topic repeatedly intersects with architecture, sre, and ai, so design choices here rarely stand alone.

Practical checklist

  • Set SLOs first, then choose tooling that keeps deploy, observability, and rollback simple.
  • Start with the newest post to calibrate current constraints, then backtrack to older entries for first principles.
  • When boundary questions appear, cross-read architecture and sre before committing implementation details.

Failure modes

  • Adding platform layers faster than the team can operate and debug them.
  • Chasing throughput gains without proving they improve end-user reliability.
  • Applying guidance from 2016 to 2026 without revisiting assumptions as context changed.

Suggested reading path

References

    Designing the AI Leadership Bench: Roles, Interfaces, and Failure Boundaries Canon post — AI scaling needs explicit leadership interfaces between product, platform, reliability, and governance. leadership teams ai How to Run an AI Incident Review That Changes Architecture, Not Slides Incident reviews should produce architecture deltas and control updates, not narrative theater. reliability ai governance AI Production Governance: A Maturity Model The gap between stable AI features and shipping chaos isn't tools—it's production governance. How mature teams evaluate, deploy, and roll back. governance ai reliability Why Most Enterprise AI Architecture Fails in Year One In 2026, enterprise AI isn't failing because models are bad. It is failing because organizations are building brittle demos instead of bounded, operable systems. architecture ai reliability Building Reliable AI Agents in Go Reliable agents are engineered, not prompted: bounded tools, validation at every step, explicit recovery paths. Here's how I build them in Go. agents reliability ai AI Incidents Don't Look Like Outages. That's the Problem. AI systems can return 200 OK while confidently wrong. How to detect, contain, and learn from AI incidents using proven incident response principles. incident-management ai reliability Agentic Workflows: From Demo Magic to Production Reality AI agents that can take actions are fundamentally different from chatbots. The engineering bar must match the blast radius. agents ai production Why I Run Multiple Models in Production Betting on a single model provider is like having a single database with no failover. Here is why multi-model is the only sane production strategy. ai architecture llm The AWS us-east-1 Outage Was Predictable. Your Architecture Was Not Ready. December 7 reminded everyone that us-east-1 is a single point of failure for half the internet. Again. I am annoyed. aws outage reliability What a 3 AM Outage Taught Me About Incident Management Good incident response is not about preventing failure. It is about failing well. Lessons from a decade of on-call, including NATO and telecom-scale operations. incident-management sre on-call Database Reliability Engineering: What I've Learned the Hard Way Practical database reliability from running Postgres in production: configs, safe migration patterns, and the operational habits that prevent outages. databases reliability sre Most Chaos Engineering Is Theater Teams love saying they do chaos engineering. Few actually have hypotheses. Even fewer fix what they find. chaos-engineering reliability sre Zero Downtime Deploys Are a Team Habit, Not a Tool Every team says they want zero downtime. Few want to do the boring work that actually gets them there. Here's what that boring work looks like. deployment devops kubernetes Your Load Tests Are Lying to You Most load tests produce comforting numbers instead of useful answers. Here's what I learned the hard way about getting honest results. testing performance reliability Your SLOs Are Probably Useless (Here's How to Fix Them) Most SLOs are dashboards nobody acts on. Pick indicators that reflect real users, set targets from data, and make error budgets change how your team ships. sre slo reliability Design for Failure or It Will Design Your Weekend Failure is not an edge case but the default state you hold off with good engineering. Hard-won rules for systems that bend instead of shatter. reliability architecture distributed-systems Async Job Processing: Patterns That Saved Us at a Fintech Startup Hard-won patterns for reliable background job processing -- queues, retries, idempotency, and the failures that taught me to care about all three. backend architecture async What Building Distributed Systems at a Fintech Startup Taught Me About Failure Hard-won lessons from designing distributed systems that survive real failures -- timeouts, retries, bulkheads, and the habits that keep things running. distributed-systems reliability architecture SRE Principles Are Great. The Cargo-Culting Is Not. The SRE hype train has everyone copying Google's playbook without asking whether it fits. What actually matters when you're not running at planet scale. sre devops reliability You Don't Need to Be Netflix to Break Things on Purpose Chaos engineering isn't just for the big players. Here's how a small team can start breaking things deliberately and actually learn from it. chaos-engineering reliability testing How I Build Data Pipelines That Actually Survive Production Every pipeline I've built at the fintech startup broke at some point. Here's the design approach that made them recoverable instead of catastrophic. data-engineering etl pipelines Building Resilient Systems: Lessons from Production Failures Production incidents show where architecture bends and breaks. Lessons on designing for failure, limiting blast radius, and making recovery routine. reliability resilience architecture