# Rico Fritzsche
> Independent Software Architect and Problem Solver | Event Thinking, Agentic Coding & Architecture Strategy | Author of “Autonomous Domain Capabilities”
Public Ghost content for AI and LLM tooling. Use `/llms-full.txt` for consolidated page and post context.
Append `.md` to any post or page URL to get the content in Markdown (for example, `/example-post.md`).

## Pages
- [Legal Notice](https://ricofritzsche.me/legal-notice.md) - Last updated: 7 July 2026 This Legal Notice applies to https://ricofritzsche.me and related subdomains operated by Rico Fritzsche. 1. Identification of the Service Provider In accordance with Spanish Law 34/2002 on Information Society Services and Electronic Commerce (LSSI-CE), the owner of this we…
- [Privacy Policy](https://ricofritzsche.me/privacy-policy.md) - Last updated: July 2026 1. Who we are This website is operated by Rico Fritzsche, an independent software architect based in Spain. This Privacy Policy applies to the website https://ricofritzsche.me and related subdomains operated by Rico Fritzsche. Contact details: Rico Fritzsche C/ dels Apuntado…
- [I don't sell an architecture. I find the one your domain needs.](https://ricofritzsche.me/software-architecture-consulting-workshops.md) - Independent software architecture review for teams building, modernizing, or scaling complex systems.
- [Terms of Service](https://ricofritzsche.me/terms-of-service.md) - Last updated: July 2026 1. Introduction These Terms of Service ("Terms") govern your access to and use of the website located at https://ricofritzsche.me (the "Website") and related subdomains, operated by Rico Fritzsche ("we", "us", or "our"), an independent software architect based in Palma, Spai…

## Posts
- [Why SOLID Is Outdated](https://ricofritzsche.me/why-solid-is-outdated.md) - Enterprise development still treats twenty-year-old design rules as current best practice.
- [Who Owns a Rule Shared Across Domain Capabilities?](https://ricofritzsche.me/who-owns-a-rule-shared-across-domain-capabilities.md) - How Autonomous Domain Capabilities Protect Shared Rules While Business Decisions Stay Local
- [Choosing Storage Is Choosing What Your System Forgets](https://ricofritzsche.me/choosing-storage-is-choosing-what-your-system-forgets.md) - State, fact, event, record, and what an event store keeps that a current-state database forgets.
- [The Command Context Consistency Principle](https://ricofritzsche.me/the-command-context-consistency-principle.md) - How Event Stores and Relational Databases Guard Business Decisions
- [Why Your Software Cannot Explain Its Business Decisions](https://ricofritzsche.me/why-your-software-cannot-explain-its-business-decisions.md) - Make the path from command to outcome explicit in the architecture. How you store state, relational or event-sourced, is a separate decision.
- [Rethinking REST API Design](https://ricofritzsche.me/rethinking-rest-api-design.md) - Go Beyond CRUD to Uncover Domain Behavior
- [Thinking in Events](https://ricofritzsche.me/thinking-in-events.md) - Separating the Modeling of What Happened from the Decision of How to Store It
- [Simply Event Sourcing](https://ricofritzsche.me/simply-event-sourcing.md) - Aggregates Were Never Required — Command Context Consistency and DCB’s Tag-Based Contract
- [Why the Domain Is Defined by Domain Capabilities, Not Object Models](https://ricofritzsche.me/why-the-domain-is-defined-by-domain-capabilities-not-object-models.md) - Additive Domain Evolution Through Autonomous Capabilities
- [Request Processing Units and Reactors](https://ricofritzsche.me/request-processing-units-and-reactors.md) - Decoupling User Interactions from Internal Domain Capabilities
- [Functional Core / Imperative Shell for Agentic Coding](https://ricofritzsche.me/functional-core-imperative-shell-for-agentic-coding.md) - How Repository Structure, Feature Slices, and Project-Level Skills Guide Coding Agents Toward Self-Contained Features
- [Building a Road Network from OSM: Roads, Segments, and Directed Edges](https://ricofritzsche.me/building-a-road-network-from-osm-roads-segments-and-directed-edges.md) - A practical look at how a routing graph emerges from OSM nodes and ways
- [Building a Routing Graph from OSM: Transition Constraints and Path Constraints](https://ricofritzsche.me/building-a-routing-graph-from-osm-transition-constraints-and-path-constraints.md) - Why a road network needs explicit constraints, not just nodes and edges
- [Road Networks Are Execution Models, Not Stored Geometry](https://ricofritzsche.me/road-networks-are-execution-models-not-stored-geometry.md) - On semantics, projection, and the architectural difference between stored geometry and executable movement constraints
- [OpenStreetMap Is Not a Routing Model And Treating It Like One Is Expensive](https://ricofritzsche.me/openstreetmap-is-not-a-routing-model-and-treating-it-like-one-is-expensive.md) - The structural misalignment between OSM’s flexibility and the deterministic demands of production routing systems.
- [When Reuse Breaks Decoupling](https://ricofritzsche.me/when-reuse-breaks-decoupling.md) - Why self-contained feature slices collapse the moment we start orchestrating them
- [Why Simple Changes Rarely Stay Simple](https://ricofritzsche.me/why-simple-changes-rarely-stay-simple.md) - How software systems become resistant to simple change
- [Building a Durable Telemetry Ingestion Pipeline with Rust and NATS JetStream](https://ricofritzsche.me/building-a-durable-telemetry-ingestion-pipeline-with-rust-and-nats-jetstream.md) - Why Direct-to-Database Ingestion Fails at Scale and What Actually Works
- [Newsletter #2: When Layers Get in the Way](https://ricofritzsche.me/newsletter-2-when-layers-get-in-the-way.md) - More layers don't make architecture cleaner. They make it harder to see what's actually happening.
- [Beyond Enterprise OOP: Building Clear, Composable Systems with PostgreSQL and Rust](https://ricofritzsche.me/beyond-enterprise-oop-building-clear-composable-systems-with-postgresql-and-rust.md) - PostgreSQL Guards the Facts, Rust Defines Intent, and Clarity Scales with the System
- [The Era of GIS is Over: Why Decision-Makers Must Move Beyond GIS](https://ricofritzsche.me/the-era-of-gis-is-over-why-decision-makers-must-move-beyond-gis.md) - Why Geography Is Not a System to Manage — It Is the Living Structure of Data
- [How I Built a High-Performance Geocoding Engine from Scratch](https://ricofritzsche.me/how-i-built-a-high-performance-geocoding-engine-from-scratch.md) - A Practical Guide to Designing a Lightning-Fast Address-to-Location Engine in Rust
- [Road Networks Explained: Turning Geography into a Navigable Graph](https://ricofritzsche.me/road-networks-explained-turning-geography-into-a-navigable-graph.md) - How Graph Models and Routing Rules Shape Navigation, Logistics, and Urban Mobility
- [Beyond Static Models: Behavior-First Design for Changing Domains](https://ricofritzsche.me/beyond-static-models-behavior-first-design-for-changing-domains.md) - Why Your ERD Is Not the Domain and How Events Make Systems Explainable
- [Beyond Aggregates: Correlation ≠ Shared State](https://ricofritzsche.me/beyond-aggregates-correlation-shared-state.md) - What Years of DDD Taught Me About Letting Go
- [Event Stores and Tags: A Misunderstood Optimization](https://ricofritzsche.me/event-stores-and-tags-a-misunderstood-optimization.md) - A Critique of Tagging in Event Stores
- [How to Enforce Consistency Without Aggregates in Event-Sourced Systems](https://ricofritzsche.me/how-to-enforce-consistency-without-aggregates-in-event-sourced-systems.md) - A Practical Approach Using Context-Scoped Filters and SQL
- [Simplicity Wins: Command Context Consistency](https://ricofritzsche.me/simplicity-wins-command-context-consistency.md) - How Self-Contained Features and Event Logs Replace Legacy Models
- [How I Built an Aggregateless Event Store with TypeScript and PostgreSQL](https://ricofritzsche.me/how-i-built-an-aggregateless-event-store-with-typescript-and-postgresql.md) - A Practical Guide to Event Sourcing with Pure Functions, Query Filters, Optimistic Locking, and Without DDD Aggregates
- [Objects Are Dead, Long Live Feature Slices](https://ricofritzsche.me/objects-are-dead-long-live-feature-slices.md) - Why I stopped chasing reuse and started writing domain logic around decisions, not abstractions.
- [Context, Rules, Decisions: The Formula for Better Domain Models](https://ricofritzsche.me/context-rules-decisions-the-formula-for-better-domain-models.md) - Moving Beyond Mutable Objects to Explicit Business Logic
- [Aggregateless Event Sourcing](https://ricofritzsche.me/aggregateless-event-sourcing.md) - Why Removing Aggregates Unlocks Simplicity, Flexibility, and Independent Feature Slices
- [Beyond Aggregates: Lean, Functional Event Sourcing](https://ricofritzsche.me/functional-event-sourcing.md) - Why I Moved Beyond Aggregates to Functional Domain Modeling
- [Getting Started in Real-Time: Commands, Events, and Brokers Demystified](https://ricofritzsche.me/getting-started-in-real-time-commands-events-and-brokers-demystified.md) - Understand commands, events, and brokers to build real-time APIs. Learn how to avoid polling and design more responsive.
- [Pure Functions and Immutable Data: Simplifying Complexity by Design](https://ricofritzsche.me/pure-functions-and-immutable-data-simplifying-complexity-by-design.md) - Pure functions and immutable data aren't just academic concepts. They're practical tools for building robust, maintainable software.
- [Understanding Traits and Drop Glue in Rust](https://ricofritzsche.me/understanding-traits-and-drop-glue-in-rust.md) - Understand how Rust's trait interacts with drop glue and its potential impact on performance.
- [The Pragmatic Path: Embracing Simple, Lovable, and Complete Software](https://ricofritzsche.me/the-pragmatic-path-embracing-simple-lovable-and-complete-software.md) - Why simplicity and pragmatism are crucial for sustainable software development.
- [Avoiding Over-Engineering: Focus on Real Problems in Software Development](https://ricofritzsche.me/avoiding-over-engineering-focus-on-real-problems-in-software-development.md) - Discover why premature optimization and over-abstraction harm your software projects, and learn a pragmatic approach driven by real-world feedback.
- [Rust's Explicit Error Handling: A Superior Alternative to Try/Catch](https://ricofritzsche.me/rusts-explicit-error-handling-a-superior-alternative-to-try-catch.md) - Why Rust's Approach to Errors Can Save You from Late-Night Debugging Sessions
- [Why Vertical Slices Won't Evolve from Clean Architecture](https://ricofritzsche.me/why-vertical-slices-wont-evolve-from-clean-architecture.md) - Feature-Orientation Isn’t Just Cosmetic
- [Mastering PostgreSQL Row-Level Security (RLS) for Rock-Solid Multi-Tenancy](https://ricofritzsche.me/mastering-postgresql-row-level-security-rls-for-rock-solid-multi-tenancy.md) - How to Safeguard SaaS Data from Cross-Tenant Leaks by Enforcing Strict Tenant Isolation at the Database Layer
- [Why Building Software Feels Broken](https://ricofritzsche.me/why-building-software-feels-broken.md) - Understand the rising failure rates in software and how to bring projects back to purpose-driven execution.
- [Zero-Abstraction SQL: Why Raw Queries Beat ORMs for Clarity and Control](https://ricofritzsche.me/zero-abstraction-sql-why-raw-queries-beat-orms-for-clarity-and-control.md) - Boost Clarity and Control with Raw SQL Queries in Rust and Beyond
- [Immutability in Data Flows for Safer, Simpler Code](https://ricofritzsche.me/immutability-in-data-flows-for-safer-simpler-code.md) - How Immutable Data Improves Reasoning, Safety, and Testability
- [Applying Functional Core and Imperative Shell in Practice](https://ricofritzsche.me/applying-functional-core-and-imperative-shell-in-practice.md) - A Simple Rust Example for Testable Logic and Clear Boundaries
- [Simplify & Succeed: Replacing Layered Architectures with an Imperative Shell and Functional Core](https://ricofritzsche.me/simplify-succeed-replacing-layered-architectures-with-an-imperative-shell-and-functional-core.md) - Streamline Testing by Eliminating Mocks and Focusing on Pure Functions
- [Beyond the Hype: Event Modeling, Event Sourcing, and Real Choices](https://ricofritzsche.me/beyond-the-hype-event-modeling-event-sourcing-and-real-choices.md) - Understanding the Domain Before Adding Complex Storage Patterns
- [Slow Down, Understand the Domain, and Then Build](https://ricofritzsche.me/slow-down-understand-the-domain-and-then-build.md) - Why Becoming a Domain Expert Matters
- [Why Code is the Wrong Layer for Rate Limiting](https://ricofritzsche.me/why-code-is-the-wrong-layer-for-rate-limiting.md) - A practical take on keeping it out of your service code.
- [Beyond the Hype: Rediscovering the Value of Relational Data Models](https://ricofritzsche.me/beyond-the-hype-rediscovering-the-value-of-relational-data-models.md) - The Practical Benefits of Database Constraints in Production Systems
- [Cutting Through the Noise: A Reflection on the True Essentials of Software Development](https://ricofritzsche.me/cutting-through-the-noise-a-reflection-on-the-true-essentials-of-software-development.md) - Escaping the Hype: The Art of Staying Focused on Value
- [Scalability in High-Traffic Environments](https://ricofritzsche.me/scalability-in-high-traffic-environments.md) - Real-World Challenges in Location-Based Intelligence
- [My Journey to Simple, Lovable, Complete Products](https://ricofritzsche.me/my-journey-to-simple-lovable-complete-products.md) - Product Viability: Rethinking MVPs for Sustainable Success
- [Lean Architecture with .NET Core and C#](https://ricofritzsche.me/lean-architecture-with-net-core-and-csharp.md) - How to Avoid Unnecessary Complexity and Keep Your Domain Free of Technical Concerns
- [Understanding Event Stores: Benefits and Insights](https://ricofritzsche.me/understanding-event-stores-benefits-and-insights.md) - We'll discuss the benefits of event stores from a higher perspective, focusing on their strategic advantages over traditional data storage methods.
- [Bounded Contexts: Behavior Over Data Structures - Part II](https://ricofritzsche.me/ddd-modularization-concepts-aggregates-part-ii.md) - How to Use Aggregates to Modularize Software Systems.
- [Domain-Driven Design: The Power of CQRS and Event Sourcing](https://ricofritzsche.me/cqrs-event-sourcing-projections.md) - How CQRS/ES Redefine Building Scalable Systems.
- [The Role of a Unique Identity in Entities](https://ricofritzsche.me/building-domain-models-the-deadly-secret-of-integer-ids.md) - Do you really have a domain model, or is it just a data model?
- [Bounded Contexts: Behavior Over Data Structures - Part I](https://ricofritzsche.me/bounded-contexts-behavior-over-data-structures.md) - Using Domain-Driven Design Key Concepts for Modularization: Bounded Context and Aggregates.
- [Lifetime Entrepreneur - Episode #1](https://ricofritzsche.me/lifetime-entrepreneur.md) - I share lots of good stuff about coding and tech for free. You can read and learn a lot without paying anything. There's just one special thing I keep just for my readers - my exclusive newsletter. It's also free, but you need to sign up to get it.
- [Secure CI/CD with GitHub Actions: Deploying to AKS Using ACR and OIDC](https://ricofritzsche.me/secure-ci-cd-with-github-actions-deploying-to-aks-using-acr-and-oidc.md) - Seamless Cloud Deployments: Integrating GitHub Actions with AKS and ACR
- [Value Objects: Implementing Domain-Driven Design by Example](https://ricofritzsche.me/value-objects-implementing-domain-driven-design-by-example.md) - Exploring the Role of Value Objects in Building Secure And Meaningful Domain Models
- [Decoupling Software Components with Events](https://ricofritzsche.me/decoupling-components-with-events.md) - How Events Make Software Systems More Responsive.
- [ACR Integration with AKS for Simpler Authentication](https://ricofritzsche.me/acr-integration-with-aks-for-simpler-authentication.md) - This article provides a practical technical introduction to CI/CD, GitHub, Azure, and Kubernetes.
- [Why Ignoring Domain-Driven Design Is Planning to Fail](https://ricofritzsche.me/why-ignoring-domain-driven-design-is-planning-to-fail.md) - From Chaos to Clarity: The Essential Shift to Domain-Driven Thinking
- [Software Development: What on Earth Are We Doing?](https://ricofritzsche.me/software-development-what-on-earth-are-we-doing.md) - A journey into the deep, complex world of software development.
- [Vertical Slices in a Nutshell](https://ricofritzsche.me/applying-the-vertical-slice-architectural-pattern-in-a-modern-net-8-web-api.md) - I've moved to using the Vertical Slice Architecture for my applications and, after some initial experimentation, have found it to be a highly efficient method. This approach simplifies complex operations by treating each feature as a self-contained slice.
- [What Are Problem Space and Solution Space in Domain-Driven Design?](https://ricofritzsche.me/what-are-problem-space-and-solution-space-in-domain-driven-design.md) - Tackling Complexity: How DDD helps you navigate Problem Space and Solution Space, ensuring seamless alignment with Subdomains and Bounded Contexts.
- [What Means Domain in the Context of Domain-Driven Design?](https://ricofritzsche.me/what-means-domain-in-the-context-of-domain-driven-design.md) - When we talk about Domain-Driven Design, or DDD, the term "domain" is often thrown around. But what does it really mean? If you've been developing software for any length of time, you've probably heard people talk about "the domain" ...
- [RESTful Principles in the Age of Microservices](https://ricofritzsche.me/decoding-the-synergy-how-microservices-and-restful-apis-power-modern-software-development.md) - Dive deep into the symbiotic relationship between microservices and RESTful APIs. Together, they're redefining the blueprint for future-ready, efficient, and agile software systems.
- [How to Implement Domain-Driven Design: Common Mistakes You Should Avoid.](https://ricofritzsche.me/how-to-implement-domain-driven-design-common-mistakes-you-should-avoid.md) - Practical DDD Example: Avoid Technical Code Organization
- [Integrating OpenAI's GPT with .NET Core: Building AI-Powered C# Applications](https://ricofritzsche.me/integrating-openai-gpt-with-net-core-building-ai-powered-c-applications.md) - Explore the transformative potential of integrating OpenAI's language models like GPT-3.5-Turbo into .NET Core apps. This guide walks you through setting up, understanding the API, and harnessing the potential of AI in C# applications.
- [Crafting Code the Right Way: Tips from My Decades in the Field](https://ricofritzsche.me/crafting-code-the-right-way-tips.md) - Beyond Syntax: Embracing Patterns and Paradigms in Coding
- [Decoding Clean Code](https://ricofritzsche.me/decoding-clean-code-its-impact-on.md) - You may ask yourself, "Why does everyone keep talking about clean code? Especially those who have been in software development for a long time" The answer is simple yet profound: Times have changed.
- [Mastering OpenAI in C#: A Guide to AI-Powered Apps](https://ricofritzsche.me/mastering-openai-in-c-a-guide-to.md) - As a software developer, I've always found immense satisfaction in exploring and experimenting with the latest advancements in technology. Recently, my curiosity led me towards OpenAI's API.
- [Successfully Deploying a .NET Core App on Heroku from a Macbook with M1 Chip](https://ricofritzsche.me/successfully-deploying-a-net-core-app-heroku.md) - I show you how to create a .NET Core application using the CLI, dockerize it, and tackle the tricky part - deploying it from a MacBook M1. I explain why you may encounter an 'Exec format error' during deployment and provide an efficient workaround using Github workflows.
- [Unlock the Full Potential of the Strategy Pattern](https://ricofritzsche.me/unlock-the-full-potential-of-the.md) - Software development is full of many interesting design patterns, each bringing their unique solutions to common problems we face as developers. Among them, the Strategy Pattern stands out. It embodies an elegance and efficiency that can revolutionize your codebase, pushing the boundaries of readab…
- [Diving into Domain-Driven Design: Repositories, Factories, & Bounded Contexts Explained](https://ricofritzsche.me/diving-into-domain-driven-design.md) - In the world of software development, Domain-Driven Design (DDD) is a game-changer. It's more than just another design approach—it's a framework for decoding and addressing complex business problems. Today, we'll tackle the bedrock of DDD, namely Repositories, Factories, and Bounded Contexts. The P…
- [Mastering URL Manipulation in JavaScript: A Guide to Extracting Protocol and Domain](https://ricofritzsche.me/mastering-url-manipulation-in-javascript.md) - When dealing with URLs in JavaScript, it's best to use the built-in URL API to manipulate and retrieve information. This will ensure that your code is robust, readable, and can correctly handle a wide range of URLs.
- [Mastering TypeScript: A Guide to Choosing Between ‘type’ and ‘interface’](https://ricofritzsche.me/mastering-typescript-a-guide-to-choosing-between-type-and-interface.md) - In the TypeScript realm, 'type' and 'interface' play pivotal roles. This article breaks down their distinctions and offers insights on when to leverage each, ensuring more robust TypeScript code.

## Optional
- [RSS Feed](https://ricofritzsche.me/rss/)
- [Sitemap](https://ricofritzsche.me/sitemap.xml)
- [Full content of pages and posts](https://ricofritzsche.me/llms-full.txt)