# Software Architecture

> An engineering notebook on software architecture: in-depth articles, living diagrams and clear examples to design systems that scale.

- [Documentation](https://sazardev.github.io/software-architecture/en/docs): Explore every article in the notebook by topic: software architecture explained with diagrams, examples and practice.
- [RSS (en)](https://sazardev.github.io/software-architecture/en/feed.xml)

## Foundations — Conceptual foundations and principles that sustain any solid architecture.

- [Getting started](https://sazardev.github.io/software-architecture/en/docs/getting-started): An orientation guide: what this site is, what to read and in what order for your profile, a four-week plan, how to use search and how to contribute content.
- [SOLID principles](https://sazardev.github.io/software-architecture/en/docs/solid): The five SOLID principles explained with concrete examples and links to go deeper on each one.
- [ADRs: document architecture decisions](https://sazardev.github.io/software-architecture/en/docs/adr): A practical guide to ADRs: what they are, when to write them, templates (Nygard, MADR, Y-statements), lifecycle, PR review and working with AI agents.
- [Coupling and cohesion: the foundation of design](https://sazardev.github.io/software-architecture/en/docs/acoplamiento-cohesion): A guide for architects: types of cohesion and coupling, information hiding, deep modules, Demeter, instability and connascence, with tooling.
- [Quality attributes and trade-offs](https://sazardev.github.io/software-architecture/en/docs/atributos-de-calidad): How to choose the quality attributes that drive your architecture, write them as measurable scenarios, weigh trade-offs with a light ATAM and track SLOs.
- [DevOps and its culture: the foundation of delivery](https://sazardev.github.io/software-architecture/en/docs/devops-cultura): A foundational guide: what DevOps is and is not, its culture (CALMS, Three Ways, Westrum), the DORA metrics and how to adopt it without starting with tools.
- [GoF design patterns, a modern take](https://sazardev.github.io/software-architecture/en/docs/patrones-de-diseno): Which GoF patterns still matter, which ones the language absorbed and which dependency injection replaced, plus a guide to deciding when to use them.
- [Trade-offs and decision-making in architecture](https://sazardev.github.io/software-architecture/en/docs/trade-offs-y-decisiones): How to reason through an architecture decision: explicit criteria, reversibility, the last responsible moment, cognitive biases and a reusable method.
- [Basic design principles](https://sazardev.github.io/software-architecture/en/docs/principios-de-diseno-basicos): DRY, KISS, YAGNI, the Law of Demeter and information hiding: where they come from, what each protects, when they help and when they hurt.
- [Essential and accidental complexity](https://sazardev.github.io/software-architecture/en/docs/complejidad-esencial-y-accidental): The line Brooks drew between the complexity of the problem and the one your tools add: how to diagnose it, avoid its traps and reduce it.
- [Conway's law and Team Topologies](https://sazardev.github.io/software-architecture/en/docs/ley-de-conway-team-topologies): Why an organization's communication ends up in its architecture, the inverse Conway maneuver, and how to design teams with Team Topologies.
- [Data, ACID and isolation levels](https://sazardev.github.io/software-architecture/en/docs/datos-acid-y-aislamiento): Data modeling, ACID transactions, concurrency anomalies and isolation levels: what each level protects against and how to choose in your database.
- [Numbers and performance laws](https://sazardev.github.io/software-architecture/en/docs/numeros-y-leyes-de-rendimiento): The laws of Little and Amdahl, the Universal Scalability Law and queueing: how to estimate latency, concurrency and capacity before you build.
- [Architectural styles](https://sazardev.github.io/software-architecture/en/docs/estilos-arquitectonicos): What an architectural style is, how it differs from a pattern and a technology, and how to choose among nine styles based on your quality attributes.
- [The complexity your tools add](https://sazardev.github.io/software-architecture/en/docs/complejidad-accidental-de-herramientas): Telling apart the complexity of the problem from the complexity your frameworks and tools add, with diagnostic questions and four ways to reduce it.
- [The architect as facilitator](https://sazardev.github.io/software-architecture/en/docs/arquitecto-como-facilitador): How to influence without formal authority: when to decide yourself, when to consult and when to delegate, and how the team keeps ownership of its choices.

## System design — Modeling, diagrams and decisions to communicate complex architecture.

- [C4 model: document your architecture by levels](https://sazardev.github.io/software-architecture/en/docs/c4-model): Learn the four levels of the C4 model with a complete example: context, containers, components and code, plus notation rules and common mistakes.
- [Domain-Driven Design: design from the domain](https://sazardev.github.io/software-architecture/en/docs/domain-driven-design): A DDD guide for architects: subdomains, ubiquitous language, bounded contexts, aggregates, Event Storming and the tools that keep the design honest.
- [Hexagonal architecture: ports and adapters](https://sazardev.github.io/software-architecture/en/docs/arquitectura-hexagonal): A guide for architects: ports and adapters, the dependency rule, how to organize and name the pieces, how to test it and protect it with executable rules.
- [Diagrams as code: document with version control](https://sazardev.github.io/software-architecture/en/docs/diagramas-como-codigo): Compare Mermaid, Structurizr, D2, PlantUML and Graphviz on one system, and learn to version, validate in CI and keep your architecture diagrams alive.
- [Monolith, modular monolith or microservices](https://sazardev.github.io/software-architecture/en/docs/monolito-vs-microservicios): How to choose between a monolith, a modular monolith and microservices: real costs, enforceable boundaries, team structure and migration paths.
- [Layered, Onion and Clean: where dependencies point](https://sazardev.github.io/software-architecture/en/docs/arquitectura-en-capas-clean-onion): Layered, Onion and Clean Architecture compared: the dependency rule, what crosses each boundary, common failures and a guide to choosing.
- [CAP theorem, PACELC and consistency](https://sazardev.github.io/software-architecture/en/docs/cap-pacelc): What CAP and PACELC actually say, the spectrum of consistency models, and how to choose the trade-off per operation in a distributed system.
- [Event-driven, CQRS and Event Sourcing](https://sazardev.github.io/software-architecture/en/docs/event-driven-cqrs-event-sourcing): Events versus commands, notification versus state transfer, CQRS and Event Sourcing: when they pay off, projections, versioning and data erasure.
- [Sagas, outbox and idempotency](https://sazardev.github.io/software-architecture/en/docs/sagas-outbox-idempotencia): How to coordinate changes across services without a distributed transaction: sagas, compensations, outbox, deduplication and idempotency.
- [API design: contracts that last](https://sazardev.github.io/software-architecture/en/docs/diseno-de-apis): Contract-first, REST, GraphQL and gRPC, non-breaking changes, pagination, RFC 9457 errors, idempotency and rate limits for APIs that need to evolve.
- [Multi-agent systems: when one agent is enough](https://sazardev.github.io/software-architecture/en/docs/multiagente-cuando-un-agente-basta): When one agent with good tools is enough, what each link in a multi-agent system costs, and how to design contracts, traces and limits between agents.
- [File architecture for large repositories](https://sazardev.github.io/software-architecture/en/docs/arquitectura-de-archivos-repos-grandes): How to organize a large repository tree so module boundaries are real: domain, public API, enforced dependency rules, ownership and build cost.
- [Resilience in distributed systems](https://sazardev.github.io/software-architecture/en/docs/resiliencia-sistemas-distribuidos): Timeouts, deadlines, retries with backoff and jitter, circuit breakers, bulkheads and load shedding to contain partial failures and measure them.
- [Caching, queues and streaming](https://sazardev.github.io/software-architecture/en/docs/caching-colas-streaming): Caching patterns, invalidation and stampedes; queues versus partitioned logs, delivery semantics, and how to choose between a queue, pub/sub and a log.
- [Versioned, compatible event contracts](https://sazardev.github.io/software-architecture/en/docs/contratos-de-eventos-versionados): How to evolve events without breaking consumers: the schema as a contract, backward and forward compatibility, versioning and measured deprecation.
- [Scalability and classic design cases](https://sazardev.github.io/software-architecture/en/docs/escalabilidad-casos-clasicos): A method for scaling: requirements, back-of-the-envelope estimates, partitions and replicas, applied to a URL shortener, a rate limiter and a news feed.
- [Web rendering: SSR, SSG, ISR and islands](https://sazardev.github.io/software-architecture/en/docs/renderizado-web-ssr-ssg-islands): Where HTML is generated and when: CSR, SSR, SSG, ISR, streaming and islands, with their costs, selection criteria and common mistakes.
- [Case study: a system from start to finish](https://sazardev.github.io/software-architecture/en/docs/caso-estudio-sistema-completo): Illustrative case of a booking system: requirements, boundaries, data, integration, security and evolution, with each decision and its alternative.
- [Multi-tenancy: many customers, one system](https://sazardev.github.io/software-architecture/en/docs/multi-tenancy): How to design a multi-tenant SaaS: isolation models, tenant identification, Row-Level Security, noisy neighbors, schema migrations and usage metering.
- [Data modeling: normalize or denormalize](https://sazardev.github.io/software-architecture/en/docs/modelado-de-datos-normalizacion): How to model data after how it is read and written: normalization, deliberate copies with an owner, relational versus document models and query-driven design.
- [Layers are not the architecture](https://sazardev.github.io/software-architecture/en/docs/capas-no-son-arquitectura): Why folders named after layers are not enough: the dependency rule, what each boundary may carry, and when extra layers add noise instead of protection.
- [Modular monolith before microservices](https://sazardev.github.io/software-architecture/en/docs/monolito-modular-primero): Monolith or microservices is the wrong question. How to design boundaries inside one process and when extracting a service actually makes sense.
- [Coordinating services without distributed transactions](https://sazardev.github.io/software-architecture/en/docs/coordinar-servicios-sin-2pc): Sagas with compensations, the outbox pattern and idempotency for an operation that spans several services and can fail halfway through.
- [CAP is decided per operation](https://sazardev.github.io/software-architecture/en/docs/cap-por-operacion): CAP and PACELC explained as per-operation decisions: what choosing consistency or availability means for a balance, a cart or a like counter.
- [Before you scale, do the math](https://sazardev.github.io/software-architecture/en/docs/antes-de-escalar-la-cuenta): Little's law, Amdahl's law and queueing to estimate concurrency and capacity before adding servers, with a full calculation from start to finish.
- [Migrating a database without downtime](https://sazardev.github.io/software-architecture/en/docs/migraciones-bd-sin-downtime): Expand and contract, backward-compatible schema changes and batched backfills to evolve a database without maintenance windows.
- [Legacy systems: strangler and anti-corruption layer](https://sazardev.github.io/software-architecture/en/docs/legado-strangler-anticorrupcion): How to modernize a system you cannot rewrite: a strangler that redirects routes and an anti-corruption layer that protects the new model.
- [Micro-frontends and BFF: when yes and when no](https://sazardev.github.io/software-architecture/en/docs/micro-frontends-y-bff): When to split the frontend into micro-frontends and when a BFF per channel is enough. Criteria on coupling, teams and the cost of coordinating deployments.
- [Real time: WebSockets, SSE and queues](https://sazardev.github.io/software-architecture/en/docs/tiempo-real-websockets-sse): How to choose between SSE, WebSocket and queues to push data in real time: direction of the flow, number of clients and what happens when the connection drops.
- [Payments and the ledger: double entry without errors](https://sazardev.github.io/software-architecture/en/docs/pagos-libro-mayor-ledger): Immutable double-entry postings, corrections by reversal, idempotent charges and reconciliation with the payment provider.
- [Choosing a database: access patterns first](https://sazardev.github.io/software-architecture/en/docs/persistencia-politica-elegir-bd): Before choosing a database, define reads and writes: which store type fits, when polyglot persistence pays off and what it costs to run.
- [Search inside the application: when the database is enough](https://sazardev.github.io/software-architecture/en/docs/busqueda-en-aplicacion): When a database index is enough, when a dedicated inverted index pays off, and how to keep it in sync with the source without losing changes.
- [Notifications: push, email and SMS reliably](https://sazardev.github.io/software-architecture/en/docs/notificaciones-push-correo-sms): A decoupled notification service with one queue per channel, user preferences, deduplication and retries that avoid losses and reduce duplicates.
- [Extensible architecture: plugins and extension points](https://sazardev.github.io/software-architecture/en/docs/arquitectura-extensible-plugins): When to open a system to extensions, extension points with a stable contract, permissions and sandboxing, and versioning and deprecation of the plugin API.
- [Offline-first mobile: syncing without losing data](https://sazardev.github.io/software-architecture/en/docs/movil-offline-first-sincronizacion): How to design an app that writes locally first, syncs a queue of operations in order and resolves conflicts without losing the changes the user made.

## Practices & quality — Habits, continuous refactoring and standards that keep the system healthy.

- [Clean code for architects](https://sazardev.github.io/software-architecture/en/docs/clean-code): A practical clean code guide: names, functions, errors, complexity, tests, refactoring and technical debt, with before/after examples and a review checklist.
- [Harness engineering with Claude Code](https://sazardev.github.io/software-architecture/en/docs/harness-engineering-claude-code): A guide for architects: designing the Claude Code harness with memory, hooks, permissions, subagents and dynamic workflows, current as of October 2026.
- [Fitness functions and evolutionary architecture](https://sazardev.github.io/software-architecture/en/docs/fitness-functions): How to turn your architecture's characteristics into automated checks: types, tools per language and how to adopt them in legacy systems.
- [Technical debt and architectural evolution](https://sazardev.github.io/software-architecture/en/docs/deuda-tecnica-evolucion): How to name, measure and pay down technical debt, and how to evolve the architecture through guided, incremental change instead of rewrites.
- [Security by design: threats, boundaries and trust](https://sazardev.github.io/software-architecture/en/docs/seguridad-por-diseno): Security as a property of the architecture: classic principles, STRIDE in one hour, trust boundaries, secrets, the supply chain and zero trust.
- [Your architecture should fail in CI](https://sazardev.github.io/software-architecture/en/docs/fitness-en-el-ci): How to turn an architecture rule into a check that fails the pipeline: a real ESLint example from this repository and the steps to start with one.
- [Retries with jitter, without storms](https://sazardev.github.io/software-architecture/en/docs/reintentos-con-jitter): Why retries without jitter multiply an outage, and how to combine timeouts, backoff, retry budgets and circuit breakers.
- [Observability: SLIs, SLOs and error budgets](https://sazardev.github.io/software-architecture/en/docs/observabilidad-slo-presupuesto-error): How to measure what users experience with SLIs, set an SLO and use the error budget to decide when to ship faster and when to slow down.
- [Testing strategy: the pyramid and contracts](https://sazardev.github.io/software-architecture/en/docs/estrategia-de-pruebas-contratos): What to test at each level of the pyramid, how contracts between services prevent broken integrations, and which architecture tests to keep.
- [Evaluating agents: trajectories, regressions and judges](https://sazardev.github.io/software-architecture/en/docs/evaluar-agentes-trayectorias): How to evaluate an agent that acts: trajectories versus final outcome, tasks with verifiable criteria, model-based judges, variance and evals in CI.
- [Progressive delivery: flags, canary and blue/green](https://sazardev.github.io/software-architecture/en/docs/entrega-progresiva-flags-canary): Deploying without exposing every user: feature flags, canary and blue/green releases, and how to roll back without deploying again.
- [Agent identity and permissions: least privilege and audit](https://sazardev.github.io/software-architecture/en/docs/identidad-y-permisos-de-agentes): Which identity an AI agent uses, how to delegate narrow credentials, least privilege per action, secrets kept out of context, and revocation.
- [Threat modelling with STRIDE on a real diagram](https://sazardev.github.io/software-architecture/en/docs/modelado-de-amenazas-stride): How to apply STRIDE to a real data flow diagram: trust boundaries, the six threat categories and a complete review example.
- [AI-generated code: review, ownership and debt](https://sazardev.github.io/software-architecture/en/docs/codigo-generado-por-ia): When a model writes the code, review, ownership and debt change: what to measure, who answers for a change and how to leave criteria.
- [Privacy by design: data, retention and deletion](https://sazardev.github.io/software-architecture/en/docs/privacidad-por-diseno-gdpr): Minimization, legal basis, retention periods and deletion that reaches copies and backups: privacy as an architecture requirement.
- [Designing for deletion: retiring code without fear](https://sazardev.github.io/software-architecture/en/docs/disenar-para-borrar): Why code you cannot delete keeps costing you, and how to design boundaries, expiring flags and phased retirements you can reverse.
- [Incidents and blameless postmortems](https://sazardev.github.io/software-architecture/en/docs/gestion-incidentes-postmortems): Incident roles, severities, communication and blameless postmortems that end in owned, dated actions.
- [Secrets and keys: rotation without surprises](https://sazardev.github.io/software-architecture/en/docs/gestion-secretos-claves): Why secrets never belong in the repository, how vaults and workload identities work, and how to rotate keys without taking the service down.
- [Software supply chain: SBOM, signatures and SLSA](https://sazardev.github.io/software-architecture/en/docs/cadena-de-suministro-software): Architect's guide: which inventory, signatures and provenance to require, how to pin dependencies and which SLSA level to target, as of October 2026.
- [Trunk-based vs long branches in continuous delivery](https://sazardev.github.io/software-architecture/en/docs/ramas-y-entrega-continua): How the distance between code and trunk sets the cost of integration: trunk-based versus long branches, flags that expire, a healthy trunk and what to measure.
- [Chaos engineering and game days: failing on purpose](https://sazardev.github.io/software-architecture/en/docs/chaos-engineering-game-days): How to test resilience by injecting controlled faults: hypotheses, blast radius, stop conditions and game days with the teams that run the system.
- [Capacity and load testing: measure with real loads](https://sazardev.github.io/software-architecture/en/docs/capacidad-y-pruebas-de-carga): How much capacity a system needs and how to check it with loads that resemble real traffic: load model, test types, measurement errors and headroom.
- [Distributed tracing with OpenTelemetry](https://sazardev.github.io/software-architecture/en/docs/trazas-distribuidas-opentelemetry): How to follow a request across services with traces, which data makes each span useful, and how to sample and govern telemetry with OpenTelemetry.
- [Infrastructure as code and GitOps](https://sazardev.github.io/software-architecture/en/docs/infraestructura-como-codigo-gitops): Reviewable infrastructure as code: remote state with locking, drift, versioned modules, least-privilege appliers and GitOps versus a push-based pipeline.

## Trends — Languages, platforms and industry shifts worth understanding before you decide.

- [Programming languages in the AI era](https://sazardev.github.io/software-architecture/en/docs/lenguajes-era-ia): A guide for architects: the role of Python, TypeScript, Rust, Go, Mojo and Zig in the AI era, and how to choose between them.
- [Architecture of LLM and agent applications](https://sazardev.github.io/software-architecture/en/docs/arquitectura-agentes-llm): A guide for architects: when to use workflows or agents, which components an LLM application needs, how to secure it and which trade-offs to accept.
- [Data architecture: lakehouse and data mesh](https://sazardev.github.io/software-architecture/en/docs/arquitectura-de-datos-lakehouse): When a data warehouse is enough, when an open-table lakehouse pays off, and when a data mesh makes sense as an organizational model.
- [RAG in production and continuous evaluation](https://sazardev.github.io/software-architecture/en/docs/rag-y-evaluacion-continua): How to take a RAG system to production: indexing, retrieval and generation as a measurable chain, with metrics per stage and continuous evaluation.
- [Inference cost: model, cache and deployment](https://sazardev.github.io/software-architecture/en/docs/costo-de-inferencia): How to lower the cost per request of an LLM system: choose the smallest model that works, use caching with judgement and decide where inference runs.
- [Sustainable software: footprint as an attribute](https://sazardev.github.io/software-architecture/en/docs/software-sostenible-carbono): How to treat software carbon footprint as a quality attribute: what to measure, where it comes from and how to choose region, timing and compute with judgement.
- [MLOps: taking a model to production](https://sazardev.github.io/software-architecture/en/docs/mlops-modelo-a-produccion): How to version data, code and models separately, deploy with shadow traffic and canaries, watch for drift, and decide when to retrain or retire a model.
- [Edge and CDN: what to run at the edge](https://sazardev.github.io/software-architecture/en/docs/edge-computing-cdn): What a CDN is good at, what can run at the edge, how latency and caching are split, and when moving logic closer to users does not pay off.
- [MCP and A2A: connecting tools and agents](https://sazardev.github.io/software-architecture/en/docs/mcp-y-a2a-integracion-de-herramientas): What MCP and A2A standardize, what you gain and pay when adopting them, and when to expose a tool via MCP instead of a plain API.
- [Context engineering and agent memory](https://sazardev.github.io/software-architecture/en/docs/context-engineering-y-memoria-de-agentes): How to treat an agent's context as a scarce resource: what enters the window, when to compact, what to store as memory, and how to measure that it works.
- [Agents that use interfaces: browser and desktop](https://sazardev.github.io/software-architecture/en/docs/agentes-que-usan-interfaces): When an agent should drive a graphical interface instead of an API, what risks the page adds, and how to contain them with sandboxes, approvals and traces.
- [Small models, on-device and data sovereignty](https://sazardev.github.io/software-architecture/en/docs/modelos-pequenos-on-device-soberania): When a small model on the device or in your own infrastructure beats a frontier API: latency, privacy, cost, sovereignty and what you give up.
- [Data for AI: quality, synthetic data and licensing](https://sazardev.github.io/software-architecture/en/docs/calidad-datos-para-ia): Data quality for models and RAG, synthetic data with its risks, and the licensing and consent framework that changes with jurisdiction.
- [Architecture with AI: what to bet on, what to watch](https://sazardev.github.io/software-architecture/en/docs/futuro-arquitectura-con-ia): A forward look at 2027 to decide today: verified trends, labeled hypotheses, review signals and reversible decisions.

## Cloud — Masterclass for architects: services, deployment models, hybrid, vendor dependency, cost and resilience in the cloud.

- [Cloud services for architects](https://sazardev.github.io/software-architecture/en/docs/servicios-nube-para-arquitectos): The service model as a contract of responsibilities: IaaS, CaaS, PaaS, FaaS and SaaS, the key service categories, and how to choose managed or self-run.
- [Deployment models: public, private, hybrid](https://sazardev.github.io/software-architecture/en/docs/modelos-de-despliegue-nube): Public, private, community and hybrid cloud as NIST defines them: what changes in control, data and cost, and how to choose a model per workload.
- [Hybrid cloud in detail](https://sazardev.github.io/software-architecture/en/docs/nube-hibrida-en-detalle): Patterns, redundant connectivity, federated identity, consistent deployment, and what must keep running when the link to the cloud goes down.
- [Locked in to one vendor: lock-in and exit plan](https://sazardev.github.io/software-architecture/en/docs/casado-a-un-proveedor): Types of cloud lock-in, how to estimate your exit cost, portability layer by layer, and how to document an exit plan you have actually tested.
- [Multicloud: when it makes sense](https://sazardev.github.io/software-architecture/en/docs/multinube-cuando-tiene-sentido): What multicloud is and how it differs from hybrid, which reasons hold up and which fail, its hidden costs, useful patterns and a decision framework.
- [Serverless and managed compute](https://sazardev.github.io/software-architecture/en/docs/serverless-y-computacion-gestionada): From control to abstraction: the function execution model, cold starts, state, retries, per-invocation cost and coupling to your cloud provider.
- [Cloud networking, identity and security](https://sazardev.github.io/software-architecture/en/docs/redes-identidad-seguridad-nube): Virtual networks, private endpoints, workload identity, least privilege, secrets, keys and logging: how to protect a workload running in the cloud.
- [Regions, zones and disaster recovery](https://sazardev.github.io/software-architecture/en/docs/regiones-zonas-y-recuperacion): Zones and regions as failure domains, synchronous and asynchronous replication, RTO and RPO, the four recovery strategies and how to actually test them.
- [FinOps: cost as an architecture attribute](https://sazardev.github.io/software-architecture/en/docs/finops-costo-como-atributo): How to treat cloud cost as a quality attribute: pricing models, unit economics, tagging, hidden costs and governance with FinOps.
- [What it would cost to leave your cloud](https://sazardev.github.io/software-architecture/en/docs/salida-de-la-nube): Exit cost from a cloud provider is not evenly distributed: data usually weighs more than the API. How to estimate it and why you should test the plan.
- [Authorization at scale: RBAC, ABAC and ReBAC](https://sazardev.github.io/software-architecture/en/docs/autorizacion-rbac-abac-rebac): When to decide access with roles, attributes or relationships, and how to avoid duplicating access rules across every service.
- [Cloud migration: the six Rs with judgement](https://sazardev.github.io/software-architecture/en/docs/migracion-nube-6r): Rehost, replatform, refactor, repurchase, retire and retain: choosing the cloud migration strategy per application, with judgement.
- [Sessions, tokens and SSO: what to choose and why](https://sazardev.github.io/software-architecture/en/docs/sesiones-tokens-sso): Server-side sessions versus self-contained tokens, expiry and rotation, revocation, SSO on top of OAuth 2.0, and where to keep tokens in the browser.
- [Cost per team and feature: tagging and alerts](https://sazardev.github.io/software-architecture/en/docs/costes-por-equipo-y-funcionalidad): How to attribute cloud spend to teams and features: mandatory tags, shared-cost allocation and budget alerts that fire before the limit.
- [Kubernetes: when yes and when no](https://sazardev.github.io/software-architecture/en/docs/kubernetes-cuando-si-cuando-no): What Kubernetes actually solves, what operational cost it brings, and when a managed service, a PaaS or a well-run VM is the cheaper decision.

## Decisions, processes and AI — Frameworks to decide, present ideas, improve flows and programs, and keep AI under control in business and engineering work.

- [Prioritization frameworks: RICE, WSJF, ICE](https://sazardev.github.io/software-architecture/en/docs/marcos-de-priorizacion): How to order a backlog with RICE, ICE and WSJF: formulas, cost of delay, a worked example with five initiatives and the traps of false precision.
- [Strategic decision frameworks: Cynefin and Wardley maps](https://sazardev.github.io/software-architecture/en/docs/marcos-de-decision-estrategica): Use Cynefin to tell what kind of problem you face, and Wardley maps to decide what to build, buy or rent based on how far each component has evolved.
- [Presenting ideas and proposals that get approved](https://sazardev.github.io/software-architecture/en/docs/presentar-ideas-y-propuestas): How to write a technical or business proposal that gets understood and decided: conclusion first, options with criteria, risks and the cost of inaction.
- [Value stream and bottlenecks](https://sazardev.github.io/software-architecture/en/docs/flujo-de-valor-y-cuellos-de-botella): Value stream mapping, wait time versus process time, the theory of constraints, Little’s law and WIP limits to shorten delivery.
- [Continuous improvement and experiments](https://sazardev.github.io/software-architecture/en/docs/mejora-continua-y-experimentos): The PDSA cycle, kaizen and the improvement kata; how to design experiments with a hypothesis, guardrails and a stopping rule, and retros that change things.
- [Measuring decisions: OKRs, KPIs and guardrail metrics](https://sazardev.github.io/software-architecture/en/docs/medir-decisiones-okr-kpi): How to measure in order to decide: health KPIs, OKRs with key results, guardrail metrics against side effects and thresholds that trigger a decision.
- [AI for decisions: research, scenarios and pre-mortems](https://sazardev.github.io/software-architecture/en/docs/ia-para-decidir-negocio): How to use a language model to improve a business decision without handing it over: what to ask, where it fails, how to verify, and a guided pre-mortem.
- [Controlling AI: governance, autonomy and evaluation](https://sazardev.github.io/software-architecture/en/docs/controlar-la-ia-gobierno-y-autonomia): How much autonomy to give an AI system, where to require human approval, how to evaluate it continuously, and what NIST AI RMF, the EU AI Act and OWASP ask.
- [Designing workflows with AI agents](https://sazardev.github.io/software-architecture/en/docs/disenar-flujos-con-agentes): Which workflow steps belong in code and which in an agent, where to validate, approve and stop, and how to trace state, cost and idempotency per step.
- [The architect's work with agents: roles and productivity](https://sazardev.github.io/software-architecture/en/docs/trabajo-del-arquitecto-con-agentes): What changes in the architect role when teams work with AI agents: specifying, delegating with judgment, reviewing, and measuring flow honestly.
- [Tools to decide and document](https://sazardev.github.io/software-architecture/en/docs/herramientas-para-decidir-y-documentar): A framework for choosing decision and documentation software by integration, data export, exit cost, permissions and search, not by hype.
- [Internal libraries: extract, version or copy](https://sazardev.github.io/software-architecture/en/docs/librerias-internas-sin-infierno-versiones): When to turn shared code into an internal library, when copying is better, and how to version and retire it so that every change is not an incident.
- [Systems thinking and biases in decisions](https://sazardev.github.io/software-architecture/en/docs/pensamiento-sistemico-y-sesgos): Reinforcing and balancing loops, delays, fixes that make the problem worse, and the biases that distort decisions, with techniques to counter them.
- [Your org chart draws your architecture](https://sazardev.github.io/software-architecture/en/docs/organigrama-y-sistema): Conway's law in practice: how your organization's communication ends up in the system, and how the inverse Conway maneuver lets you design teams on purpose.
- [Decisions have a lifecycle](https://sazardev.github.io/software-architecture/en/docs/adr-ciclo-de-vida): An ADR is proposed, accepted and, over time, deprecated or superseded. How to keep a decision log without erasing its history.
- [How much autonomy to give an agent](https://sazardev.github.io/software-architecture/en/docs/autonomia-de-la-ia): Autonomy levels for AI systems: which steps stay deterministic, where human approval belongs, how to stop safely and how to trace cost and idempotency.
- [Internal platform: when to build an IDP](https://sazardev.github.io/software-architecture/en/docs/plataforma-interna-idp): What an internal developer platform is, when it pays for its cost, and how to run it as a product with measurable golden paths.
- [Monorepo or polyrepo: the decision and its costs](https://sazardev.github.io/software-architecture/en/docs/monorepo-o-polirepo): When a monorepo pays off, when a polyrepo is better, and which hidden costs each option brings, with explicit criteria for the decision.
- [RFCs and architecture reviews without bureaucracy](https://sazardev.github.io/software-architecture/en/docs/rfc-y-revisiones-de-arquitectura): How to take technical proposals through review with timeboxes, clear decision criteria and an ADR record, without turning every change into a committee.
- [Service catalogue and API governance](https://sazardev.github.io/software-architecture/en/docs/catalogo-servicios-gobierno-apis): A service catalogue with an owner, a status and a contract per service, light governance rules and an API lifecycle with deprecation and retirement dates.
- [Documenting architecture so someone uses it](https://sazardev.github.io/software-architecture/en/docs/documentar-arquitectura-util): What architecture documentation must answer, how to pick its level of detail, keep it next to the code and measure whether anyone uses it.

_125 artículos en en. Generado desde https://sazardev.github.io/software-architecture/en._