# Juan Cardena · Blog

> Enterprise architect writing on agentic AI, MLOps, and the systems behind them. 25 years across web, software, data, AI.

Author: Juan Cardena (https://jcardena.com) — Enterprise Architect, Data & AI

## Posts (English)
- [We fear the curse of dimensionality. In 1965, Cover proved it's the whole trick.](https://blog.jcardena.com/en/cover-1965-the-dark-geometry-that-makes-ai-work/): 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.
- [What 25 years across web, software, data, and AI taught me about durability](https://blog.jcardena.com/en/what-25-years-across-web-software-data-and-ai-taught-me-abou/): Juan Cardena reflects on 25 years across web, software, data, and AI, sharing architectural principles that ensure durability amidst technological shifts.
- [We credit the Transformer. The blueprint was already drawn in 2013 — on handwriting.](https://blog.jcardena.com/en/before-the-transformer-the-2013-handwriting-paper/): 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.
- [The Latency and Cost of Agentic Ambition: Productionizing LLM Workflows](https://blog.jcardena.com/en/the-latency-and-cost-of-agentic-ambition-productionizing-llm/): Productionizing LLM agentic workflows demands architecting for cost and latency. Learn how semantic caching, deterministic controls, and observability build durable, cost-effective systems.
- [When data and AI must not fail, I reach for Rust](https://blog.jcardena.com/en/when-data-and-ai-must-not-fail-i-reach-for-rust/): 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.
- [Where the Agent Ends: Architecting the Deterministic Interface to LLM Agents](https://blog.jcardena.com/en/where-the-agent-ends-architecting-the-deterministic-interfac/): 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
- [The unglamorous truth about data quality](https://blog.jcardena.com/en/the-unglamorous-truth-about-data-quality/): 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 
- [Why agentic AI breaks in production (and the demos never show it)](https://blog.jcardena.com/en/why-agentic-ai-breaks-in-production-and-the-demos-never-show/): 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
- [Why I built blog.jcardena.com](https://blog.jcardena.com/en/welcome-to-blog/): 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.
- [Every pixel matters: 25 years on, why frontend craft still earns trust](https://blog.jcardena.com/en/every-pixel-matters-25-years-on-why-frontend-craft-still-ear/): 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.
- [The systems behind the systems: observability for a one-person platform](https://blog.jcardena.com/en/the-systems-behind-the-systems-observability-for-a-one-perso/): 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.
- [Agentic AI in production: the failure modes and cost curves](https://blog.jcardena.com/en/agentic-ai-in-production-the-failure-modes-and-cost-curves/): 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.
- [What the data years taught me that I still use in agentic systems](https://blog.jcardena.com/en/what-the-data-years-taught-me-that-i-still-use-in-agentic-sy/): 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.
- [Three lives in one year: day work, building, and learning](https://blog.jcardena.com/en/three-lives-in-one-year-day-work-building-and-learning/): A practitioner's guide to de-risking agentic AI for enterprise use. How to use a personal lab to test concepts like deterministic outputs and turn theory into credible, production-ready architectural 
- [Human-in-the-loop: AI systems people can actually trust](https://blog.jcardena.com/en/human-in-the-loop-ai-systems-people-can-actually-trust/): 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.
- [Running 30+ apps on one home cluster: the ops reality](https://blog.jcardena.com/en/running-30-apps-on-one-home-cluster-the-ops-reality/): A 25-year enterprise architect on the operational reality of running a self-hosted AI development cluster, focusing on the architectural patterns that work.
- [MLflow when you're a team of one](https://blog.jcardena.com/en/mlflow-when-youre-a-team-of-one/): MLOps tools feel like overkill for one person, but MLflow provides a crucial, low-overhead discipline for solo model development, ensuring reproducibility and sanity.
- [Enterprise RAG that survives an audit: chunking, citations, control](https://blog.jcardena.com/en/enterprise-rag-that-survives-an-audit-chunking-citations-con/): Build enterprise RAG systems that withstand legal and compliance audits. Learn about structural chunking, immutable citations, and deterministic control planes.
- [Lessons from building a multi-agent system over millions of records](https://blog.jcardena.com/en/lessons-from-building-a-multi-agent-system-over-millions-of-/): 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 
- [What twelve focused weeks of study actually changed](https://blog.jcardena.com/en/what-twelve-focused-weeks-of-study-actually-changed/): 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.
- [apps.jcardena.com: proof, not screenshots — my personal Live Lab](https://blog.jcardena.com/en/appsjcardenacom-proof-not-screenshots-my-personal-live-lab/): Explore why a personal live lab is crucial for modern architects. Discover the trade-offs between local simulation and a live environment for testing AI and data systems.
- [A capstone project that finally made the math click](https://blog.jcardena.com/en/a-capstone-project-that-finally-made-the-math-click/): An enterprise architect's story of how a hands-on recommender project transformed abstract linear algebra into durable, intuitive knowledge for system architecture.
- [Customer segmentation, from lecture notes to a working model](https://blog.jcardena.com/en/customer-segmentation-from-lecture-notes-to-a-working-model/): Bridge the gap between textbook customer segmentation theory and a durable production model. Learn how to architect the data pipelines and feature engineering.
- [What cloud-cert exams teach — and what they completely miss](https://blog.jcardena.com/en/what-cloud-cert-exams-teach-and-what-they-completely-miss/): AI certifications provide a service catalog but miss the critical lessons of production: non-linear costs, cascading failures, and complex architectural trade-offs.
- [Day one back in a classroom — what beginner's mind feels like at 45](https://blog.jcardena.com/en/day-one-back-in-a-classroom-what-beginners-mind-feels-like-a/): 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.
- [Studying deep learning when you grew up on SQL](https://blog.jcardena.com/en/studying-deep-learning-when-you-grew-up-on-sql/): 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.
- [Going back to school at 45 to learn AI](https://blog.jcardena.com/en/going-back-to-school-at-45-to-learn-ai/): 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.
- [The data skills that aged well — and the ones that didn't](https://blog.jcardena.com/en/the-data-skills-that-aged-well-and-the-ones-that-didnt/): 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.
- [Rebuilding my identity from 'data' to 'data and AI'](https://blog.jcardena.com/en/rebuilding-my-identity-from-data-to-data-and-ai/): An enterprise architect's journey from traditional data architecture to building modern systems where deterministic pipelines and agentic LLMs cooperate.
- [Treating a job search like a data pipeline](https://blog.jcardena.com/en/treating-a-job-search-like-a-data-pipeline/): Transform your job search from a chaotic process into a measurable system by applying data pipeline architecture, combining deterministic automation and AI agents.
- [Docker to Kubernetes, explained for a data person](https://blog.jcardena.com/en/docker-to-kubernetes-explained-for-a-data-person/): A guide for data engineers and scientists moving from Docker to Kubernetes, explaining the core mental shifts around state, scheduling, and declarative architecture.
- [Standing up a bare-metal Kubernetes cluster in my house](https://blog.jcardena.com/en/standing-up-a-bare-metal-kubernetes-cluster-in-my-house/): 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.
- [Why I run my own infrastructure at home](https://blog.jcardena.com/en/why-i-run-my-own-infrastructure-at-home/): A home lab provides a consequence-free sandpit to stress-test real AI and data systems, explore failure modes, and build durable, hands-on knowledge.
- [Building my first real multi-agent loop](https://blog.jcardena.com/en/building-my-first-real-multi-agent-loop/): Discover the key architectural pattern for building reliable multi-agent systems. Learn why a deterministic orchestrator and shared state beat AI managers.
- [MCP and tool-use: first impressions from a systems person](https://blog.jcardena.com/en/mcp-and-tool-use-first-impressions-from-a-systems-person/): 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
- [Learning agentic AI from scratch when you already know systems](https://blog.jcardena.com/en/learning-agentic-ai-from-scratch-when-you-already-know-syste/): 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
- [Deciding to retrain at 44 — and why it didn't feel late](https://blog.jcardena.com/en/deciding-to-retrain-at-44-and-why-it-didnt-feel-late/): 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.
- [What I wish I'd learned about AI five years sooner](https://blog.jcardena.com/en/what-i-wish-id-learned-about-ai-five-years-sooner/): 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.
- [RAG that survives a hard question](https://blog.jcardena.com/en/rag-that-survives-a-hard-question/): Production-ready RAG isn't about retrieval; it's about managing failure. Learn the architecture for building robust RAG systems that survive hard questions.
- [Why I decided to rebuild my skills from the foundation up](https://blog.jcardena.com/en/why-i-decided-to-rebuild-my-skills-from-the-foundation-up/): 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.
- [Evaluating LLM output like a data pipeline](https://blog.jcardena.com/en/evaluating-llm-output-like-a-data-pipeline/): Learn to evaluate LLM outputs with the discipline of data engineering. This post covers the architectural choice between constraining generation and post-hoc validation.
- [The cost of context windows nobody warns you about](https://blog.jcardena.com/en/the-cost-of-context-windows-nobody-warns-you-about/): Massive LLM context windows promise simplicity but come with high latency, spiraling costs, and poor recall. The better path is engineered architecture.
- [The first agent I built that actually did something useful](https://blog.jcardena.com/en/the-first-agent-i-built-that-actually-did-something-useful/): 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.
- [Governance before hype: my rule for adopting any new tool](https://blog.jcardena.com/en/governance-before-hype-my-rule-for-adopting-any-new-tool/): 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.
- [Embeddings vs the BI mindset: unlearning what I knew](https://blog.jcardena.com/en/embeddings-vs-the-bi-mindset-unlearning-what-i-knew/): 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.
- [When to use an LLM, and when to just write the query](https://blog.jcardena.com/en/when-to-use-an-llm-and-when-to-just-write-the-query/): 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.
- [Prompt engineering for a SQL brain](https://blog.jcardena.com/en/prompt-engineering-for-a-sql-brain/): A guide for engineers moving from deterministic SQL to probabilistic LLMs. Learn to map your existing mental models and build a reliable agentic architecture.
- [Why a solid data foundation made AI adoption easy for me](https://blog.jcardena.com/en/why-a-solid-data-foundation-made-ai-adoption-easy-for-me/): 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.
- [My first real RAG prototype, at 44, after 20 years in data](https://blog.jcardena.com/en/my-first-real-rag-prototype-at-44-after-20-years-in-data/): 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.
- [A decade in data: what millions of records taught me about people](https://blog.jcardena.com/en/a-decade-in-data-what-millions-of-records-taught-me-about-pe/): 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.
- [ChatGPT just launched — why my data foundation means I'm calm](https://blog.jcardena.com/en/chatgpt-just-launched-why-my-data-foundation-means-im-calm/): 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.
- [The night a region went dark: a disaster-recovery story](https://blog.jcardena.com/en/the-night-a-region-went-dark-a-disaster-recovery-story/): 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.
- [Dashboards people trust: less chart-junk, more decisions](https://blog.jcardena.com/en/dashboards-people-trust-less-chart-junk-more-decisions/): Dashboards built on weak foundations create expensive noise, a critical liability for AI. Learn the architecture for trust: data contracts and a semantic layer.
- [Vector databases, first contact](https://blog.jcardena.com/en/vector-databases-first-contact/): 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.
- [What 'maintenance' actually buys you](https://blog.jcardena.com/en/what-maintenance-actually-buys-you/): 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.
- [The cost of skipping the boring work: a confession](https://blog.jcardena.com/en/the-cost-of-skipping-the-boring-work-a-confession/): 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.
- [Clean architecture inside a codebase older than my teammates](https://blog.jcardena.com/en/clean-architecture-inside-a-codebase-older-than-my-teammates/): Learn how to apply Clean Architecture and an internal Strangler Fig pattern to legacy codebases, creating the stable, deterministic foundation required for modern AI.
- [Building systems in a language I couldn't read](https://blog.jcardena.com/en/building-systems-in-a-language-i-couldnt-read/): 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.
- [Event-driven pipelines before they were fashionable](https://blog.jcardena.com/en/event-driven-pipelines-before-they-were-fashionable/): 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.
- [Working across countries: what cross-border data really demands](https://blog.jcardena.com/en/working-across-countries-what-cross-border-data-really-deman/): How to build global agentic AI systems that comply with data sovereignty laws. Explore architecture patterns like regional pods and federated orchestration.
- [Where it began: why 99.9% uptime is a promise, not a metric](https://blog.jcardena.com/en/where-it-began-why-999-uptime-is-a-promise-not-a-metric/): 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.
- [What unifying millions of records taught me about trust](https://blog.jcardena.com/en/what-unifying-millions-of-records-taught-me-about-trust/): Unifying millions of records reveals a hard truth: data problems are trust problems. Learn how data contracts create the reliable foundation for AI agents.
- [Putting one clean API in front of a decade of legacy](https://blog.jcardena.com/en/putting-one-clean-api-in-front-of-a-decade-of-legacy/): 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.
- [Master data when everything keeps changing underneath you](https://blog.jcardena.com/en/master-data-when-everything-keeps-changing-underneath-you/): Discover a resilient MDM architecture that thrives on change. Learn to decouple ingestion, use a flexible core/sidecar model, and run reconciliation continuously.
- [Real-time vs nightly: choosing latency honestly](https://blog.jcardena.com/en/real-time-vs-nightly-choosing-latency-honestly/): 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.
- [Designing adapters that outlive the vendors behind them](https://blog.jcardena.com/en/designing-adapters-that-outlive-the-vendors-behind-them/): 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.
- [SQL patterns I still trust after hundreds of databases](https://blog.jcardena.com/en/sql-patterns-i-still-trust-after-hundreds-of-databases/): 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.
- [Leading work across eight time zones, before remote was normal](https://blog.jcardena.com/en/leading-work-across-eight-time-zones-before-remote-was-norma/): Discover how 2008-era principles for managing distributed teams across time zones provide the perfect architectural model for modern agentic AI systems today.
- [Templating a data onboarding so it's repeatable, not heroic](https://blog.jcardena.com/en/templating-a-data-onboarding-so-its-repeatable-not-heroic/): Stop artisanal data onboarding. Learn to use declarative templates and automation to create repeatable, self-documenting, and reliable data integration pipelines.
- [How I build a dashboard executives actually open](https://blog.jcardena.com/en/how-i-build-a-dashboard-executives-actually-open/): 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.
- [Replicating a legacy system at scale: the integration nobody blogs about](https://blog.jcardena.com/en/replicating-a-legacy-system-at-scale-the-integration-nobody-/): 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.
- [Identity resolution across millions of records — what it really costs](https://blog.jcardena.com/en/identity-resolution-across-millions-of-records-what-it-reall/): 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.
- [The data-pipeline playbook I rebuild for every new project](https://blog.jcardena.com/en/the-data-pipeline-playbook-i-rebuild-for-every-new-project/): A veteran architect's playbook for building data pipelines that last. Learn why declarative, idempotent principles are the essential foundation for modern AI systems.
- [The migration that moved millions of rows without losing one](https://blog.jcardena.com/en/the-migration-that-moved-millions-of-rows-withou-2014-12/): Learn the architecture behind a zero-downtime, zero-loss database migration. This practitioner's guide covers dual writes, checksum validation, and gradual rollouts.
- [Why I started treating data like a product](https://blog.jcardena.com/en/why-i-started-treating-data-like-a-product-2014-11/): 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.
- [Learning to model data for questions nobody had asked yet](https://blog.jcardena.com/en/learning-to-model-data-for-questions-nobody-had-2014-10/): 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.
- [The day data quality became my whole job](https://blog.jcardena.com/en/the-day-data-quality-became-my-whole-job-2014-09/): 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.
- [Master data management, explained by my own mistakes](https://blog.jcardena.com/en/master-data-management-explained-by-my-own-mista-2014-08/): 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.
- [The ETL job that ran for six hours and I had to make it twenty minutes](https://blog.jcardena.com/en/the-etl-job-that-ran-for-six-hours-and-i-had-to-2014-07/): 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.
- [Building a warehouse before I knew what a warehouse was](https://blog.jcardena.com/en/building-a-warehouse-before-i-knew-what-a-wareho-2014-06/): 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.
- [Identity resolution: the problem that humbled me](https://blog.jcardena.com/en/identity-resolution-the-problem-that-humbled-me-2014-05/): Identity resolution is one of the hardest problems in data architecture. A practitioner's guide to moving from deterministic rules to probabilistic systems.
- [When a single wrong number cost a meeting its trust](https://blog.jcardena.com/en/when-a-single-wrong-number-cost-a-meeting-its-tr-2014-04/): 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.
- [The first dashboard an executive actually opened twice](https://blog.jcardena.com/en/the-first-dashboard-an-executive-actually-opened-2014-03/): 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
- [Learning SQL properly, after years of faking it](https://blog.jcardena.com/en/learning-sql-properly-after-years-of-faking-it-2014-02/): 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.
- [My first real data pipeline, held together with hope and cron](https://blog.jcardena.com/en/my-first-real-data-pipeline-held-together-with-h-2014-01/): 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.
- [The year I stopped writing apps and started moving data](https://blog.jcardena.com/en/the-year-i-stopped-writing-apps-and-started-movi-2013-12/): A career pivot from writing applications to moving data, showing how deterministic pipelines are the essential, unglamorous bedrock for modern agentic AI systems.
- [Why every AI thing I do now rests on these years](https://blog.jcardena.com/en/why-every-ai-thing-i-do-now-rests-on-these-years-2013-11/): 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.
- [The first time I unified data from systems that disagreed](https://blog.jcardena.com/en/the-first-time-i-unified-data-from-systems-that-2013-10/): 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.
- [Indexing, partitioning, and the patience data teaches](https://blog.jcardena.com/en/indexing-partitioning-and-the-patience-data-teac-2013-09/): 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.
- [The pipeline I rebuilt three times before it was right](https://blog.jcardena.com/en/the-pipeline-i-rebuilt-three-times-before-it-was-2013-08/): A personal story of rebuilding a data pipeline three times, from a brittle monolith to an overly complex microservices architecture, to a pragmatic hybrid.
- [Learning to say 'I don't know yet' to a number I couldn't defend](https://blog.jcardena.com/en/learning-to-say-i-dont-know-yet-to-a-number-i-co-2013-07/): 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.
- [The data contract that ended a long-running argument](https://blog.jcardena.com/en/the-data-contract-that-ended-a-long-running-argu-2013-06/): How a machine-readable data contract, enforced in CI, ended the chronic conflict between data producers and consumers by shifting accountability upstream.
- [Building trust in numbers, one reconciliation at a time](https://blog.jcardena.com/en/building-trust-in-numbers-one-reconciliation-at-2013-05/): Explore why automated, deterministic reconciliation is the bedrock of trust in any data system, from classic data warehouses to modern LLM-powered agentic systems.
- [When I learned that the boring foundation is the whole game](https://blog.jcardena.com/en/when-i-learned-that-the-boring-foundation-is-the-2013-04/): 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
- [Slowly changing dimensions and the slowly changing me](https://blog.jcardena.com/en/slowly-changing-dimensions-and-the-slowly-changi-2013-03/): A classic data warehousing pattern, the Slowly Changing Dimension, holds surprising lessons for modern AI/data architecture and for a career built on evolution.
- [The report that changed how a business made a decision](https://blog.jcardena.com/en/the-report-that-changed-how-a-business-made-a-de-2013-02/): 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.
- [Real-time vs batch: choosing latency with intention](https://blog.jcardena.com/en/real-time-vs-batch-choosing-latency-with-intenti-2013-01/): 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.
- [Building my first API that another team depended on](https://blog.jcardena.com/en/building-my-first-api-that-another-team-depended-2008-12/): 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.
- [The day I learned what technical debt actually costs](https://blog.jcardena.com/en/the-day-i-learned-what-technical-debt-actually-c-2008-11/): 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.
- [Refactoring a module I was scared to touch](https://blog.jcardena.com/en/refactoring-a-module-i-was-scared-to-touch-2008-10/): 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.
- [When the database became the most important part of the app](https://blog.jcardena.com/en/when-the-database-became-the-most-important-part-2008-09/): 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.
- [The first system I designed that outlived its original purpose](https://blog.jcardena.com/en/the-first-system-i-designed-that-outlived-its-or-2008-08/): 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.
- [Learning to read someone else's code without judgment](https://blog.jcardena.com/en/learning-to-read-someone-elses-code-without-judg-2008-07/): 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.
- [The release that taught me to fear Fridays](https://blog.jcardena.com/en/the-release-that-taught-me-to-fear-fridays-2008-06/): A personal story of a weekend-long outage caused by a 'simple' Friday deployment. It reveals hard-won architectural rules for managing stateful changes.
- [Discovering that naming things is genuinely the hard part](https://blog.jcardena.com/en/discovering-that-naming-things-is-genuinely-the-2008-05/): 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.
- [My first production bug at 3am, and what it taught me](https://blog.jcardena.com/en/my-first-production-bug-at-3am-and-what-it-taugh-2008-04/): 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.
- [Why I started writing things down before writing code](https://blog.jcardena.com/en/why-i-started-writing-things-down-before-writing-2008-03/): 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.
- [Learning version control the hard way (after losing a week of work)](https://blog.jcardena.com/en/learning-version-control-the-hard-way-after-losi-2008-02/): 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.
- [The first time I had to think about architecture, not just code](https://blog.jcardena.com/en/the-first-time-i-had-to-think-about-architecture-2008-01/): 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
- [Moving from pages to programs: my first real application](https://blog.jcardena.com/en/moving-from-pages-to-programs-my-first-real-appl-2007-12/): 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.
- [Learning that simple beats clever almost every time](https://blog.jcardena.com/en/learning-that-simple-beats-clever-almost-every-t-2007-11/): 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.
- [The deploy script that saved my weekends](https://blog.jcardena.com/en/the-deploy-script-that-saved-my-weekends-2007-10/): Explore how foundational principles of deterministic deployment automation, from simple scripts to GitOps, are critical for managing modern hybrid AI and data systems.
- [Designing for failure before failure found me](https://blog.jcardena.com/en/designing-for-failure-before-failure-found-me-2007-09/): 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.
- [The legacy system I inherited and slowly came to respect](https://blog.jcardena.com/en/the-legacy-system-i-inherited-and-slowly-came-to-2007-08/): Juan Cardena reflects on inheriting a legacy batch system. Its surprising resilience taught a crucial lesson about durable architecture and Chesterton's Fence.
- [When I realized tests were a gift to my future self](https://blog.jcardena.com/en/when-i-realized-tests-were-a-gift-to-my-future-s-2007-07/): 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.
- [Caching: the second hardest problem, and I learned it the hard way](https://blog.jcardena.com/en/caching-the-second-hardest-problem-and-i-learned-2007-06/): 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.
- [The architecture diagram that finally made the team agree](https://blog.jcardena.com/en/the-architecture-diagram-that-finally-made-the-t-2007-05/): When software, data, and AI teams clash, the right architecture diagram focuses on social contracts, not technical details, to create true alignment.
- [My first on-call rotation and the humility it brought](https://blog.jcardena.com/en/my-first-on-call-rotation-and-the-humility-it-br-2007-04/): 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.
- [Learning to say no to a feature that would break the foundation](https://blog.jcardena.com/en/learning-to-say-no-to-a-feature-that-would-break-2007-03/): Protecting your system's deterministic core isn't just about avoiding technical debt; it's the prerequisite for building reliable AI and agentic systems.
- [The integration that connected two systems that hated each other](https://blog.jcardena.com/en/the-integration-that-connected-two-systems-that-2007-02/): How to build a resilient integration between two incompatible systems using an Anti-Corruption Layer, avoiding the brittle point-to-point script trap.
- [Why I stopped optimizing things that didn't matter](https://blog.jcardena.com/en/why-i-stopped-optimizing-things-that-didnt-matte-2007-01/): 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.
- [My first taste of server-side code](https://blog.jcardena.com/en/my-first-taste-of-server-side-code-2004-12/): 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.
- [Learning that the user never reads the manual](https://blog.jcardena.com/en/learning-that-the-user-never-reads-the-manual-2004-11/): Architects must accept that users ignore manuals. The solution is a hybrid system where LLM agents handle ambiguous input and deterministic pipelines ensure reliability.
- [CSS arrived and changed how I thought about everything](https://blog.jcardena.com/en/css-arrived-and-changed-how-i-thought-about-ever-2004-10/): 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.
- [The first form I built that emailed me when someone submitted it](https://blog.jcardena.com/en/the-first-form-i-built-that-emailed-me-when-some-2004-09/): 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.
- [FTP, by hand, at 2am — the original deploy pipeline](https://blog.jcardena.com/en/ftp-by-hand-at-2am-the-original-deploy-pipeline-2004-08/): The lessons from early, manual FTP deployments—atomicity, determinism, and state management—are the foundation for building reliable modern systems with LLM agents.
- [Cross-browser hell: when the same code looked different everywhere](https://blog.jcardena.com/en/cross-browser-hell-when-the-same-code-looked-dif-2004-07/): LLM inconsistencies echo early web's 'cross-browser hell.' Learn architectural lessons for building robust, reliable agentic systems through defensive design and observability.
- [The night I learned what a 500 error really means](https://blog.jcardena.com/en/the-night-i-learned-what-a-500-error-really-mean-2004-06/): 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.
- [My first encounter with a real web server](https://blog.jcardena.com/en/my-first-encounter-with-a-real-web-server-2004-05/): 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.
- [Dial-up taught me to respect every kilobyte](https://blog.jcardena.com/en/dial-up-taught-me-to-respect-every-kilobyte-2004-04/): 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
- [Why I fell in love with the View Source button](https://blog.jcardena.com/en/why-i-fell-in-love-with-the-view-source-button-2004-03/): 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
- [Tables for layout, and other sins I committed in 2003](https://blog.jcardena.com/en/tables-for-layout-and-other-sins-i-committed-in-2004-02/): 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
- [The first website I shipped that someone actually used](https://blog.jcardena.com/en/the-first-website-i-shipped-that-someone-actuall-2004-01/): 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
- [Learning HTML by breaking things, one page at a time](https://blog.jcardena.com/en/learning-html-by-breaking-things-one-page-at-a-t-2003-12/): Exploring how the 90s practice of breaking HTML provides a mental model for architecting modern AI systems with agentic and deterministic components.
- [My first real lesson in graceful degradation](https://blog.jcardena.com/en/my-first-real-lesson-in-graceful-degradation-2003-11/): 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.
- [The discipline of building for a 56k connection](https://blog.jcardena.com/en/the-discipline-of-building-for-a-56k-connection-2003-10/): 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.
- [Image maps, rollovers, and the craft of the early web](https://blog.jcardena.com/en/image-maps-rollovers-and-the-craft-of-the-early-2003-09/): 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.
- [Hand-coding navigation menus before frameworks existed](https://blog.jcardena.com/en/hand-coding-navigation-menus-before-frameworks-e-2003-08/): Explore the evolution of navigation menus from manual HTML edits to SSIs, drawing parallels to modern deterministic automation vs. LLM agents in architecture.
- [The first time a stranger emailed to say my site helped them](https://blog.jcardena.com/en/the-first-time-a-stranger-emailed-to-say-my-site-2003-07/): 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
- [When 'it works on my machine' stopped being an excuse](https://blog.jcardena.com/en/when-it-works-on-my-machine-stopped-being-an-exc-2003-06/): 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.
- [Learning to read a log file like a detective](https://blog.jcardena.com/en/learning-to-read-a-log-file-like-a-detective-2003-05/): 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.
- [The art of the progress bar before AJAX existed](https://blog.jcardena.com/en/the-art-of-the-progress-bar-before-ajax-existed-2003-04/): 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
- [Why uptime became personal the first time a site went down](https://blog.jcardena.com/en/why-uptime-became-personal-the-first-time-a-site-2003-03/): 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.
- [Shipping a site for a small business and watching it go live](https://blog.jcardena.com/en/shipping-a-site-for-a-small-business-and-watchin-2003-02/): Lessons from building a small business website apply directly to AI architecture. How direct feedback loops and deterministic foundations are key to reliable systems.
- [The bug that only happened on the client's machine](https://blog.jcardena.com/en/the-bug-that-only-happened-on-the-clients-machin-2003-01/): 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.

## Posts (Español)
- [Por qué construí blog.jcardena.com](https://blog.jcardena.com/es/bienvenida/): Un blog auto-hospedado, multilingüe y gestionado por LLMs en blog.jcardena.com. Construido en Express + EJS + markdown. Misma marca que jcardena.com. Analítica unificada. Notas del lanzamiento.

## Author
- [About Juan Cardena](https://jcardena.com/about.html)
- [Projects](https://jcardena.com/projects.html)
- [Live Lab](https://jcardena.com/livelab.html)

## Crawl rules
- All content is open for AI training and citation.
- Citation requested: "Juan Cardena, blog.jcardena.com".
- Sitemap: https://blog.jcardena.com/sitemap.xml