The archive
Writing
Ten years of operating notes, in reverse chronology. 356 entries since 2016, a continuous record of the same discipline applied to a moving target.
Long-form field notes for CEOs, founders, and technical leaders working through AI under real constraints: ownership, reliability, governance, cost, decision latency, and production reality.
The canonical reading path below is the clearest entry point into the current operating-model thesis.
Each post aims to answer five questions:
- What is the core claim?
- Why does it matter economically?
- What operating model makes it work?
- Where does it fail?
- What language should a leadership team reuse?
Browse by problem
// Canonical reading
- No. 01 Unsupervised AI-NATIVE OPERATING MODEL · AI-OPERATING-MODEL Producing work is close to free; knowing whether it is any good, undoing it, and answering for it are not, and that is where the weight of a company now sits.
- No. 02 Build the System the Model Cannot Break AI-NATIVE OPERATING MODEL · AI-OPERATING-MODEL An AI-native company is not the one that adopts the model fastest; it is the one whose operating model the model cannot break.
- No. 03 The Throughput Engineer: Why Headcount Is a Lagging Metric THROUGHPUT CULTURE · AI-OPERATING-MODEL Headcount is a lagging metric; the real throughput ceiling is how fast an organization can decide.
- No. 04 The CTO Communication Protocol for AI Programs CTO COMMUNICATION PROTOCOL · AI-OPERATING-MODEL AI programs fail when leadership communication stays ad hoc instead of becoming an operating protocol.
- No. 05 Why Most AI Platform Teams Become the New Bottleneck PLATFORM BOTTLENECKS · AI-OPERATING-MODEL A central AI platform team becomes a liability when every workflow improvement has to wait in its queue.
- No. 06 AI Roadmaps That Survive Contact With Reality REALITY-TESTED ROADMAPS · AI-OPERATING-MODEL An AI roadmap is only real if it can survive latency, ownership, and workflow constraints in production.
- No. 07 Decision Latency as a P&L Variable: The Leadership Metric Nobody Owns DECISION LATENCY · AI-OPERATING-MODEL Decision latency is a P&L variable because slow organizational decisions destroy AI leverage before the model does.
- No. 08 Designing the AI Leadership Bench: Roles, Interfaces, and Failure Boundaries LEADERSHIP BENCH · AI-OPERATING-MODEL Serious AI execution needs a leadership bench with explicit role interfaces, not a heroic single-threaded leader.
- No. 09 The Operating Cadence: Turning AI Leadership Interfaces Into Predictable Output OPERATING CADENCE · AI-OPERATING-MODEL Leadership interfaces only compound when the organization runs them on a predictable cadence.
- No. 10 The Post-Prototype AI Org: Operating Models That Survive Year Two POST-PROTOTYPE AI ORG · AI-OPERATING-MODEL The hard part of AI starts after the prototype, when the company has to become an organization that can actually run it.
// Topics
2026
Compliance Fails at the Vendor Handoff
You answer for an AI system you can only partly witness. Build a compliance interface to each vendor, with owners, deadlines, and drills.
Your AI Tool Needs an Adoption SLO
Seat counts can't justify an AI tool renewal. Define one adoption SLI, governed completions over eligible cases, with guardrails and a breach rule.
The Review Queue Is Your Real Agent Limit
Plan agent rollouts like capacity: risk-weighted review demand against effective reviewer-hours. Past the constraint, seats buy inventory, not throughput.
Content Marking Is a Pipeline, Not a Policy
The EU AI Act marking deadline for existing generative systems is 2 December. Provenance survives only what your pipeline keeps, so test it in CI.
Your Coding Agent Inherits the Engineer
A coding agent inherits every credential the engineer holds and none of the judgment behind them. Close that gap with a runtime boundary, not a ban.
Agent Scale Has a Company-Size Gap
Large firms report scaling AI agents; smaller ones sit flat. A small company needs one workflow with an owner, gate, boundary, spend cap, and off switch.
A Backup Model You Never Exercise Is Not a Backup
Vendor count is inventory; measured failover time is resilience. Shadow replay, a bounded canary, and a recovery clock with defined start and stop.
The Handoff Tax
80% report personal AI gains while EBIT impact stays flat. The handoff tax: task time down, throughput flat, queues rising at one nameable transition.
The Statistic Nobody Can Reconstruct
I tried to reconstruct '95% of AI pilots fail.' It isn't in the report it cites. Card the numbers that steer your decisions: licensed, expired, or retired.
Don't Book the Cut Before the Work Disappears
Expected AI headcount cuts outran reported ones last year. Let forecasts drive scenarios; book a saving only once the work has observably gone.
Autonomy Without a Demotion Path Is Permission Creep
Teams can describe how agents earn autonomy. Few can take it back. Write the transition contract: trigger, authority, mechanics, re-entry.
The Software You Didn't Buy Still Needs an Owner
Teams skip software purchases and build with agents. Each build is rational; the fleet is the risk. Agents compress upkeep but can't own it.
MCP Grew Up. Your Integration Debt Has a Clock.
The July MCP revision started a 12-month deprecation clock. Use it to find every agent-to-tool boundary, give each an owner, and test it.
The Rung Contract
Competency matrices describe skills. Apprenticeship needs a contract per rung: permission, evidence, reviewer, a promotion rule two managers apply alike.
Your Real Token Price Is a Cache Hit Rate
For input-heavy agent loops, effective token cost rides on cached-token share. Track your hit rate, and measure the cold-cache premium before you switch.
The EU Gave You a Reprieve, Not a Pardon
The Digital Omnibus deferred the AI Act's high-risk duties, not its live ones. Build a deferral ledger: one row per system and obligation.
The Eval Inversion
Two frontier labs lost containment this summer, in eval environments. The more adversarial the workload, the weaker the walls around it. Invert that.
The Junior Developer Cliff Is a Leadership Problem
AI eats the work juniors learned on. Rebuild apprenticeship around verification and ownership, or starve your senior bench.
Garbage Context, Confident Answer
Most AI failures are context failures wearing a model's face. Score retrieval with groundedness and margin, check freshness against live state.
Geopolitical Model Risk Is an Engineering Constraint
Export controls, gated releases, and open-to-closed reversals make model availability an architecture-review line item.
The Diffusion Gap: Why Pilots Don't Become Capability
Most AI pilots pass the trial and then die. Closing the gap takes ownership, cadence, and incentives. Write exit criteria as operating changes.
AI Insurance Will Ask for Evidence, Not Intent
As insurers exclude AI, protection tracks evidence, not intent. Your operating cadence is your audit trail.
The Board's AI Oversight Problem Is Operational
Board AI oversight is operational: a named owner per system, a rehearsed halt path, an incident threshold, and a failure rate you can defend.
Unsupervised
Producing the work can be handed to a machine. Answering for it cannot. What an organization values when machines do most of the making, what people are for, and four things to try this week.
Shadow AI Is an Operating Problem, Not a Ban
Banning AI tools removes your visibility, not the tools. Make the governed path the fast path and pull usage into the control plane.
Power Belongs on the AI Roadmap
Grid power and GPU quota arrive on lead times of months to years. Put region, capacity type, owner, and fallback next to every committed AI ramp.
Regulatory Divergence Is a Routing Problem
One global AI policy is wrong in every market. Tag requests by jurisdiction, data class, and user type, then route policy like cost and capability.
Reliability Is the Autonomy Ceiling
How much autonomy to give an AI agent: bound its failure rate with the rule of three, shadow mode, and fault injection, then price it by failure cost.
Your Vendor's Balance Sheet Is Your Risk
AI vendor risk you can price: compare the API price to a self-hosted floor, lock deprecation notice and export rights at signing, fund a warm fallback.
Agent Identity Is the New Control Plane
AI agents need workload identity, not shared API keys: SPIFFE SVIDs, RFC 8693 token exchange, and Vault leases make access scoped, attributable, revocable.
Token Prices Fell. AI Bills Did Not.
Per-token LLM prices keep falling while AI bills climb. Measure cost per completed task, reviewer time included, instead of price per token.
The Benchmark You Didn't Build
Use public LLM benchmarks as a shortlist filter, then decide on an owned eval: programmatic assertions, a versioned LLM judge, and paired per-case diffs.
Leading Senior Engineers in the AI Era: Autonomy, Standards, and Accountability
Leading senior engineers on AI features: a written definition of done with an owned eval, a named failure mode, a rollback drill, and a paging threshold.
Sovereignty-by-Design for AI: How to Win Regulated Enterprise Deals
AI data sovereignty an auditor can test: BYOK, in-region decryption, and which copies key revocation kills versus which need signed delete receipts.
Agentic Systems at Scale: The New Reliability Contract
An AI agent reliability contract is real only where the control plane enforces it: scoped credentials, a deny-by-default tool gateway, a sandbox.
The Anti-Fragile AI Organization
A warm LLM fallback is a standing cost that needs an owner. Price portability per feature, and turn each vendor shock into a capability you keep.
The AI Strategy Stack: What Boards Mistake for Moats
Models and prompt scaffolding are not AI moats. The defensible layer is a correction loop on your own work, tracked by escalation rate, and it depreciates.
From Model Demos to Profit Engines: The CTO Playbook for AI Unit Economics
AI unit economics: route requests by value and risk, price in failure and rework, and measure margin per workflow instead of per model call.
The New Talent Stack: Product, Platform, and Applied AI Must Work as One System
AI organizations create leverage when product, platform, and applied AI are designed as one operating system instead of three kingdoms.
The Executive Case for Local-First AI Infrastructure
When to run AI workloads locally and when to stay on cloud APIs: a placement rubric based on call frequency, data sensitivity, and fallback readiness.
The Post-Prototype AI Org: Operating Models That Survive Year Two
Year-two AI failure usually comes from org-design mismatch, not model-quality mismatch. The handoffs are where the system slows down.
The Operating Cadence: Turning AI Leadership Interfaces Into Predictable Output
Leadership interfaces decay without rhythm. A weekly metrics review, monthly outcome review, and quarterly architecture audit keep AI ownership real.
Designing the AI Leadership Bench: Roles, Interfaces, and Failure Boundaries
Scaling AI needs a leadership bench: named owners for product, platform, applied AI, and governance, with failure handoffs rehearsed before incidents.
Decision Latency as a P&L Variable: The Leadership Metric Nobody Owns
Slow decisions are a hidden cost. How to measure decision latency, from issue to decision to action, and cut it with clear ownership of decision classes.
The AI Vendor Negotiation Playbook for CTOs
A pre-meeting checklist for AI vendor contract negotiations: know your workload, switching cost, eval evidence, and exit plan before the vendor does.
How to Run an AI Incident Review That Changes Architecture, Not Slides
An AI incident review is done when it changes architecture, evals, alerting, or ownership. An eight-part template that ends in fixes, owners, and dates.
AI Roadmaps That Survive Contact With Reality
AI roadmaps fail when they are sequenced around ambition instead of dependency, verification, and rollback cost.
Hiring for AI Teams: The Operator Profile That Scales
The AI hires that scale are operators who handle ambiguity, systems tradeoffs, and verification pressure. Four traits and four interview questions.
Technical Leadership in the AI Era: Throughput Over Trends
Technical leadership in 2026: anchor decisions in throughput, verification, and operability instead of chasing the latest agent framework.
Stop Building Internal AI Tools No One Uses
Internal AI tools die quietly when teams optimize for launch over workflow fit, output trust, and post-launch ownership. One tool failed, one stuck.
Why Most AI Platform Teams Become the New Bottleneck
AI platform teams become bottlenecks when they centralize decisions instead of capabilities. The warning signs, the metrics that expose it, and the fix.
Build the System the Model Cannot Break
A manifesto for AI-native organizations: twelve tenets across strategy, architecture, economics, and people, and the one test that matters in year two.
The CTO Communication Protocol for AI Programs
AI programs fail when engineers, executives, and investors hear different definitions of success. A communication cadence that keeps one true story.
AI Governance Without Bureaucracy
AI governance that works: tighter defaults, named owners, fast escalation, and a small control stack engineers can follow at 2 a.m. No new committees.
Measuring AI Progress Without Theater: A Board Scorecard
Most AI progress reporting confuses activity with value. Executive measurement should collapse around adoption, reliability, margin, and delivery speed.
AI Build vs. Buy in 2026: An Operational Cost Question
AI build vs. buy in 2026 turns on operational cost: who owns telemetry, fallbacks, and data residency. When to buy, when to build, and the hybrid default.
AI Strategy Metrics: Margin, Risk, and Speed
Replace AI novelty metrics with three executive numbers: margin, risk, and speed. Give each a baseline, target, owner, cadence, and rollback path.
AI Evaluation and Production Governance: A Maturity Model
A five-level maturity model for AI evaluation and production governance, from vibes-based deploys to CI eval gates, production sampling, and rollback.
Why Most Enterprise AI Architecture Fails in Year One
Enterprise AI architecture fails in year one when teams expect deterministic behavior from a statistical engine. Build failure boundaries and telemetry.
AI Capital Allocation: What to Stop Funding First
Strong AI strategy starts with a kill list. If a project cannot defend margin, risk, or speed, it should not survive the next budget meeting.
AI Strategy for CTOs: It's Data Infrastructure
AI strategy for CTOs: the moat is the context pipeline, the eval loop, and the fallback path. Picking a model is the easiest problem in the room.
Data Sovereignty by Design: Privacy as Architecture
Data privacy and residency are architecture constraints. Four minimum controls, zero-trust data access, and multi-region tradeoffs to build in early.
The Throughput Engineer: Why Headcount Is a Lagging Metric
Headcount is a lagging metric. The best engineering organizations measure throughput: decision speed, defect containment, and constraint removal.
Why AI Agents Fail on Legacy Network Infrastructure
Many AI agent failures trace to the network: stale DNS, flat trust, retry storms, shallow queues. Zero-trust identity and per-step reliability fix them.
Red-Teaming Distributed Databases Before the Black Swan
Most catastrophic distributed database incidents are compound failures nobody practiced. How to red-team partitions, clock skew, and operator error.
Local-First AI Agents: Why Cloud-Heavy Architecture Fails
Agents that chain dozens of cloud hops pay in latency variance, cost, and failure surface. How to move routine inference local without a rewrite.
AI Startups in 2026: Where the Leverage Is
What buyers of AI startups reward in 2026: workflow ownership, data loops, integration depth, and predictable cost per outcome. Novelty stalls at pilot.
AI Security in 2026: Prompt Injection, Agents, and Defenses
Multi-step prompt injection and tool-based exfiltration target AI agents in 2026. The layered defenses, monitoring, and security review I use.
AI Team Structures 2026: Central, Embedded, and Hybrid Models
Central, embedded, or hybrid AI team? How to decide where AI ownership lives, with roles, tradeoffs, platform-to-product ratios, and scaling rules.
AI Inference Cost Trends 2026: LLM Prices, September Update
LLM API prices now run from $0.10 to $10 per million input tokens. A sourced September 2026 price table, the trend since GPT-4, and where savings come from.
AI Regulation Is Here: Treat Compliance as Engineering
AI regulation already shows up in procurement and security reviews. How to build compliance evidence into the delivery pipeline instead of bolting it on.
AI-Native Architecture Patterns 2026: Production Guide
AI-native architecture patterns for production: an AI gateway, a retrieval layer, an evaluation pipeline, fallbacks, cost control, and clear ownership.
Building Reliable AI Agents in Go
How I build reliable AI agents in Go: bounded tools, schema validation at the boundary, idempotent state, and a supervisor loop with hard limits.
Video AI in Practice: Pipelines, Evaluation, Human Review
Video AI is practical for scoped workflows. A reference pipeline, the evaluation metrics that matter for video, and where human review still belongs.
AI Predictions for 2026: Bounded Agents, Routing, Governance
What I expect from AI in 2026: bounded agents in production, routing across models, MCP as the tool layer, and governance on the critical path.
2025
2025 Year in Review: AI Stopped Being Special
AI in 2025: What Held Up in Production and What Didn't
Scaling AI in the Enterprise Is a Management Problem
AI Incident Response: Failures That Don't Look Like Outages
AI Technical Debt: Prompts, Evals, and Pipelines Nobody Owns
AI and Team Productivity: Shared Infrastructure Wins
Measuring AI ROI Without Lying to Yourself
AI Data Privacy Is a Plumbing Problem
AI Pair Programming: It's a Junior Dev, Not a Wizard
Running LLMs Locally: A Team Guide With Ollama and Go
AI Workflow Automation: Let the Model Decide, Let Code Act
AI Documentation Search: Versioned Retrieval and Citations
AI Product Metrics: Measure Task Success, Not Usage
When to Fine-Tune an LLM: Prompt and Retrieve First
AI Customer Support: Design for Handoff, Not Deflection
AI Data Pipelines for RAG: ETL With a Retrieval Layer
Multi-Agent Orchestration: Four Patterns and Their Tradeoffs
AI Security: Prompt Injection and the New Attack Surface
Testing AI in Production: Shadow Mode, Canaries, Holdouts
AI Observability: Green Dashboards, Wrong Answers
Model Context Protocol in Go: Building an MCP Tool Server
AI Governance That Works: Risk Tiers and System Cards
Video Understanding AI: Transcript First, Frames Second
AI Code Review Is Mostly Noise
Reasoning Models in Production: A Practical Guide
AI Trends for 2025: Why Engineering Discipline Wins
2024
AI in 2025 Will Reward the Boring Teams
2024: The Year AI Got Boring (In a Good Way)
AI Infrastructure at Scale Is Just Infrastructure
Building AI Teams: Ownership and Evaluation Beat Hiring
Picking an AI Model for Production (Late 2024)
AI Safety in Production Is Defense in Depth
AI Agent Patterns in Go: Planning, Memory, Recovery
LLM Cost Benchmarking: Measure Cost per Completed Task
RAG Retrieval in Go: Hybrid Search, Chunking, Reranking
AI for Technical Documentation: Drafts Yes, Ownership No
AI-Assisted Code Migration: Lessons From 200K Lines of Go
How I Test LLM Features: Three Layers, One Cadence
Small LLMs in Production: Use the Smallest Model That Works
Context Window Budgets: Stop Stuffing Your LLM Prompts
LLM Function Calling Patterns That Survive Production
Claude 3.5 Sonnet Analysis: Cost, Coding, and Model Routing
Enterprise AI Compliance Without the Theater
Why Enterprise AI Pilots Stall Between Demo and Production
Building Voice AI: Latency, Interruptions, and Narrow Scope
GPT-4o Changed the Interface, Not the Hard Part
LLM Structured Output in Go: JSON Schema, Validation, Retries
Most AI Developer Tools Are Not Worth Adopting Yet
Agentic Workflows in Production: Constrain the Blast Radius
LLM Response Caching in Go: Cut Costs Without Breaking Things
Multi-Model LLM Routing and Fallbacks in Production
Claude 3 First Impressions: Picking Opus, Sonnet, or Haiku
LLM Evaluation: Stop Shipping on Vibes
Architecting AI-Native Applications (Without the Delusion)
Local LLMs for Development: Stop Paying to Test Prompts
AI Engineering Is Its Own Discipline Now
2023
2023 Year in Review: LLM Integration, Payments, and Go
Scaling AI Features: GPUs, Rate Limits, and Backpressure
GPT-4V Use Cases: Five That Work, Three That Don't
OpenAI Assistants API: Two Weeks of Real Use
OpenAI DevDay 2023: What It Means for Build vs Buy
AI Coding Assistant Productivity: Three Months of Numbers
LLM Security: A Field Guide for People Who Ship Things
Responsible AI Is Operational Risk Management
AI Technical Debt: Prompts, Models, and Evals Nobody Tracks
AI Agent Architecture Patterns for Production
AI Product Strategy: Start With the Problem, Not the Model
LLM Observability: Monitoring Quality, Not Just Uptime
What I Learned Building AI Features Into a Fintech Product
LLM Cost Optimization: The Basics Most Teams Skip
Embedding Models Compared: Quality, Cost, and Latency
AI Startups and the GPT Wrapper Problem
Building Semantic Search in Go with OpenAI and pgvector
Restructuring Engineering Orgs After Layoffs
AI Code Review: What It Catches and What It Misses
Fine-Tuning vs. Prompting: A Decision Framework
LangChain Is the New ORM: Convenient Until It Is Not
RAG in Production: Patterns That Survive Real Traffic
Vector Databases Explained: What They Are, When You Need One
Claude vs GPT-4: Two Weeks Using Both
AI Safety Is Just Security Engineering With Extra Steps
My First Week Building with GPT-4
Leading Engineering Teams Through Uncertainty
Prompt Engineering Is Not Engineering
LLM Integration Patterns That Survive Production
AI in Production Is an Engineering Problem
2022
2022 Year in Review: The Year the Music Stopped
Cloud Cost Optimization Starts With Visibility
Resilient Engineering Teams Are Boring Teams
Five Days With ChatGPT: First Impressions From an Engineer
GitHub Copilot After Six Months: Faster Drafts, More Review
Terraform Patterns That Scale: Modules, State, Promotion
Tech Layoffs 2022: What I Saw From the Inside
Platform Engineering: DevOps Grew Up
Monorepo vs. Polyrepo: A Practical Decision Guide
Engineering Metrics: DORA, Error Budgets, and DevEx Signals
Cloud Cost Management: You Do Not Need a FinOps Team
Testing Microservices: Contract Tests Over End-to-End Suites
Kubernetes Requests and Limits: Lessons From an Outage
Go Concurrency Patterns I Use in Every Service
Caching Strategies: Adding It Is Easy, Invalidation Is Hard
Async Architecture: When to Go Async and When Not To
Container Image Scanning Without the Security Theater
Rate Limiting: The Boring Feature That Saves You at 3 AM
Engineering Documentation: Owners, Doc Types, Docs as Code
Distributed Systems Patterns I Keep Reaching For
TypeScript Best Practices From a Go Developer
PostgreSQL Performance: Measure First, Tune Second
OAuth Token Security After the Heroku and Travis CI Breach
Service Mesh Decision Guide: You Probably Don't Need One Yet
Engineering Onboarding: Ship a Real PR by Day Three
API Versioning: Pick One and Stop Overthinking It
Zero-Downtime PostgreSQL Migrations Without the Drama
Kubernetes Security Hardening: Pods, RBAC, Network, Secrets
DORA Metrics: Keep Them Off Performance Reviews
After Log4Shell: Dependency Visibility and Patch Speed
2021
2021 in Review: The Year Everything We Ignored Caught Fire
The December 2021 AWS us-east-1 Outage Was Predictable
Log4j CVE-2021-44228 Response: What to Do Right Now
Terraform at Scale: What Changed Since 2019
What a 3 AM Outage Taught Me About Incident Management
OpenTelemetry in Late 2021: What's Ready and What's Not
SRE Team Structures: Stop Renaming Your Ops Team
Platform Engineering Maturity: Why Teams Stall at Level 2
Event Sourcing in Go: Lessons From Financial Event Pipelines
Kubernetes Cost Optimization: Right-Size Requests First
GraphQL Federation in 2021: Most Teams Still Don't Need It
Most 'Technical Debt' Is Just Decisions You Disagree With Now
Feature Flags at Scale: Ownership, Expiry, and Cleanup
Zero Trust Architecture: Identity First, Then Segmentation
Postgres Reliability: Restores, Failover, Safe Migrations
WebAssembly Beyond the Browser: A 2021 Progress Report
Serverless Databases vs Postgres: Most Teams Need Postgres
GitHub Copilot: First Impressions From a Go Developer
Observability-Driven Development: Instrument Before You Ship
Remote Work for Engineering Teams: Benefits and Dangers
API Gateway Patterns: Edge, BFF, and Service Mesh Ingress
Data Engineering Patterns: Batch vs. CDC vs. Streaming
Hybrid Work for Engineering Teams Is Harder Than Full Remote
DevSecOps in Practice: The Pipeline Controls I Implement
Multi-Cloud Is Mostly a Marketing Strategy
MLOps Fundamentals: Fix the Basics Before Buying Tools
Internal Developer Portals: Start With the Service Catalog
Rust vs Go for Cloud Services: A Go Developer's View
GitOps and Canary Rollouts: No More Gambling on Deploys
eBPF for Observability: Interesting, but I'm Not Sold Yet
Supply Chain Security After SolarWinds: Where to Start
2020
2020 in Review: The Year That Broke the Playbook
SolarWinds Supply-Chain Attack: Lessons for Build Pipelines
Container Runtime Security: Seccomp, Network Policy, Falco
Apple M1 and ARM Servers: What Changes for Infrastructure
Zero Trust vs VPN: How to Migrate Off the Perimeter
Platform Engineering vs DevOps: Mostly a Rebrand
API Gateway Build vs Buy: Kong, Envoy, or Custom Go
Distributed Engineering Teams: What Works Six Months In
Observability for Small Distributed Teams: A Minimal Stack
Developer Productivity Metrics: Why I Only Trust DORA
GraphQL Federation: Why Most Teams Don't Need It
Kubernetes Operators in Go: Lessons From Six in Production
GitHub Actions in Production: Matrix, Caching, Secrets
Event-Driven Architecture: What I Got Wrong, What Survived
Serverless vs Containers: Where the Math Stops Working
Chaos Engineering Without Hypotheses Is Theater
Kubernetes Requests and Limits: How I Size Resources
Remote Engineering Interviews: What I Changed Over Zoom
gRPC in Production with Go: Protos, Deadlines, Errors
State of Linux Usability 2020: Distros vs Windows and macOS
VPN Overload in 2020: Why Scaling the VPN Is the Wrong Fix
AWS Security While Scaling Fast: Make Secure the Default
Async-First Remote Work: Stop Recreating the Office on Zoom
Business Continuity for Engineering Teams: Beyond the Binder
Scaling WebRTC Video: SFUs, Simulcast, and TURN Costs
Remote Overnight: The First Two Weeks for Engineering Teams
WebAssembly Outside the Browser: Real Promise, Real Gaps
Terraform Testing: Static Checks, Policy, and Integration
API Versioning Strategies: Why I Use URL Path Versioning
PostgreSQL Replication Patterns: Async, Sync, and Quorum
Kubernetes Predictions for 2020: Day-Two Operations Win
2019
2019 in Review: The Year I Quit, Built, and Started Over
FinOps for Engineers: The Cloud Bill as a Design Document
Edge Computing Is Usually Premature Optimization
How I Build CLI Tools in Go: Patterns That Hold Up
Zero-Downtime Deployments: Migrations, Probes, and Habits
Engineering Onboarding: First PR on Day One
Terraform at Scale: Splitting the State Monolith
Message Queue Patterns: Idempotency, Retries, Dead Letters
Load Testing Strategies That Find Real Breaking Points
Developer Experience: Internal Platforms vs Ad-Hoc Tooling
Data Mesh: Fix Data Ownership Before Architecture
Security Incident Response: Drills Beat Written Plans
Monolith to Microservices: When to Split and How
Multi-Region Architecture: You Probably Don't Need It Yet
Testing in Production: Why Staging Misses the Real Bugs
SLOs and Error Budgets That Change How Teams Ship
Designing for Failure: Timeouts, Circuit Breakers, Failover
Kubernetes Security Hardening: Fixing Insecure Defaults
Cloud Cost Optimization: Cut Waste Before Buying Discounts
PostgreSQL Performance Tuning: The Playbook I Use
Internal Developer Platforms: Treat Them as Products
API Design Lessons: Every Field Is a Contract
GitOps with Flux and Argo CD: Stop Deploying From a Laptop
Incremental TypeScript Migration Without Losing Your Mind
Kubernetes Production Checklist: The Boring Basics
2018
2018 in Review: Spectre, GDPR, and a Humbled Tech Industry
Async Job Processing Patterns: Queues, Retries, Idempotency
How We Track and Prioritize Tech Debt at a Fintech Startup
Istio 1.0 in Practice: Powerful, Painful, Often Overkill
Scaling Engineering Teams: What Breaks at 10, 25, and 50
Terraform in Production: Repo Layout, Modules, and State
API Rate Limiting: Token Buckets, Redis, and Headers
Code Reviews: Fixing Rubber Stamps and Nitpick Wars
Partial Failure in Distributed Systems: Lessons From Fintech
Serverless Patterns and Anti-Patterns: Lessons From Lambda
Container Security in 2018: PSP, Distroless, Image Signing
Database Sharding: You Probably Don't Need It Yet
Microservices Security: Identity, mTLS, and Secrets
Monitoring vs Observability: Lessons From a Silent Outage
Making Go Services Fast: Profiling, Allocations, Timeouts
GraphQL in Production: N+1 Queries, Caching, and Tracing
GDPR Week One: Lessons From a Fintech Startup
GDPR for Engineers: What We Built at a Fintech Startup
SRE Principles for Small Teams: Skip the Cargo Cult
Technical Interviews: Work Samples Beat Whiteboard Puzzles
Kubernetes Operators: Powerful, but Overhyped
Event Sourcing in Practice: What I Got Right and Wrong
Rust vs Go for Backend Services: A Go Developer's First Look
Zero Trust Architecture: Building It at a Fintech Startup
ML in Production for Backend Engineers: It's Mostly Plumbing
Two Years of Kubernetes in Production: The Boring Parts
Spectre and Meltdown: What We Patched in the First Five Days
2017
Building a Platform Team: Lessons from Our First Year
Technical Debt Triage: A Simple Prioritization Framework
Async-First Engineering Teams: Cutting Decision Latency
Container Security Beyond the Basics: What We Hardened
Service Mesh: You Probably Don't Need One
Code Review Quality: Stop Counting Reviews, Start Reading
Incident Management for Growing Teams: What to Change
Engineering Manager vs Tech Lead: How the Roles Differ
Multi-Region Architecture: What I Wish Someone Had Told Me
Security Champions: Startup Security Without a Security Team
The Business Case for Infrastructure: Pitch It in Money
Chaos Engineering for Small Teams: No Netflix Required
PostgreSQL Performance Tuning: Stop Guessing, Measure First
Security Automation in CI: Stop Reviewing by Hand
Hidden AWS Costs: Why the Bill Doesn't Match the Calculator
Technical Leadership Without Authority: What Works
Serverless Patterns for Production: Lessons from AWS Lambda
API Versioning Strategies: What Works and What Doesn't
WannaCry Postmortem: Unpatched SMB and Flat Networks
Data Pipelines That Survive Production: How I Build Them
Event-Driven Architecture: Why We Switched and What Broke
Observability vs Monitoring: Why Dashboards Aren't Enough
GDPR Is an Engineering Problem: A Technical Checklist
GraphQL vs REST: Pick the Boring One
Kubernetes in Production: What Paid Off and What Bit Us
2016
2016 in Review: The Year I Stopped Fighting Infrastructure
Securing APIs: Authentication and Authorization Patterns
Production Monitoring: Why We Deleted 42 Grafana Panels
Building a Startup Engineering Team: Lessons from 2016
Why We Chose Go for Our Backend Services
Scaling PostgreSQL: Why Scaling Up Beats Sharding
Technical Due Diligence: What Investors Actually Check
Container Orchestration: Docker Swarm vs Kubernetes vs Mesos
Building a Security-First Engineering Culture
Why Every Developer Should Understand Networking
Log Aggregation at Scale: ELK vs Alternatives
Zero-Downtime PostgreSQL Migrations: Expand and Contract
Hiring Engineers When You Can't Compete on Salary
Building Resilient Systems: Lessons from Production Failures
Cloud vs Colocation for Startups: The Real Cost in 2016
Why I Moved Our AWS Infrastructure to Terraform
Continuous Deployment Without the Chaos
Security Incident Response Playbook for Startups
REST API Design Principles That Stand the Test of Time
Ansible vs Puppet vs Chef: Why Ansible Won for Us
Postgres vs MySQL in 2016: A Practical Comparison
AWS Lambda: When Serverless Makes Sense and When It Doesn't
Building a DevOps Culture from Scratch
The True Cost of Technical Debt, and How to Measure It
Docker in Production: Lessons from Running Containers
Microservices vs Monolith: Why Small Teams Should Wait
No entries match.