184 posts
EN ES

“Every pixel matters.”

Writing on agentic AI, MLOps, and the systems behind them.

Juan Cardena — Enterprise AI & Agentic Systems Architect. 25 years across web, software, data, AI. MIT CDAO ’25.

New · Cinema Every Pixel Matters A short film on 25 years, from the bit, to the pixel, to the sky. Full cinema →
Sort
An exploded view of glowing gold layers stacked in a navy void AI
The Enterprise Agent Platform, Decomposed
July 2026

Strip the branding off an enterprise agent platform and it is six layers: identity, index, model tier, gateway, orchestration, governance. A map you carry between clouds.

8 min read
An architect's drafting table at night with brass instruments and a glowing blueprint of interlocking gears Software Includes: ebook
Governing Rust by Contract: Owning the Bits, From the Compiler to the Cluster
November 2026

A free guide to governing a Rust adoption: what the compiler proves, what tooling must enforce, and what operations and people still own, with contract cards and templates.

6 min read
A precise copper rail and a fast blue conveyor running side by side through a dim industrial hall Software
Rust vs Go for Enterprise Architecture: A Decision-First Comparison
November 2026

A fair, decision-first look at Rust and Go for enterprise teams: what each optimizes for, supply chain, concurrency, errors, containers, and when to choose each or both.

12 min read
Hero image for: Observability for the Undecidable: Debugging Non-Deterministic Agent Paths Data
Observability for the Undecidable: Debugging Non-Deterministic Agent Paths
November 2026

Discover how to debug non-deterministic AI agent paths by tracing internal thought processes and using behavioral evaluation, ensuring trust in enterprise agentic systems.

10 min read
A foundry crucible pouring molten light into a mold, like raw capability shaped by design Writing Includes: cinema, ebook, video
AI Foundry by Contract: Delivering Governed AI on Azure
November 2026

A free field guide to Microsoft Foundry on a governed Azure landing zone: projects, roles, models and quota, private networking, safety, evaluations, tracing, the AI gateway and agents by contract.

3 min read
Stacked glass platforms joined by gold frames, like the layers of a governed cloud estate Writing Includes: ebook
Governing Azure by Contract: A Layer-by-Layer Guide to a Governed Azure Platform
November 2026

A free field guide to governing Azure layer by layer: tenant, management groups, dev/test/prod subscriptions, roles and PIM, policy, network, security, visibility and cost.

3 min read
A ledger of dated rows, each linked by a line to a test checkmark Writing
The Failures Register: Every Mistake Becomes a Rule
November 2026

An append-only failures register: each production failure closes as a new test, a contract amendment or a signed risk acceptance, so the same failure cannot return silently.

9 min read
A short document of numbered articles above a row of agent terminal windows AI
Give Every Agent a Constitution
November 2026

Unwritten agent rules do not scale. A short constitution of purpose, authority, prohibitions and stop-and-ask lines sits under role rules and briefs, and the stricter layer always wins.

9 min read
A contract at the center of a ring of doors labeled git, tools, APIs, streams, browser, terminal and agents AI Includes: ebook
The Contract Decides: Governing AI at Every Door
November 2026

A field guide to governing production AI agents with written contracts at every door: tools, APIs, streams, memory and other agents. Outcome first, enforced and evidenced.

8 min read
A quiet status board over a row of stopped scheduled jobs Software
Silence Is Not Health: The Run-Record Contract for Scheduled Work
November 2026

Scheduled jobs can miss cycle after cycle while the status view stays calm, if silence is modeled as success. Every run must leave a record; a missing record is an alarm.

7 min read
Two rack servers joined by a cable with a glowing link light Software
Remote Capacity Is Not Resilience: Governing Shared Compute Dependencies
October 2026

Spare compute is not resilience. How our team added capacity to a production tier through a job contract, and why remote memory must never become the safety net.

9 min read
Many small terminal windows arranged in layers on a navy grid AI
Agent Fleets Need a Session Platform, Not Another Editor
October 2026

Long-running agents need sessions that survive restarts, can be addressed, and stay within bounded resources. Why our team is designing a session platform around those contracts.

7 min read
An open book beside a sandbox box with a small agent icon inside AI
Reading OpenHands: What to Borrow from an Open Agent Runtime, and What to Refuse
September 2026

An architecture review of OpenHands against production guarantees: the event log, run governor and path rules worth borrowing, and the advisory security we refuse.

8 min read
Five stacked layers of a messaging system with a lock on the top layer Software
Contracts Before Code: Guarantees for a Production Messaging Layer
September 2026

Before implementing a messaging layer, we defined its contracts: membership enforced by the protocol, order in the same write, reconnect as truth, empty push, shippable licenses.

9 min read
A row of slim control bars across several displays with a search panel listing session windows AI
A Control Surface for Agents: Making Concurrent Sessions Visible
September 2026

When many agent sessions run at once, the failure is losing the one that is waiting. How our team made session visibility an operator surface with explicit contracts.

9 min read
A tree of machines, windows, project groups and sessions under one control window AI
One Control Plane for Agent Sessions: Ownership, Not Copies
September 2026

When agent sessions outgrow editor windows, the failure is missing contracts. Machine, IDE, project group and session, one session contract, and a control plane that holds no state.

8 min read
Layered diagram of apps, storage and an ingress moving from a server rack to a cloud Software
Moving a Kubernetes Estate to the Cloud: Prove the Base, Name Every Byte, Then Cut Over
August 2026

A platform migration fails on the layer nobody looked at. How our team moves a Kubernetes estate: a proven minimal base, a data audit per workload, and a gate at every phase.

8 min read
A magnifying lens of light over a field of glowing cloud nodes and hidden connections Writing
API Keys Are Spend Contracts: Bound Every Credential Before It Can Bill
July 2026

A few of our API keys were compromised and we contained it. Why an AI key is a spend contract, and the five bounds every key now carries: scope, vault, caps, owner, limits.

8 min read
A wireframe room turning photoreal, framed like a storyboard panel AI
Governing a Generative Media Pipeline: Human Ownership Where Agents Scale
July 2026

Agents can generate and score media at scale. They cannot own story, taste, edit or sound. How we govern a generative media pipeline with a human owner at every gate.

8 min read
A continuous gold control loop circling a navy fleet of structures AI Includes: cinema, ebook
Security Is a Signal, Not a Checklist
July 2026

An audit is a photo of security posture on one day. Our team runs posture as a live signal: owned findings, fenced fixes, and human attention spent only on real decisions.

10 min read
A hand-off of a scoped-down, time-limited glowing gold key AI
Acting On Behalf Of: Delegation Without Standing Privilege
July 2026

When an agent acts for a person it should borrow only that person's authority, for that task, then give it back. Delegation without standing privilege.

7 min read
A gold gauge measuring flowing rivers of light, a budget dial AI
Paying for Agents: Cost Control for Agent Fleets
July 2026

Agents can spend at programmatic speed. The controls that keep them affordable: route by task, reuse work, cap with budgets, and watch headroom as a metric.

8 min read
A single grand gold gate all channels of light must pass through in a navy void AI
One Front Door: Tool Gateways as Policy Enforcement Points
July 2026

When every agent reaches every tool directly, you get a mesh nobody can govern. One tool gateway makes it a front door where policy, auth, and cost live.

8 min read
A navy library of gold documents where a beam reveals only some shelves Software
The Index That Knows Who's Asking
July 2026

An enterprise retrieval index must return only what the person asking is allowed to see. Why identity-gated retrieval is a design problem, not a filter you bolt on later.

8 min read
A faceless gold identity token scanned by a beam of light in a navy vault AI Includes: ebook
Who Is the Agent? Identity for Non-Human Actors
July 2026

As software agents start acting on their own, the hard new question is not what they can do but who they are. A field guide to identity for non-human actors.

9 min read
A single point of gold light on deep navy expanding into a glowing planet and then scattering into a constellation of smaller lights, abstract, no text. AI Includes: cinema, ebook
Azure Became Microsoft's New Operating System
June 2026

A builder's read of how Azure became Microsoft's distributed operating system: the cloud wins by disappearing, and ground that is owned is not ground that is free.

13 min read
A glowing gold checkpoint gate between a swirling cloud and an ordered structure AI
LLM Proposes, Code Enforces
June 2026

Reliable agentic AI architecture: the model proposes, deterministic code enforces, RAG is retrieval done well, route by task. Trust lives in the code around the model.

9 min read
Many gold threads weaving into one strong rope across a deep navy void Writing
Leading Without Authority
June 2026

How senior engineers lead large efforts without org power: through credibility, coalition, conflict handled well, and framing every idea around the other person's goals.

7 min read
A fortified vault door with glowing gold locks set into a navy wall Software
Security and Ops from Day One
June 2026

The boring parts of running production Kubernetes (secrets, least privilege, network isolation) are the real job. Security and operations are designed in, not bolted on.

9 min read
A finished tool on one side and an empty office of people on the other Software
Shipping Is the Easy Part
June 2026

Why shipping an internal tool is the easy part, and adoption is the hard, unglamorous work that decides whether the thing you built actually mattered.

10 min read
A warm human library of books on one side, dissolving into a vast cold network of light, a nervous system, on the other. AI Includes: cinema, ebook
Git Is a Bookshelf. Agents Need a Nervous System.
June 2026

We have built software with Git since the early 2000s. It is 2026 and we never re-engineered how we work for what AI agents can build. Git is a bookshelf; agents need a nervous system.

10 min read
An ocean of flowing liquid light freezing mid-motion into a glowing crystalline lattice. AI Includes: cinema, ebook
Model Quantization: the Ocean and the Crystal
June 2026

Quantization isn't 'making models smaller', it's cashing in over-parameterization slack to fit a giant mind in a small machine. Why it works, where it silently breaks, why the frontier won't ship it.

13 min read
A single glowing loop dissolving into a vast planetary mesh of event-nodes and reaction-edges, deep navy with gold accents. Software Includes: cinema, ebook
The Mesh: agentic AI after the loop
June 2026

The loop isn't the architecture of agency — it's local cognition inside one worker. The future is agents living in an event-driven mesh, reacting continuously to a world that never waits.

13 min read
A lone human silhouette at the center of four converging beams of colored light weaving into a single glowing solid, on deep navy. AI Includes: cinema, ebook
Council of Mirrors: how a human and a council of models actually decide
June 2026

A human convening a council of reasoners that debate and converge beats a smarter single model — and the dark geometry of how consensus can look like agreement while being quietly wrong.

14 min read
A single point of warm gold light reaching a thread out to touch a structured world and receiving a signal back, on deep navy: the reason-act-observe loop. AI Includes: cinema, ebook
The Loop That Started It All: a close read of ReAct (2022)
June 2026

A close read of ReAct (2022): the paper that crystallized the reason-act-observe loop for the LLM era, and why that loop, not intelligence, is the structure that makes an agent earn its answers.

10 min read
A single still point of golden light at the center of a fast-spinning ring, on deep navy: the hero frame of the film In the Loop. AI Includes: cinema
In the Loop: how agentic AI actually works with humans
June 2026

The companion essay to the short film In the Loop: how agents move at machine speed, why the refinement loop earns quality, and why a human at the center keeps the whole thing aligned.

7 min read
Many points of developer light, an agent loop, and a router deciding how much to spend AI Includes: ebook, video
Ten engineers, the output of thirty: the honest enterprise agentic playbook
June 2026

Enterprise agentic AI for software teams: the Agency Router pattern, the four model tiers, AI coding-agent governance, and the honest 1.7-2.1x ROI a CIO can defend to a board.

18 min read
A single point of light beside a convened ring of specialist lights, over a clinical blue field AI Includes: video
Most questions don't need the swarm: what medicine's agentic AI taught me
June 2026

A deep read of MDAgents (NeurIPS 2024): a medical AI that decides how many agents a question deserves, and why its restraint is the part you can actually deploy.

14 min read
Hero image: a clear reservoir going green and stagnant, the green water rising into the shape of a mouth Data Includes: video
The Data Swamp Never Drained. We Just Taught It to Talk.
June 2026

I watched the data lake rot into a swamp for fifteen years. AI is repeating it one abstraction up, and this is the first swamp that feeds itself.

34 min read
Hero image: tangled points in a plane lifting into a higher dimension where a single plane separates them Data Includes: video
We fear the curse of dimensionality. In 1965, Cover proved it's the whole trick.
June 2026

Thomas Cover's overlooked 1965 theorem: the geometry behind why embeddings, kernels, and neural nets work at all. We fear high dimensions as a curse, Cover proved they're the blessing.

13 min read
Hero image for: What 25 years across web, software, data, and AI taught me about durability Software Includes: video
What 25 years across web, software, data, and AI taught me about durability
June 2026

Juan Cardena reflects on 25 years across web, software, data, and AI, sharing architectural principles that ensure durability amidst technological shifts.

8 min read
Abstract: cursive handwriting becoming neural network and flowing tokens Data Includes: video
We credit the Transformer. The blueprint was already drawn in 2013 — on handwriting.
June 2026

An honest review of Alex Graves's overlooked 2013 paper 'Generating Sequences With Recurrent Neural Networks' — and what it reveals about which idea really changed AI.

13 min read
Hero image for: The Latency and Cost of Agentic Ambition: Productionizing LLM Workflows Data Includes: video
The Latency and Cost of Agentic Ambition: Productionizing LLM Workflows
June 2026

Productionizing LLM agentic workflows demands architecting for cost and latency. Learn how semantic caching, deterministic controls, and observability build durable, cost-effective systems.

11 min read
Hero image for: When data and AI must not fail, I reach for Rust Data Includes: video
When data and AI must not fail, I reach for Rust
June 2026

Where Rust fits in a data and AI stack: the deterministic, memory-safe substrate under probabilistic models and agents - and where Python is still the right call.

8 min read
Hero image for: Where the Agent Ends: Architecting the Deterministic Interface to LLM Agents Software Includes: video
Where the Agent Ends: Architecting the Deterministic Interface to LLM Agents
June 2026

Architecting reliable LLM agent systems requires a deterministic interface, treating agents as untrusted services. This post details building a robust harness with strict schemas and supervised contro

10 min read
Hero image for: The unglamorous truth about data quality Writing Includes: video
The unglamorous truth about data quality
May 2026

For enterprise architects, data quality is about defensibility, not perfection. Learn how to build systems that earn trust, with insights on lineage, contracts, observability, and why this is crucial

10 min read
Hero image for: Why agentic AI breaks in production (and the demos never show it) Writing Includes: video
Why agentic AI breaks in production (and the demos never show it)
May 2026

Juan Cardena discusses why LLM agents often fail in production, detailing hidden costs, latency spikes, and state management challenges. Learn how deterministic guardrails and hybrid architectures ens

10 min read
A data center aisle of server racks lit in deep blue with gold accent lighting Writing Includes: video
Why I built blog.jcardena.com
May 2026

A self-hosted, multi-language, LLM-managed blog at blog.jcardena.com. Built on Express + EJS + markdown. Same brand as jcardena.com. Cross-domain analytics. Launch notes inside.

2 min read
Hero image for: Every pixel matters: 25 years on, why frontend craft still earns trust AI Includes: ebook, video
Every pixel matters: 25 years on, why frontend craft still earns trust
April 2026

An enterprise architect's 25-year perspective on why frontend craft is a core architectural concern for modern AI, data, and agentic systems that earns user trust.

7 min read
Hero image for: The systems behind the systems: observability for a one-person platform Web Includes: video
The systems behind the systems: observability for a one-person platform
March 2026

Learn to build a calm, effective observability system for a one-person platform by focusing on SLOs over raw metrics and applying SRE principles to modern AI agents.

8 min read
Hero image for: Agentic AI in production: the failure modes and cost curves AI Includes: video
Agentic AI in production: the failure modes and cost curves
February 2026

Agentic AI looks powerful in demos, but its recursive loops create silent financial risks in production. Learn the key failure modes and architectural patterns to prevent them.

9 min read
Hero image for: What the data years taught me that I still use in agentic systems Data Includes: video
What the data years taught me that I still use in agentic systems
January 2026

Agentic systems fail like brittle distributed systems. Learn how to apply battle-tested data engineering patterns like idempotency and dead-letter queues to build reliable agents.

9 min read
Hero image for: Three lives in one year: day work, building, and learning AI Includes: video
Three lives in one year: day work, building, and learning
December 2025

A practitioner's guide to de-risking agentic AI for enterprise use: test deterministic outputs on an R&D platform, then turn theory into credible, production-ready architecture.

7 min read
Hero image for: Human-in-the-loop: AI systems people can actually trust AI
Human-in-the-loop: AI systems people can actually trust
November 2025

Explore why human-in-the-loop (HITL) is a critical, permanent architectural pattern for enterprise AI, not a temporary fix. Learn to build trustworthy systems.

8 min read
Hero image for: Running 30+ apps on one on-prem cluster: the ops reality Web Includes: video
Running 30+ apps on one on-prem cluster: the ops reality
October 2025

A 25-year enterprise architect on the operational reality of running a self-hosted AI development cluster, focusing on the architectural patterns that work.

7 min read
Hero image for: MLflow when you're a team of one AI Includes: video
MLflow when you're a team of one
September 2025

MLOps tools feel like overkill for one person, but MLflow provides a crucial, low-overhead discipline for solo model development, ensuring reproducibility and sanity.

7 min read
Hero image for: Enterprise RAG that survives an audit: chunking, citations, control AI
Enterprise RAG that survives an audit: chunking, citations, control
August 2025

Build enterprise RAG systems that withstand legal and compliance audits. Learn about structural chunking, immutable citations, and deterministic control planes.

7 min read
Hero image for: Lessons from building a multi-agent system over millions of records AI Includes: video
Lessons from building a multi-agent system over millions of records
July 2025

Scaling multi-agent systems from demos to production requires a shift from AI-driven chat to robust data engineering. Learn why queue-based worker patterns, externalized state, and deterministic DAGs

8 min read
Hero image for: What twelve focused weeks of study actually changed AI Includes: video
What twelve focused weeks of study actually changed
June 2025

A senior architect reflects on a 12-week deep dive into the modern AI stack, revealing a new model for system design: the deterministic core and the agentic edge.

8 min read
Hero image for: apps.jcardena.com: proof, not screenshots — a live reference platform Web
apps.jcardena.com: proof, not screenshots — a live reference platform
May 2025

Explore why a live reference platform is crucial for modern architects. Discover the trade-offs between local simulation and a live environment for testing AI and data systems.

8 min read
Hero image for: A capstone project that finally made the math click AI Includes: video
A capstone project that finally made the math click
April 2025

An enterprise architect's story of how a hands-on recommender project transformed abstract linear algebra into durable, intuitive knowledge for system architecture.

8 min read
Hero image for: Customer segmentation, from lecture notes to a working model Data
Customer segmentation, from lecture notes to a working model
March 2025

Bridge the gap between textbook customer segmentation theory and a durable production model. Learn how to architect the data pipelines and feature engineering.

8 min read
Hero image for: What cloud-cert exams teach — and what they completely miss AI Includes: video
What cloud-cert exams teach — and what they completely miss
February 2025

AI certifications provide a service catalog but miss the critical lessons of production: non-linear costs, cascading failures, and complex architectural trade-offs.

8 min read
Hero image for: Day one back in a classroom — what beginner's mind feels like at 45 AI
Day one back in a classroom — what beginner's mind feels like at 45
January 2025

Returning to the classroom at 45 to learn AI fundamentals shattered my expert intuition. I learned that the future of durable architecture is a hybrid model.

8 min read
Hero image for: Studying deep learning when you grew up on SQL AI Includes: video
Studying deep learning when you grew up on SQL
December 2024

An enterprise architect's guide to rewiring your brain from SQL's deterministic world to deep learning's probabilistic one for modern AI system design.

6 min read
Hero image for: Going back to school at 45 to learn AI AI
Going back to school at 45 to learn AI
November 2024

An enterprise architect's reflection on going back to school for AI at 45. It’s not about credentials, but about trading heuristics for first principles.

8 min read
Hero image for: The data skills that aged well — and the ones that didn't AI Includes: video
The data skills that aged well — and the ones that didn't
October 2024

A 25-year architect on the data skills that provide lasting value. Learn why principles like SQL and data modeling outlive specific tools and why a software discipline is key.

8 min read
Hero image for: Rebuilding my identity from 'data' to 'data and AI' AI Includes: video
Rebuilding my identity from 'data' to 'data and AI'
September 2024

An enterprise architect's journey from traditional data architecture to building modern systems where deterministic pipelines and agentic LLMs cooperate.

6 min read
Hero image for: Treating a job search like a data pipeline AI Includes: video
Treating a job search like a data pipeline
August 2024

Transform your job search from a chaotic process into a measurable system by applying data pipeline architecture, combining deterministic automation and AI agents.

7 min read
Hero image for: Docker to Kubernetes, explained for a data person Data
Docker to Kubernetes, explained for a data person
July 2024

A guide for data engineers and scientists moving from Docker to Kubernetes, explaining the core mental shifts around state, scheduling, and declarative architecture.

8 min read
Hero image for: Standing up a bare-metal Kubernetes cluster on-premises Web Includes: video
Standing up a bare-metal Kubernetes cluster on-premises
June 2024

I built a bare-metal Kubernetes cluster to understand the failure modes AI systems inherit from the cloud. A deep dive into MetalLB, BGP, and Longhorn.

9 min read
Hero image for: Why I still run on-prem infrastructure for AI R&D Web Includes: video
Why I still run on-prem infrastructure for AI R&D
May 2024

An on-prem R&D platform provides a consequence-free sandpit to stress-test real AI and data systems, explore failure modes, and build durable, hands-on knowledge.

8 min read
Hero image for: Building my first real multi-agent loop AI
Building my first real multi-agent loop
April 2024

Discover the key architectural pattern for building reliable multi-agent systems. Learn why a deterministic orchestrator and shared state beat AI managers.

8 min read
Hero image for: MCP and tool-use: first impressions from a systems person AI Includes: video
MCP and tool-use: first impressions from a systems person
March 2024

Learn the essential software architecture for LLM agents. We cover the Adapter pattern, separating planning from execution, and why treating the LLM like an untrusted user is key to production reliabi

6 min read
Hero image for: Learning agentic AI from scratch when you already know systems AI
Learning agentic AI from scratch when you already know systems
February 2024

Systems engineers already have the right mental models for agentic AI. Learn how principles of state machines, transaction logs, and idempotency from distributed systems directly apply to building rel

8 min read
Hero image for: Deciding to retrain at 44 — and why it didn't feel late AI
Deciding to retrain at 44 — and why it didn't feel late
January 2024

My experience retraining for AI at 44. It wasn't about learning a new field from scratch, but applying durable architectural patterns to a new, unreliable API.

7 min read
Hero image for: What I wish I'd learned about AI five years sooner AI Includes: video
What I wish I'd learned about AI five years sooner
December 2023

The most critical lesson for AI architecture isn't about the model, but the system around it. How to build reliable systems with non-deterministic components.

8 min read
Hero image for: RAG that survives a hard question AI Includes: video
RAG that survives a hard question
November 2023

Production-ready RAG isn't about retrieval; it's about managing failure. Learn the architecture for building robust RAG systems that survive hard questions.

8 min read
Hero image for: Why I decided to rebuild my skills from the foundation up AI Includes: video
Why I decided to rebuild my skills from the foundation up
October 2023

An enterprise architect's personal journey of rebuilding skills for the AI era. Learn why foundational knowledge in math and systems design is key to building durable.

8 min read
Hero image for: Evaluating LLM output like a data pipeline Software
Evaluating LLM output like a data pipeline
September 2023

Learn to evaluate LLM outputs with the discipline of data engineering. This post covers the architectural choice between constraining generation and post-hoc validation.

8 min read
Hero image for: The cost of context windows nobody warns you about Software Includes: video
The cost of context windows nobody warns you about
August 2023

Massive LLM context windows promise simplicity but come with high latency, spiraling costs, and poor recall. The better path is engineered architecture.

8 min read
Hero image for: The first agent I built that actually did something useful AI Includes: video
The first agent I built that actually did something useful
July 2023

The story of my first useful AI agent. It wasn't magic, but a deterministic state machine with LLM tools. A practical guide to agentic architecture.

7 min read
Hero image for: Governance before hype: my rule for adopting any new tool Software
Governance before hype: my rule for adopting any new tool
June 2023

My rule for adopting new data and AI tools: answer three governance questions on provenance, access, and retention before any hype-driven PoC. A lesson from production reality.

8 min read
Hero image for: Embeddings vs the BI mindset: unlearning what I knew AI
Embeddings vs the BI mindset: unlearning what I knew
May 2023

An enterprise architect's journey from the deterministic world of BI and star schemas to the probabilistic power of vector embeddings for modern AI systems.

7 min read
Hero image for: When to use an LLM, and when to just write the query Software Includes: video
When to use an LLM, and when to just write the query
April 2023

LLMs are intent engines, not query engines. For production data systems, use an LLM as a smart router to trigger deterministic code, not to write raw SQL.

8 min read
Hero image for: Prompt engineering for a SQL brain AI Includes: video
Prompt engineering for a SQL brain
March 2023

A guide for engineers moving from deterministic SQL to probabilistic LLMs. Learn to map your existing mental models and build a reliable agentic architecture.

8 min read
Hero image for: Why a solid data foundation made AI adoption easy for me Data Includes: video
Why a solid data foundation made AI adoption easy for me
February 2023

Adopting AI was surprisingly calm for me. This wasn't because of a new model, but because of old-school data engineering: contracts, lineage, and observability.

8 min read
Hero image for: My first real RAG prototype, at 44, after 20 years in data AI Includes: video
My first real RAG prototype, at 44, after 20 years in data
January 2023

Building a production-ready RAG system at 44 taught me that success isn't in the LLM, but in the data pipeline. A practitioner's guide to robust AI architecture.

8 min read
Hero image for: A decade in data: what millions of records taught me about people AI
A decade in data: what millions of records taught me about people
December 2022

A decade of experience with large-scale data systems shows how to architect for reality: blend deterministic automation with agentic AI and treat fairness as a core feature.

9 min read
Hero image for: ChatGPT just launched — why my data foundation means I'm calm AI
ChatGPT just launched — why my data foundation means I'm calm
November 2022

When a new LLM like ChatGPT launches, the frantic scramble to build demos creates technical debt. A calm, ready response comes from a robust data foundation.

7 min read
Hero image for: The night a region went dark: a disaster-recovery story Software Includes: video
The night a region went dark: a disaster-recovery story
October 2022

A first-person disaster recovery story about a full cloud region failure. It explores how plans fail under human pressure and technical debt like config drift.

8 min read
Hero image for: Dashboards people trust: less chart-junk, more decisions Data
Dashboards people trust: less chart-junk, more decisions
September 2022

Dashboards built on weak foundations create expensive noise, a critical liability for AI. Learn the architecture for trust: data contracts and a semantic layer.

8 min read
Hero image for: Vector databases, first contact AI Includes: video
Vector databases, first contact
August 2022

A practitioner's first look at vector databases. They are a new architectural primitive for semantic search, but the real challenge isn't storage—it's the embedding model dependency.

8 min read
Hero image for: What 'maintenance' actually buys you Software Includes: video
What 'maintenance' actually buys you
July 2022

Explore why proactive system maintenance is not a cost center but a crucial investment that preserves future velocity and resilience in modern AI and data architectures.

8 min read
Hero image for: The cost of skipping the boring work: a confession AI Includes: video
The cost of skipping the boring work: a confession
June 2022

A personal confession about skipping foundational data engineering work and the catastrophic, silent failure it caused. The lesson: the boring work is the bedrock of any reliable data or AI system.

7 min read
Hero image for: Clean architecture inside a codebase older than my teammates Software
Clean architecture inside a codebase older than my teammates
May 2022

Learn how to apply Clean Architecture and an internal Strangler Fig pattern to legacy codebases, creating the stable, deterministic foundation required for modern AI.

8 min read
Hero image for: Building systems in a language I couldn't read AI
Building systems in a language I couldn't read
April 2022

How to manage opaque systems, from legacy code to AI agents. Use a deterministic harness, a variant of the Strangler Fig pattern, to de-risk and modernize.

8 min read
Hero image for: Event-driven pipelines before they were fashionable Data
Event-driven pipelines before they were fashionable
March 2022

Exploring the foundational principles of event-driven architecture, born from necessity. How this durable pattern of decoupling is essential for modern data and AI systems.

8 min read
Hero image for: Working across countries: what cross-border data really demands Data Includes: video
Working across countries: what cross-border data really demands
February 2022

How to build global agentic AI systems that comply with data sovereignty laws. Explore architecture patterns like regional pods and federated orchestration.

8 min read
Hero image for: Where it began: why 99.9% uptime is a promise, not a metric Software Includes: video
Where it began: why 99.9% uptime is a promise, not a metric
January 2022

Uptime percentages like 99.9% are a dangerous vanity metric. Learn why true system reliability, especially in AI, comes from measuring user success, not server pings.

8 min read
Hero image for: What unifying millions of records taught me about trust AI Includes: video
What unifying millions of records taught me about trust
December 2021

Unifying millions of records reveals a hard truth: data problems are trust problems. Learn how data contracts create the reliable foundation for AI agents.

8 min read
Hero image for: Putting one clean API in front of a decade of legacy Software Includes: video
Putting one clean API in front of a decade of legacy
November 2021

Learn to tame legacy systems with an API Facade and the Strangler Fig pattern. This is a pragmatic, incremental approach to modernization that works in production.

7 min read
Hero image for: Master data when everything keeps changing underneath you Data Includes: video
Master data when everything keeps changing underneath you
October 2021

Discover a resilient MDM architecture that thrives on change. Learn to decouple ingestion, use a flexible core/sidecar model, and run reconciliation continuously.

8 min read
Hero image for: Real-time vs nightly: choosing latency honestly Data Includes: video
Real-time vs nightly: choosing latency honestly
September 2021

Choosing between real-time and nightly batch processing is a critical architectural decision. Learn to cut through the hype and focus on business value to avoid the complexity tax.

7 min read
Hero image for: Designing adapters that outlive the vendors behind them Software
Designing adapters that outlive the vendors behind them
August 2021

Stop coupling your core logic to specific LLM or vector DB vendors. Learn to build a proper Adapter Pattern, or Anti-Corruption Layer, for AI systems.

8 min read
Hero image for: SQL patterns I still trust after hundreds of databases Data Includes: video
SQL patterns I still trust after hundreds of databases
July 2021

Discover the durable SQL patterns—CTEs, window functions, idempotency keys, event sourcing—that are more critical than ever for building reliable AI agent systems and data architectures.

8 min read
Hero image for: Leading work across eight time zones, before remote was normal AI
Leading work across eight time zones, before remote was normal
June 2021

Discover how 2008-era principles for managing distributed teams across time zones provide the perfect architectural model for modern agentic AI systems today.

7 min read
Hero image for: Templating a data onboarding so it's repeatable, not heroic Data Includes: video
Templating a data onboarding so it's repeatable, not heroic
May 2021

Stop artisanal data onboarding. Learn to use declarative templates and automation to create repeatable, self-documenting, and reliable data integration pipelines.

8 min read
Hero image for: How I build a dashboard executives actually open AI
How I build a dashboard executives actually open
April 2021

A 25-year enterprise architect's method for building dashboards that executives and AI agents actually use, focusing on decisions, MVP pipelines, and real value.

8 min read
Hero image for: Replicating a legacy system at scale: the integration nobody blogs about Software Includes: video
Replicating a legacy system at scale: the integration nobody blogs about
March 2021

Discover the unglamorous but vital process for replacing legacy systems. This guide covers the comparator pattern, its trade-offs with Strangler Fig, and why a stable core is essential for AI.

8 min read
Hero image for: Identity resolution across millions of records — what it really costs Data
Identity resolution across millions of records — what it really costs
February 2021

A practitioner's guide to the real costs of identity resolution. We explore the economics of brute-force matching, deterministic pipelines vs. vector embeddings, and why human review is inevitable.

8 min read
Hero image for: The data-pipeline playbook I rebuild for every new project Data Includes: video
The data-pipeline playbook I rebuild for every new project
January 2021

A veteran architect's playbook for building data pipelines that last. Learn why declarative, idempotent principles are the essential foundation for modern AI systems.

7 min read
Hero image for: The migration that moved millions of rows without losing one Software Includes: video
The migration that moved millions of rows without losing one
December 2014

Learn the architecture behind a zero-downtime, zero-loss database migration. This practitioner's guide covers dual writes, checksum validation, and gradual rollouts.

8 min read
Hero image for: Why I started treating data like a product Software Includes: video
Why I started treating data like a product
November 2014

Learn why treating data as a product, not operational exhaust, is critical for modern AI and automation. I cover the architectural and organizational shifts required.

8 min read
Hero image for: Learning to model data for questions nobody had asked yet Data Includes: video
Learning to model data for questions nobody had asked yet
October 2014

Discover why the classic star schema, a dimensional modeling pattern, is more critical than ever for preparing data to answer future business questions and feed AI.

7 min read
Hero image for: The day data quality became my whole job Data Includes: video
The day data quality became my whole job
September 2014

A personal story of a silent data failure that reshaped my view on architecture. From a simple ETL plumber to a guardian of data integrity, and why this matters more than ever for AI.

8 min read
Hero image for: Master data management, explained by my own mistakes Data Includes: video
Master data management, explained by my own mistakes
August 2014

A personal story of building a Master Data Management (MDM) hub after a disastrous meeting. Learn the real-world architecture and trade-offs of this essential system.

6 min read
Hero image for: The ETL job that ran for six hours and I had to make it twenty minutes Data Includes: video
The ETL job that ran for six hours and I had to make it twenty minutes
July 2014

An enterprise architect's breakdown of a real-world performance disaster. How a six-hour ETL job was cut to 20 minutes by replacing anti-patterns with durable principles.

7 min read
Hero image for: Building a warehouse before I knew what a warehouse was Data
Building a warehouse before I knew what a warehouse was
June 2014

A 25-year enterprise architect's honest retrospective on building an accidental data warehouse and the production failures that forced a move to intentional design.

7 min read
Hero image for: Identity resolution: the problem that humbled me Data
Identity resolution: the problem that humbled me
May 2014

Identity resolution is one of the hardest problems in data architecture. A practitioner's guide to moving from deterministic rules to probabilistic systems.

8 min read
Hero image for: When a single wrong number cost a meeting its trust Data Includes: video
When a single wrong number cost a meeting its trust
April 2014

A real-world story of a silent data pipeline failure and how it underscores the need for verifiable data contracts and assertions in the age of LLM agents.

8 min read
Hero image for: The first dashboard an executive actually opened twice Data Includes: video
The first dashboard an executive actually opened twice
March 2014

Most dashboards fail because they offer a sea of data instead of a single, clear answer. Learn the architectural shift from a slow data explorer to a fast, deterministic pipeline that actually gets us

7 min read
Hero image for: Learning SQL properly, after years of faking it Software
Learning SQL properly, after years of faking it
February 2014

A senior architect's reflection on learning SQL the right way after years of faking it. Discover why a declarative model is critical for modern data and AI work.

9 min read
Hero image for: My first real data pipeline, held together with hope and cron Data Includes: video
My first real data pipeline, held together with hope and cron
January 2014

A 25-year architect's story of a first data pipeline built on cron and hope. It covers the silent failures that followed and the hard-won, non-negotiable lessons.

8 min read
Hero image for: The year I stopped writing apps and started moving data Software Includes: video
The year I stopped writing apps and started moving data
December 2013

A career pivot from writing applications to moving data, showing how deterministic pipelines are the essential, unglamorous bedrock for modern agentic AI systems.

8 min read
Hero image for: Why every AI thing I do now rests on these years AI Includes: video
Why every AI thing I do now rests on these years
November 2013

Production AI systems depend on more than the model. They require a foundation of deterministic data engineering—the patterns that ensure reliability and prevent costly failures.

9 min read
Hero image for: The first time I unified data from systems that disagreed Data Includes: video
The first time I unified data from systems that disagreed
October 2013

Instead of forcing conflicting system data into one 'golden record', build a contextual model. A deterministic router serving data by purpose is safer and more honest.

7 min read
Hero image for: Indexing, partitioning, and the patience data teaches Data
Indexing, partitioning, and the patience data teaches
September 2013

Learn why modern AI and RAG pipelines fail. It's not the LLM; it's the underlying data architecture. A practitioner's guide to indexing and partitioning.

7 min read
Hero image for: The pipeline I rebuilt three times before it was right Data Includes: video
The pipeline I rebuilt three times before it was right
August 2013

A personal story of rebuilding a data pipeline three times, from a brittle monolith to an overly complex microservices architecture, to a pragmatic hybrid.

7 min read
Hero image for: Learning to say 'I don't know yet' to a number I couldn't defend Software Includes: video
Learning to say 'I don't know yet' to a number I couldn't defend
July 2013

An enterprise architect's take on why refusing to give a premature number is crucial for engineering integrity and the foundation of building modern data and AI systems.

8 min read
Hero image for: The data contract that ended a long-running argument Software Includes: video
The data contract that ended a long-running argument
June 2013

How a machine-readable data contract, enforced in CI, ended the chronic conflict between data producers and consumers by shifting accountability upstream.

8 min read
Hero image for: Building trust in numbers, one reconciliation at a time Data
Building trust in numbers, one reconciliation at a time
May 2013

Explore why automated, deterministic reconciliation is the bedrock of trust in any data system, from classic data warehouses to modern LLM-powered agentic systems.

8 min read
Hero image for: When I learned that the boring foundation is the whole game Software Includes: video
When I learned that the boring foundation is the whole game
April 2013

Building reliable AI systems isn't about the latest agentic model; it's about the boringly reliable foundation that gives it leverage. A look at why data contracts and idempotency matter more than eve

8 min read
Hero image for: Slowly changing dimensions and the slowly changing me Data Includes: video
Slowly changing dimensions and the slowly changing me
March 2013

A classic data warehousing pattern, the Slowly Changing Dimension, holds surprising lessons for modern AI/data architecture and for a career built on evolution.

8 min read
Hero image for: The report that changed how a business made a decision Software Includes: video
The report that changed how a business made a decision
February 2013

How a single, well-architected report built on a deterministic data pipeline overturned a gut-feel business strategy and revealed the real cause of customer churn.

8 min read
Hero image for: Real-time vs batch: choosing latency with intention Data Includes: video
Real-time vs batch: choosing latency with intention
January 2013

A practitioner's guide to choosing between real-time and batch processing in modern AI and data architectures. Learn when to pay the latency tax and how to compose them.

7 min read
Hero image for: Building my first API that another team depended on Software
Building my first API that another team depended on
December 2008

A lesson from a first-generation microservice API about contracts and versioning, and why those same principles are non-negotiable for building reliable LLM agents.

7 min read
Hero image for: The day I learned what technical debt actually costs Web Includes: video
The day I learned what technical debt actually costs
November 2008

A first-person account of how legacy technical debt surfaces in modern data and AI architecture, causing model failures, blocking MLOps, and costing more than just time.

8 min read
Hero image for: Refactoring a module I was scared to touch Web Includes: video
Refactoring a module I was scared to touch
October 2008

How to safely refactor a legacy module. A case study on using characterization tests to make a deterministic pipeline reliable enough for a modern AI agent.

8 min read
Hero image for: When the database became the most important part of the app Data Includes: video
When the database became the most important part of the app
September 2008

Application code is transient, but data is permanent. Learn why shifting to a data-centric architecture is the key to building durable, reliable systems for AI.

9 min read
Hero image for: The first system I designed that outlived its original purpose Software Includes: video
The first system I designed that outlived its original purpose
August 2008

Discover the architectural pattern that allowed a data integration system to outlive its purpose and how it applies to building reliable AI agentic systems today.

9 min read
Hero image for: Learning to read someone else's code without judgment Web Includes: video
Learning to read someone else's code without judgment
July 2008

To build reliable AI agents, we must first learn to read legacy code without judgment. This is how to become a technical archaeologist for modern systems.

8 min read
Hero image for: The release that taught me to fear Fridays Web Includes: video
The release that taught me to fear Fridays
June 2008

A personal story of a weekend-long outage caused by a 'simple' Friday deployment. It reveals hard-won architectural rules for managing stateful changes.

7 min read
Hero image for: Discovering that naming things is genuinely the hard part Web
Discovering that naming things is genuinely the hard part
May 2008

Discover why naming is a crucial architectural act, not a soft skill. Learn how ambiguous names create technical debt in systems where AI agents and data pipelines cooperate.

7 min read
Hero image for: My first production bug at 3am, and what it taught me Web Includes: video
My first production bug at 3am, and what it taught me
April 2008

A 3am production bug in a deterministic batch job taught me foundational lessons in defensive design and observability that are now critical for building agentic AI.

8 min read
Hero image for: Why I started writing things down before writing code Web Includes: video
Why I started writing things down before writing code
March 2008

Writing things down before writing code isn't bureaucracy; it's a critical design step to force clarity, especially when building hybrid AI and data systems.

8 min read
Hero image for: Learning version control the hard way (after losing a week of work) Web Includes: video
Learning version control the hard way (after losing a week of work)
February 2008

A hard-won lesson on version control after losing a week of work. Basic Git is not enough for today's AI and data stacks. An architect's take on DVC, Git LFS, and why process is architecture.

8 min read
Hero image for: The first time I had to think about architecture, not just code Software Includes: video
The first time I had to think about architecture, not just code
January 2008

My first experience with architecture wasn't about theory; it was a painful refactor of fragile CGI scripts. That lesson—defining contracts to isolate components—is the key to building durable systems

8 min read
Hero image for: Moving from pages to programs: my first real application Software Includes: video
Moving from pages to programs: my first real application
December 2007

Discover how the foundational lessons from building a first simple web application in PHP/MySQL directly apply to the architectural challenges of modern data and AI systems.

8 min read
Hero image for: Learning that simple beats clever almost every time Web
Learning that simple beats clever almost every time
November 2007

Learn why simple architectural patterns beat clever ones for long-term durability, especially in data and AI systems. A practitioner's guide to avoiding complexity.

7 min read
Hero image for: The deploy script that saved my weekends Web Includes: video
The deploy script that saved my weekends
October 2007

Explore how foundational principles of deterministic deployment automation, from simple scripts to GitOps, are critical for managing modern hybrid AI and data systems.

7 min read
Hero image for: Designing for failure before failure found me Software
Designing for failure before failure found me
September 2007

Explore how classic software resilience patterns like circuit breakers and exponential backoff are essential for building robust AI and data systems. Learn to manage them.

9 min read
Hero image for: The legacy system I inherited and slowly came to respect Web Includes: video
The legacy system I inherited and slowly came to respect
August 2007

Juan Cardena reflects on inheriting a legacy batch system. Its surprising resilience taught a crucial lesson about durable architecture and Chesterton's Fence.

7 min read
Hero image for: When I realized tests were a gift to my future self Web Includes: video
When I realized tests were a gift to my future self
July 2007

I once saw tests as a tax. A production failure in a data-to-AI pipeline taught me they're a gift. Classic testing patterns are our best tool for managing modern agentic systems.

7 min read
Hero image for: Caching: the second hardest problem, and I learned it the hard way Software
Caching: the second hardest problem, and I learned it the hard way
June 2007

Caching is more than a performance win; it's a commitment to managing distributed state. I learned the hard way about invalidation, stale data, and race conditions.

8 min read
Hero image for: The architecture diagram that finally made the team agree Software Includes: video
The architecture diagram that finally made the team agree
May 2007

When software, data, and AI teams clash, the right architecture diagram focuses on social contracts, not technical details, to create true alignment.

8 min read
Hero image for: My first on-call rotation and the humility it brought Web Includes: video
My first on-call rotation and the humility it brought
April 2007

My first on-call rotation, a 3 AM outage, and the cascade failure that taught me humility is a core technical skill in systems architecture.

7 min read
Hero image for: Learning to say no to a feature that would break the foundation Software Includes: video
Learning to say no to a feature that would break the foundation
March 2007

Protecting your system's deterministic core isn't just about avoiding technical debt; it's the prerequisite for building reliable AI and agentic systems.

8 min read
Hero image for: The integration that connected two systems that hated each other Data Includes: video
The integration that connected two systems that hated each other
February 2007

How to build a resilient integration between two incompatible systems using an Anti-Corruption Layer, avoiding the brittle point-to-point script trap.

8 min read
Hero image for: Why I stopped optimizing things that didn't matter Web Includes: video
Why I stopped optimizing things that didn't matter
January 2007

A hard lesson in system performance: optimizing a component in isolation is a trap. Why I learned to ignore micro-optimizations and focus on the entire request path.

7 min read
Hero image for: My first taste of server-side code Software Includes: video
My first taste of server-side code
December 2004

A look back at a first Perl/CGI script reveals the durable architectural patterns that underpin modern software and sets up today's core challenge.

8 min read
Hero image for: Learning that the user never reads the manual Web Includes: video
Learning that the user never reads the manual
November 2004

Architects must accept that users ignore manuals. The solution is a hybrid system where LLM agents handle ambiguous input and deterministic pipelines ensure reliability.

7 min read
Hero image for: CSS arrived and changed how I thought about everything Software
CSS arrived and changed how I thought about everything
October 2004

Explore the enduring lesson of CSS: separating concerns. Learn how this principle applies to modern data pipelines and LLM agent architectures for building robust, adaptable systems.

8 min read
Hero image for: The first form I built that emailed me when someone submitted it Data Includes: video
The first form I built that emailed me when someone submitted it
September 2004

Juan Cardena reflects on his first form that sent an email, tying its deterministic automation to modern data and AI architectures, contrasting simple web processes with agentic systems.

8 min read
Hero image for: FTP, by hand, at 2am — the original deploy pipeline Web
FTP, by hand, at 2am — the original deploy pipeline
August 2004

The lessons from early, manual FTP deployments—atomicity, determinism, and state management—are the foundation for building reliable modern systems with LLM agents.

8 min read
Hero image for: Cross-browser hell: when the same code looked different everywhere Software
Cross-browser hell: when the same code looked different everywhere
July 2004

LLM inconsistencies echo early web's 'cross-browser hell.' Learn architectural lessons for building robust, reliable agentic systems through defensive design and observability.

9 min read
Hero image for: The night I learned what a 500 error really means Software Includes: video
The night I learned what a 500 error really means
June 2004

A career-defining production outage reveals that a 500 error is a failure of observability, a lesson more critical than ever in the age of agentic AI.

8 min read
Hero image for: My first encounter with a real web server Software Includes: video
My first encounter with a real web server
May 2004

An enterprise architect's journey from static web pages to dynamic web servers, revealing foundational client-server principles crucial for modern data, AI, and agentic system architecture.

9 min read
Hero image for: Dial-up taught me to respect every kilobyte Web
Dial-up taught me to respect every kilobyte
April 2004

An enterprise architect reflects on how dial-up internet taught fundamental lessons in data efficiency that are critical for modern AI, data, and software architecture. Learn how bloated payloads impa

9 min read
Hero image for: Why I fell in love with the View Source button Web Includes: video
Why I fell in love with the View Source button
March 2004

Juan Cardena reflects on the 'View Source' button's legacy in teaching deterministic architecture and contrasts it with the challenges of building reliable systems with opaque LLM agents. Explore patt

8 min read
Hero image for: Tables for layout, and other sins I committed in 2003 Software Includes: video
Tables for layout, and other sins I committed in 2003
February 2004

Juan Cardena critiques the architectural sin of fusing content structure with presentation. From 2003 HTML table layouts to modern AI systems, he advocates for ruthless separation of concerns for dura

9 min read
Hero image for: The first website I shipped that someone actually used Web Includes: video
The first website I shipped that someone actually used
January 2004

Juan Cardena recounts his first production system: a cron-driven HTML page for a courier service. This early experience forged his belief in deterministic automation's reliability and the profound hum

6 min read
Hero image for: Learning HTML by breaking things, one page at a time Web
Learning HTML by breaking things, one page at a time
December 2003

Exploring how the 90s practice of breaking HTML provides a mental model for architecting modern AI systems with agentic and deterministic components.

8 min read
Hero image for: My first real lesson in graceful degradation Software Includes: video
My first real lesson in graceful degradation
November 2003

A personal story about an early-career system failure that taught the critical lesson of graceful degradation, now applied to building resilient AI agentic systems.

6 min read
Hero image for: The discipline of building for a 56k connection Software Includes: video
The discipline of building for a 56k connection
October 2003

The discipline of building for a 56k connection is a powerful mental model for modern systems architecture, from lean APIs to cost-effective LLM agents.

7 min read
Hero image for: Image maps, rollovers, and the craft of the early web Web
Image maps, rollovers, and the craft of the early web
September 2003

A look back at client-side image maps and rollovers reveals lessons in system fragility that apply directly to building modern AI and data architectures today.

7 min read
Hero image for: Hand-coding navigation menus before frameworks existed Web
Hand-coding navigation menus before frameworks existed
August 2003

Explore the evolution of navigation menus from manual HTML edits to SSIs, drawing parallels to modern deterministic automation vs. LLM agents in architecture.

8 min read
Hero image for: The first time a stranger emailed to say my site helped them Web Includes: video
The first time a stranger emailed to say my site helped them
July 2003

Juan Cardena discusses a real-world problem of fragile state management between LLM agents and deterministic pipelines, and how a classic event-log pattern provided a resilient solution, emphasizing d

8 min read
Hero image for: When 'it works on my machine' stopped being an excuse Software Includes: video
When 'it works on my machine' stopped being an excuse
June 2003

The journey from 'it works on my machine' to reproducible, containerized systems. Why codifying the entire environment is non-negotiable for modern AI and data.

8 min read
Hero image for: Learning to read a log file like a detective Data Includes: video
Learning to read a log file like a detective
May 2003

Dashboards fail and abstractions leak. The timeless skill of reading a raw log file is critical for debugging modern software, data, and AI agentic systems.

7 min read
Hero image for: The art of the progress bar before AJAX existed Web Includes: video
The art of the progress bar before AJAX existed
April 2003

Explore how we managed long-running server tasks pre-AJAX with HTTP redirects and meta-refresh for responsive UIs. This historical web architecture pattern of decoupling work and providing status feed

9 min read
Hero image for: Why uptime became personal the first time a site went down Software Includes: video
Why uptime became personal the first time a site went down
March 2003

A personal story about a first production outage and how it shaped a philosophy of architecture for modern data and AI systems, where trust is the key metric.

8 min read
Hero image for: Shipping a site for a small business and watching it go live Web Includes: video
Shipping a site for a small business and watching it go live
February 2003

Lessons from building a small business website apply directly to AI architecture. How direct feedback loops and deterministic foundations are key to reliable systems.

8 min read
Hero image for: The bug that only happened on the client's machine Web Includes: video
The bug that only happened on the client's machine
January 2003

An old browser bug story reveals a core principle for building reliable AI agent systems: you must choose between constraining the environment or observing it directly.

8 min read