# The tension face

> 395 records.

This index as JSON: https://banes-lab.com/json/api/records/tension

## Entries

- [Assessment / Time Cost](https://banes-lab.com/records/tension/assessment-time-cost.md): "assessment" (evolution-principles layer) is traded against "Time Cost" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Time Cost" and choosing an explicit operating point.
- [Architecture Review / Delivery Speed](https://banes-lab.com/records/tension/architecture-review-delivery-speed.md): "architecture-review" (evolution-principles layer) is traded against "Delivery Speed" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Delivery Speed" and choosing an explicit operating point.
- [Design Review / Iteration Speed](https://banes-lab.com/records/tension/design-review-iteration-speed.md): "design-review" (evolution-principles layer) is traded against "Iteration Speed" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Iteration Speed" and choosing an explicit operating point.
- [Code Review / Throughput](https://banes-lab.com/records/tension/code-review-throughput.md): "code-review" (evolution-principles layer) is traded against "Throughput" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Throughput" and choosing an explicit operating point.
- [Impact Analysis / Analysis Overhead](https://banes-lab.com/records/tension/analysis-overhead-impact-analysis.md): "impact-analysis" (evolution-principles layer) is traded against "Analysis Overhead" (evolution-principles layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Analysis Overhead" and choosing an explicit operating point.
- [Gap Analysis / Time Cost](https://banes-lab.com/records/tension/gap-analysis-time-cost.md): "gap-analysis" (evolution-principles layer) is traded against "Time Cost" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Time Cost" and choosing an explicit operating point.
- [Fitness Functions / Rule Maintenance](https://banes-lab.com/records/tension/fitness-functions-rule-maintenance.md): "fitness-functions" (evolution-principles layer) is traded against "Rule Maintenance" (evolution-principles layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Rule Maintenance" and choosing an explicit operating point.
- [Quality Attributes / Competing Attributes](https://banes-lab.com/records/tension/competing-attributes-quality-attributes.md): "quality-attributes" (performance-core layer) is traded against "Competing Attributes" (evolution-principles layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Competing Attributes" and choosing an explicit operating point.
- [Architecture Decision Records (ADR) / Documentation Maintenance](https://banes-lab.com/records/tension/architecture-decision-records-adr-documentation-maintenance.md): "architecture-decision-records" (evolution-principles layer) is traded against "Documentation Maintenance" (evolution-principles layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Documentation Maintenance" and choosing an explicit operating point.
- [Evolutionary Architecture / Governance Discipline](https://banes-lab.com/records/tension/evolutionary-architecture-governance-discipline.md): "evolutionary-architecture" (evolution-principles layer) is traded against "Governance Discipline" (evolution-principles layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Governance Discipline" and choosing an explicit operating point.
- [Minimum Viable Architecture / Future Scalability](https://banes-lab.com/records/tension/future-scalability-minimum-viable-architecture.md): "minimum-viable-architecture" (evolution-principles layer) is traded against "Future Scalability" (evolution-principles layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Future Scalability" and choosing an explicit operating point.
- [Greenfield Development / Unknown Requirements](https://banes-lab.com/records/tension/greenfield-development-unknown-requirements.md): "greenfield-development" (evolution-principles layer) is traded against "Unknown Requirements" (evolution-principles layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Unknown Requirements" and choosing an explicit operating point.
- [Greenfield Development / Legacy Constraints](https://banes-lab.com/records/tension/greenfield-development-legacy-constraints.md): "greenfield-development" (evolution-principles layer) is traded against "Legacy Constraints" (evolution-principles layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Legacy Constraints" and choosing an explicit operating point.
- [First-Principles Design / Reuse of Established Patterns](https://banes-lab.com/records/tension/first-principles-design-reuse-of-established-patterns.md): "first-principles-design" (evolution-principles layer) is traded against "Reuse of Established Patterns" (evolution-principles layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Reuse of Established Patterns" and choosing an explicit operating point.
- [Reference Architecture / Team Autonomy](https://banes-lab.com/records/tension/reference-architecture-team-autonomy.md): "reference-architecture" (evolution-principles layer) is traded against "Team Autonomy" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Team Autonomy" and choosing an explicit operating point.
- [Pattern Consistency / Local Optimization](https://banes-lab.com/records/tension/local-optimization-pattern-consistency.md): "pattern-consistency" (evolution-principles layer) is traded against "Local Optimization" (evolution-principles layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Local Optimization" and choosing an explicit operating point.
- [Architectural Consistency / Local Autonomy](https://banes-lab.com/records/tension/architectural-consistency-local-autonomy.md): "architectural-consistency" (evolution-principles layer) is traded against "Local Autonomy" (evolution-principles layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Local Autonomy" and choosing an explicit operating point.
- [Standardization / Innovation/Autonomy](https://banes-lab.com/records/tension/innovation-autonomy-standardization.md): "standardization" (evolution-principles layer) is traded against "Innovation/Autonomy" (evolution-principles layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Innovation/Autonomy" and choosing an explicit operating point.
- [Strategy Pattern / Class Count](https://banes-lab.com/records/tension/class-count-strategy-pattern.md): "strategy-pattern" (design-patterns-core layer) is traded against "Class Count" (design-patterns-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Class Count" and choosing an explicit operating point.
- [Template Method Pattern / Inheritance Coupling](https://banes-lab.com/records/tension/inheritance-coupling-template-method-pattern.md): "template-method-pattern" (design-patterns-core layer) is traded against "Inheritance Coupling" (design-patterns-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Inheritance Coupling" and choosing an explicit operating point.
- [Observer Pattern / Ordering](https://banes-lab.com/records/tension/observer-pattern-ordering.md): "observer-pattern" (design-patterns-core layer) is traded against "Ordering" (causality-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Ordering" and choosing an explicit operating point.
- [Observer Pattern / Debuggability](https://banes-lab.com/records/tension/debuggability-observer-pattern.md): "observer-pattern" (design-patterns-core layer) is traded against "Debuggability" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Debuggability" and choosing an explicit operating point.
- [Mediator Pattern / Mediator God Object](https://banes-lab.com/records/tension/mediator-god-object-mediator-pattern.md): "mediator-pattern" (design-patterns-core layer) is traded against "Mediator God Object" (design-patterns-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Mediator God Object" and choosing an explicit operating point.
- [Command Pattern / Simplicity](https://banes-lab.com/records/tension/command-pattern-simplicity.md): "command-pattern" (design-patterns-core layer) is traded against "Simplicity" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Simplicity" and choosing an explicit operating point.
- [State Pattern / Class Proliferation](https://banes-lab.com/records/tension/class-proliferation-state-pattern.md): "state-pattern" (design-patterns-core layer) is traded against "Class Proliferation" (design-patterns-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Class Proliferation" and choosing an explicit operating point.
- [Chain of Responsibility Pattern / Traceability](https://banes-lab.com/records/tension/chain-of-responsibility-pattern-traceability.md): "chain-of-responsibility-pattern" (design-patterns-core layer) is traded against "Traceability" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Traceability" and choosing an explicit operating point.
- [Iterator Pattern / Simplicity](https://banes-lab.com/records/tension/iterator-pattern-simplicity.md): "iterator-pattern" (design-patterns-core layer) is traded against "Simplicity" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Simplicity" and choosing an explicit operating point.
- [Visitor Pattern / Element Stability](https://banes-lab.com/records/tension/element-stability-visitor-pattern.md): "visitor-pattern" (design-patterns-core layer) is traded against "Element Stability" (design-patterns-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Element Stability" and choosing an explicit operating point.
- [Memento Pattern / Memory Footprint](https://banes-lab.com/records/tension/memento-pattern-memory-footprint.md): "memento-pattern" (design-patterns-core layer) is traded against "Memory Footprint" (design-patterns-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Memory Footprint" and choosing an explicit operating point.
- [Null Object Pattern / Silent No-Op Risk](https://banes-lab.com/records/tension/null-object-pattern-silent-no-op-risk.md): "null-object-pattern" (design-patterns-core layer) is traded against "Silent No-Op Risk" (design-patterns-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Silent No-Op Risk" and choosing an explicit operating point.
- [Finite State Machine / State Explosion](https://banes-lab.com/records/tension/finite-state-machine-state-explosion.md): "finite-state-machine" (design-patterns-core layer) is traded against "State Explosion" (design-patterns-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "State Explosion" and choosing an explicit operating point.
- [Statecharts / Tooling Complexity](https://banes-lab.com/records/tension/statecharts-tooling-complexity.md): "statecharts" (design-patterns-core layer) is traded against "Tooling Complexity" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Tooling Complexity" and choosing an explicit operating point.
- [Causality / Parallelism](https://banes-lab.com/records/tension/causality-parallelism.md): "causality" (causality-core layer) is traded against "Parallelism" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Parallelism" and choosing an explicit operating point.
- [Causal Consistency / Latency/Availability](https://banes-lab.com/records/tension/causal-consistency-latency-availability.md): "causal-consistency" (causality-core layer) is traded against "Latency/Availability" (causality-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Latency/Availability" and choosing an explicit operating point.
- [Happens-Before Relationship / Parallel Execution](https://banes-lab.com/records/tension/happens-before-relationship-parallel-execution.md): "happens-before-relationship" (causality-core layer) is traded against "Parallel Execution" (causality-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Parallel Execution" and choosing an explicit operating point.
- [Event Ordering / Throughput](https://banes-lab.com/records/tension/event-ordering-throughput.md): "event-ordering" (causality-core layer) is traded against "Throughput" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Throughput" and choosing an explicit operating point.
- [Causal Dependency / Graph Complexity](https://banes-lab.com/records/tension/causal-dependency-graph-complexity.md): "causal-dependency" (causality-core layer) is traded against "Graph Complexity" (causality-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Graph Complexity" and choosing an explicit operating point.
- [Dependency Graph / Dynamic Loading](https://banes-lab.com/records/tension/dependency-graph-dynamic-loading.md): "dependency-graph" (causality-core layer) is traded against "Dynamic Loading" (causality-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Dynamic Loading" and choosing an explicit operating point.
- [Directed Acyclic Graph (DAG) / Bidirectional Collaboration](https://banes-lab.com/records/tension/bidirectional-collaboration-directed-acyclic-graph-dag.md): "directed-acyclic-graph" (causality-core layer) is traded against "Bidirectional Collaboration" (causality-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Bidirectional Collaboration" and choosing an explicit operating point.
- [Vector Clocks / Metadata Size](https://banes-lab.com/records/tension/metadata-size-vector-clocks.md): "vector-clocks" (causality-core layer) is traded against "Metadata Size" (causality-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Metadata Size" and choosing an explicit operating point.
- [Lamport Clocks / No Concurrent Causality Distinction](https://banes-lab.com/records/tension/lamport-clocks-no-concurrent-causality-distinction.md): "lamport-clocks" (causality-core layer) is traded against "No Concurrent Causality Distinction" (causality-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "No Concurrent Causality Distinction" and choosing an explicit operating point.
- [Hybrid Logical Clocks / Clock Skew](https://banes-lab.com/records/tension/clock-skew-hybrid-logical-clocks.md): "hybrid-logical-clocks" (causality-core layer) is traded against "Clock Skew" (causality-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Clock Skew" and choosing an explicit operating point.
- [CRDTs / Metadata Overhead](https://banes-lab.com/records/tension/crdts-metadata-overhead.md): "crdts" (causality-core layer) is traded against "Metadata Overhead" (causality-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Metadata Overhead" and choosing an explicit operating point.
- [CRDTs / Last-Write-Wins Overwrite](https://banes-lab.com/records/tension/crdts-last-write-wins-overwrite.md): "crdts" (causality-core layer) is traded against "Last-Write-Wins Overwrite" (causality-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Last-Write-Wins Overwrite" and choosing an explicit operating point.
- [Total-Order Broadcast / Latency](https://banes-lab.com/records/tension/latency-total-order-broadcast.md): "total-order-broadcast" (causality-core layer) is traded against "Latency" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Latency" and choosing an explicit operating point.
- [CAP Theorem / Latency](https://banes-lab.com/records/tension/cap-theorem-latency.md): "cap-theorem" (causality-core layer) is traded against "Latency" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Latency" and choosing an explicit operating point.
- [PACELC Theorem / Throughput](https://banes-lab.com/records/tension/pacelc-theorem-throughput.md): "pacelc-theorem" (causality-core layer) is traded against "Throughput" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Throughput" and choosing an explicit operating point.
- [Ports and Adapters Architecture / Boilerplate](https://banes-lab.com/records/tension/boilerplate-ports-and-adapters-architecture.md): "ports-and-adapters-architecture" (structural-core layer) is traded against "Boilerplate" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Boilerplate" and choosing an explicit operating point.
- [Hexagonal Architecture / Initial Complexity](https://banes-lab.com/records/tension/hexagonal-architecture-initial-complexity.md): "hexagonal-architecture" (structural-core layer) is traded against "Initial Complexity" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Initial Complexity" and choosing an explicit operating point.
- [Clean Architecture / Boilerplate](https://banes-lab.com/records/tension/boilerplate-clean-architecture.md): "clean-architecture" (structural-core layer) is traded against "Boilerplate" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Boilerplate" and choosing an explicit operating point.
- [Layered Architecture / Anemic Layers](https://banes-lab.com/records/tension/anemic-layers-layered-architecture.md): "layered-architecture" (structural-core layer) is traded against "Anemic Layers" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Anemic Layers" and choosing an explicit operating point.
- [Component-Based Architecture / Integration Overhead](https://banes-lab.com/records/tension/component-based-architecture-integration-overhead.md): "component-based-architecture" (structural-core layer) is traded against "Integration Overhead" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Integration Overhead" and choosing an explicit operating point.
- [Package by Feature / Shared Technical Concerns](https://banes-lab.com/records/tension/package-by-feature-shared-technical-concerns.md): "package-by-feature" (structural-core layer) is traded against "Shared Technical Concerns" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Shared Technical Concerns" and choosing an explicit operating point.
- [Microservices / Operational Complexity](https://banes-lab.com/records/tension/microservices-operational-complexity.md): "microservices" (structural-core layer) is traded against "Operational Complexity" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Operational Complexity" and choosing an explicit operating point.
- [Microservices / Consistency](https://banes-lab.com/records/tension/consistency-microservices.md): "microservices" (structural-core layer) is traded against "Consistency" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Consistency" and choosing an explicit operating point.
- [Monolith Architecture / Team Autonomy](https://banes-lab.com/records/tension/monolith-architecture-team-autonomy.md): "monolith-architecture" (structural-core layer) is traded against "Team Autonomy" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Team Autonomy" and choosing an explicit operating point.
- [Monolith Architecture / Independent Scaling](https://banes-lab.com/records/tension/independent-scaling-monolith-architecture.md): "monolith-architecture" (structural-core layer) is traded against "Independent Scaling" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Independent Scaling" and choosing an explicit operating point.
- [Pipes and Filters / End-to-End Traceability](https://banes-lab.com/records/tension/end-to-end-traceability-pipes-and-filters.md): "pipes-and-filters" (structural-core layer) is traded against "End-to-End Traceability" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "End-to-End Traceability" and choosing an explicit operating point.
- [Service-Oriented Architecture / Operational Overhead](https://banes-lab.com/records/tension/operational-overhead-service-oriented-architecture.md): "service-oriented-architecture" (structural-core layer) is traded against "Operational Overhead" (resource-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Operational Overhead" and choosing an explicit operating point.
- [Space-Based Architecture / Consistency](https://banes-lab.com/records/tension/consistency-space-based-architecture.md): "space-based-architecture" (structural-core layer) is traded against "Consistency" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Consistency" and choosing an explicit operating point.
- [Design by Contract / Development Speed](https://banes-lab.com/records/tension/design-by-contract-development-speed.md): "design-by-contract" (contracts-core layer) is traded against "Development Speed" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Development Speed" and choosing an explicit operating point.
- [Explicit Contracts / Rapid Prototyping](https://banes-lab.com/records/tension/explicit-contracts-rapid-prototyping.md): "explicit-contracts" (contracts-core layer) is traded against "Rapid Prototyping" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Rapid Prototyping" and choosing an explicit operating point.
- [Stable Interfaces / Evolution Speed](https://banes-lab.com/records/tension/evolution-speed-stable-interfaces.md): "stable-interfaces" (contracts-core layer) is traded against "Evolution Speed" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Evolution Speed" and choosing an explicit operating point.
- [Interface-Based Design / Interface Overuse](https://banes-lab.com/records/tension/interface-based-design-interface-overuse.md): "interface-based-design" (contracts-core layer) is traded against "Interface Overuse" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Interface Overuse" and choosing an explicit operating point.
- [Contract-First Design / Iteration Speed](https://banes-lab.com/records/tension/contract-first-design-iteration-speed.md): "contract-first-design" (contracts-core layer) is traded against "Iteration Speed" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Iteration Speed" and choosing an explicit operating point.
- [API Contract / Evolution](https://banes-lab.com/records/tension/api-contract-evolution.md): "api-contract" (contracts-core layer) is traded against "Evolution" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Evolution" and choosing an explicit operating point.
- [Service Contract / Distributed Evolution](https://banes-lab.com/records/tension/distributed-evolution-service-contract.md): "service-contract" (contracts-core layer) is traded against "Distributed Evolution" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Distributed Evolution" and choosing an explicit operating point.
- [Data Contract / Flexible Ingestion](https://banes-lab.com/records/tension/data-contract-flexible-ingestion.md): "data-contract" (contracts-core layer) is traded against "Flexible Ingestion" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Flexible Ingestion" and choosing an explicit operating point.
- [Schema Contract / Schema Flexibility](https://banes-lab.com/records/tension/schema-contract-schema-flexibility.md): "schema-contract" (contracts-core layer) is traded against "Schema Flexibility" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Schema Flexibility" and choosing an explicit operating point.
- [Semantic Contracts / Cross-Domain Translation](https://banes-lab.com/records/tension/cross-domain-translation-semantic-contracts.md): "semantic-contracts" (contracts-core layer) is traded against "Cross-Domain Translation" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Cross-Domain Translation" and choosing an explicit operating point.
- [Preconditions / Permissive APIs](https://banes-lab.com/records/tension/permissive-apis-preconditions.md): "preconditions" (contracts-core layer) is traded against "Permissive APIs" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Permissive APIs" and choosing an explicit operating point.
- [Postconditions / Runtime Cost](https://banes-lab.com/records/tension/postconditions-runtime-cost.md): "postconditions" (contracts-core layer) is traded against "Runtime Cost" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Runtime Cost" and choosing an explicit operating point.
- [Invariants / Flexibility](https://banes-lab.com/records/tension/flexibility-invariants.md): "invariants" (contracts-core layer) is traded against "Flexibility" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Flexibility" and choosing an explicit operating point.
- [Backward Compatibility / Cleanup / Simplification](https://banes-lab.com/records/tension/backward-compatibility-cleanup-simplification.md): "backward-compatibility" (contracts-core layer) is traded against "Cleanup / Simplification" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Cleanup / Simplification" and choosing an explicit operating point.
- [Forward Compatibility / Strong Validation](https://banes-lab.com/records/tension/forward-compatibility-strong-validation.md): "forward-compatibility" (contracts-core layer) is traded against "Strong Validation" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Strong Validation" and choosing an explicit operating point.
- [Versioning / Version Sprawl](https://banes-lab.com/records/tension/version-sprawl-versioning.md): "versioning" (contracts-core layer) is traded against "Version Sprawl" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Version Sprawl" and choosing an explicit operating point.
- [Protocol Compatibility / Protocol Optimization](https://banes-lab.com/records/tension/protocol-compatibility-protocol-optimization.md): "protocol-compatibility" (contracts-core layer) is traded against "Protocol Optimization" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Protocol Optimization" and choosing an explicit operating point.
- [Interoperability / Domain-Specific Optimization](https://banes-lab.com/records/tension/domain-specific-optimization-interoperability.md): "interoperability" (contracts-core layer) is traded against "Domain-Specific Optimization" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Domain-Specific Optimization" and choosing an explicit operating point.
- [Uniform Interface / Specialized Endpoints](https://banes-lab.com/records/tension/specialized-endpoints-uniform-interface.md): "uniform-interface" (contracts-core layer) is traded against "Specialized Endpoints" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Specialized Endpoints" and choosing an explicit operating point.
- [Consumer-Driven Contracts / Provider Autonomy](https://banes-lab.com/records/tension/consumer-driven-contracts-provider-autonomy.md): "consumer-driven-contracts" (contracts-core layer) is traded against "Provider Autonomy" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Provider Autonomy" and choosing an explicit operating point.
- [Control Plane / Availability](https://banes-lab.com/records/tension/availability-control-plane.md): "control-plane" (execution-core layer) is traded against "Availability" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Availability" and choosing an explicit operating point.
- [Orchestration / Centralized Coordinator Coupling](https://banes-lab.com/records/tension/centralized-coordinator-coupling-orchestration.md): "orchestration" (execution-core layer) is traded against "Centralized Coordinator Coupling" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Centralized Coordinator Coupling" and choosing an explicit operating point.
- [Centralized Configuration / Central Dependency Risk](https://banes-lab.com/records/tension/central-dependency-risk-centralized-configuration.md): "centralized-configuration" (execution-core layer) is traded against "Central Dependency Risk" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Central Dependency Risk" and choosing an explicit operating point.
- [Centralized Authentication / Identity Provider Availability](https://banes-lab.com/records/tension/centralized-authentication-identity-provider-availability.md): "centralized-authentication" (execution-core layer) is traded against "Identity Provider Availability" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Identity Provider Availability" and choosing an explicit operating point.
- [Centralized Logging / Cost/Personal Data Exposure](https://banes-lab.com/records/tension/centralized-logging-cost-personal-data-exposure.md): "centralized-logging" (execution-core layer) is traded against "Cost/Personal Data Exposure" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Cost/Personal Data Exposure" and choosing an explicit operating point.
- [Decentralization / Governance](https://banes-lab.com/records/tension/decentralization-governance.md): "decentralization" governs the execution-core layer and "Governance" the security-core layer — two principles in different layers; apply each within its own layer instead of trading one off inside the other.
- [Decentralization / Consistency](https://banes-lab.com/records/tension/consistency-decentralization.md): "decentralization" (execution-core layer) is traded against "Consistency" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Consistency" and choosing an explicit operating point.
- [Leader Election / Availability](https://banes-lab.com/records/tension/availability-leader-election.md): "leader-election" (execution-core layer) is traded against "Availability" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Availability" and choosing an explicit operating point.
- [Consensus / Latency](https://banes-lab.com/records/tension/consensus-latency.md): "consensus" (execution-core layer) is traded against "Latency" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Latency" and choosing an explicit operating point.
- [Consensus / Availability](https://banes-lab.com/records/tension/availability-consensus.md): "consensus" (execution-core layer) is traded against "Availability" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Availability" and choosing an explicit operating point.
- [Choreography / Traceability](https://banes-lab.com/records/tension/choreography-traceability.md): "choreography" (execution-core layer) is traded against "Traceability" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Traceability" and choosing an explicit operating point.
- [Single Responsibility Principle (SRP) / Excessive Fragmentation](https://banes-lab.com/records/tension/excessive-fragmentation-single-responsibility-principle-srp.md): "single-responsibility" (structural-core layer) is traded against "Excessive Fragmentation" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Excessive Fragmentation" and choosing an explicit operating point.
- [Separation of Concerns / Over-Layering](https://banes-lab.com/records/tension/over-layering-separation-of-concerns.md): "separation-of-concerns" (structural-core layer) is traded against "Over-Layering" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Over-Layering" and choosing an explicit operating point.
- [Do Not Repeat Yourself (DRY) / Locality of Behavior](https://banes-lab.com/records/tension/do-not-repeat-yourself-dry-locality-of-behavior.md): Knowledge that means the same thing, such as a rule, a schema or a single source of truth, is centralized. Code that only looks alike stays local, because abstracting a coincidental similarity produces shared code with no shared meaning.
- [Do Not Repeat Yourself (DRY) / Simplicity](https://banes-lab.com/records/tension/do-not-repeat-yourself-dry-simplicity.md): "duplicate-code" (structural-core layer) is traded against "Simplicity" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Simplicity" and choosing an explicit operating point.
- [High Cohesion / Over-Specialization](https://banes-lab.com/records/tension/high-cohesion-over-specialization.md): "high-cohesion" (structural-core layer) is traded against "Over-Specialization" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Over-Specialization" and choosing an explicit operating point.
- [Low Coupling / Runtime Indirection](https://banes-lab.com/records/tension/low-coupling-runtime-indirection.md): "low-coupling" (structural-core layer) is traded against "Runtime Indirection" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Runtime Indirection" and choosing an explicit operating point.
- [Encapsulation / Debuggability](https://banes-lab.com/records/tension/debuggability-encapsulation.md): "encapsulation" (structural-core layer) is traded against "Debuggability" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Debuggability" and choosing an explicit operating point.
- [Information Hiding / Observability](https://banes-lab.com/records/tension/information-hiding-observability.md): "information-hiding" (structural-core layer) is traded against "Observability" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Observability" and choosing an explicit operating point.
- [Abstraction / Simplicity](https://banes-lab.com/records/tension/abstraction-simplicity.md): "abstraction" (structural-core layer) is traded against "Simplicity" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Simplicity" and choosing an explicit operating point.
- [Modularity / Cross-Cutting Concerns](https://banes-lab.com/records/tension/cross-cutting-concerns-modularity.md): "modularity" (structural-core layer) is traded against "Cross-Cutting Concerns" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Cross-Cutting Concerns" and choosing an explicit operating point.
- [Composability / Performance Overhead](https://banes-lab.com/records/tension/composability-performance-overhead.md): "composability" (structural-core layer) is traded against "Performance Overhead" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Performance Overhead" and choosing an explicit operating point.
- [Composition Over Inheritance / Simplicity for Trivial Reuse](https://banes-lab.com/records/tension/composition-over-inheritance-simplicity-for-trivial-reuse.md): "composition-over-inheritance" (structural-core layer) is traded against "Simplicity for Trivial Reuse" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Simplicity for Trivial Reuse" and choosing an explicit operating point.
- [Reusability / YAGNI](https://banes-lab.com/records/tension/reusability-yagni.md): "reusability" (structural-core layer) is traded against "YAGNI" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "YAGNI" and choosing an explicit operating point.
- [Reusability / Over-Generalization](https://banes-lab.com/records/tension/over-generalization-reusability.md): "reusability" (structural-core layer) is traded against "Over-Generalization" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Over-Generalization" and choosing an explicit operating point.
- [Replaceability / Deep Optimization](https://banes-lab.com/records/tension/deep-optimization-replaceability.md): "replaceability" (structural-core layer) is traded against "Deep Optimization" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Deep Optimization" and choosing an explicit operating point.
- [Interchangeability / Specialized Optimization](https://banes-lab.com/records/tension/interchangeability-specialized-optimization.md): "interchangeability" (structural-core layer) is traded against "Specialized Optimization" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Specialized Optimization" and choosing an explicit operating point.
- [Independence / Coordination Cost](https://banes-lab.com/records/tension/coordination-cost-independence.md): "independence" (structural-core layer) is traded against "Coordination Cost" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Coordination Cost" and choosing an explicit operating point.
- [Autonomy / Governance](https://banes-lab.com/records/tension/autonomy-governance.md): "autonomy" governs the structural-core layer and "Governance" the security-core layer — two principles in different layers; apply each within its own layer instead of trading one off inside the other.
- [Autonomy / Standardization](https://banes-lab.com/records/tension/autonomy-standardization.md): "autonomy" governs the structural-core layer and "Standardization" the evolution-principles layer — two principles in different layers; apply each within its own layer instead of trading one off inside the other.
- [Determinism / Runtime Adaptivity](https://banes-lab.com/records/tension/determinism-runtime-adaptivity.md): "determinism" (computation-core layer) is traded against "Runtime Adaptivity" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Runtime Adaptivity" and choosing an explicit operating point.
- [Predictability / Dynamic Runtime Behavior](https://banes-lab.com/records/tension/dynamic-runtime-behavior-predictability.md): "predictability" (computation-core layer) is traded against "Dynamic Runtime Behavior" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Dynamic Runtime Behavior" and choosing an explicit operating point.
- [Referential Transparency / Stateful IO](https://banes-lab.com/records/tension/referential-transparency-stateful-io.md): "referential-transparency" (computation-core layer) is traded against "Stateful IO" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Stateful IO" and choosing an explicit operating point.
- [Pure Functions / Stateful Operations](https://banes-lab.com/records/tension/pure-functions-stateful-operations.md): "pure-functions" (computation-core layer) is traded against "Stateful Operations" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Stateful Operations" and choosing an explicit operating point.
- [Immutability / Allocation Cost](https://banes-lab.com/records/tension/allocation-cost-immutability.md): "immutability" (computation-core layer) is traded against "Allocation Cost" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Allocation Cost" and choosing an explicit operating point.
- [Reproducibility / Continuous Updates](https://banes-lab.com/records/tension/continuous-updates-reproducibility.md): "reproducibility" (computation-core layer) is traded against "Continuous Updates" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Continuous Updates" and choosing an explicit operating point.
- [Repeatability / Real-World Variability](https://banes-lab.com/records/tension/real-world-variability-repeatability.md): "repeatability" (computation-core layer) is traded against "Real-World Variability" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Real-World Variability" and choosing an explicit operating point.
- [Correctness / Delivery Speed](https://banes-lab.com/records/tension/correctness-delivery-speed.md): "correctness" (computation-core layer) is traded against "Delivery Speed" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Delivery Speed" and choosing an explicit operating point.
- [Formal Verification / Cost/Complexity](https://banes-lab.com/records/tension/cost-complexity-formal-verification.md): "formal-verification" (computation-core layer) is traded against "Cost/Complexity" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Cost/Complexity" and choosing an explicit operating point.
- [Specification-Based Testing / Spec Maintenance](https://banes-lab.com/records/tension/spec-maintenance-specification-based-testing.md): "specification-based-testing" (computation-core layer) is traded against "Spec Maintenance" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Spec Maintenance" and choosing an explicit operating point.
- [Property-Based Testing / Shrinking/Debug Complexity](https://banes-lab.com/records/tension/property-based-testing-shrinking-debug-complexity.md): "property-based-testing" (computation-core layer) is traded against "Shrinking/Debug Complexity" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Shrinking/Debug Complexity" and choosing an explicit operating point.
- [Static Analysis / False Positives](https://banes-lab.com/records/tension/false-positives-static-analysis.md): "static-analysis" (computation-core layer) is traded against "False Positives" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "False Positives" and choosing an explicit operating point.
- [Testability / Encapsulation Extremes](https://banes-lab.com/records/tension/encapsulation-extremes-testability.md): "testability" (computation-core layer) is traded against "Encapsulation Extremes" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Encapsulation Extremes" and choosing an explicit operating point.
- [Validation / Iteration Speed](https://banes-lab.com/records/tension/iteration-speed-validation.md): "validation" (computation-core layer) is traded against "Iteration Speed" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Iteration Speed" and choosing an explicit operating point.
- [Verification / Cost](https://banes-lab.com/records/tension/cost-verification.md): "verification" (computation-core layer) is traded against "Cost" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Cost" and choosing an explicit operating point.
- [Factory Pattern / Simplicity](https://banes-lab.com/records/tension/factory-pattern-simplicity.md): "factory-pattern" (design-patterns-core layer) is traded against "Simplicity" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Simplicity" and choosing an explicit operating point.
- [Factory Method Pattern / Inheritance Complexity](https://banes-lab.com/records/tension/factory-method-pattern-inheritance-complexity.md): "factory-method-pattern" (design-patterns-core layer) is traded against "Inheritance Complexity" (design-patterns-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Inheritance Complexity" and choosing an explicit operating point.
- [Abstract Factory Pattern / Boilerplate](https://banes-lab.com/records/tension/abstract-factory-pattern-boilerplate.md): "abstract-factory-pattern" (design-patterns-core layer) is traded against "Boilerplate" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Boilerplate" and choosing an explicit operating point.
- [Builder Pattern / Boilerplate](https://banes-lab.com/records/tension/boilerplate-builder-pattern.md): "builder-pattern" (design-patterns-core layer) is traded against "Boilerplate" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Boilerplate" and choosing an explicit operating point.
- [Prototype Pattern / Copy Semantics](https://banes-lab.com/records/tension/copy-semantics-prototype-pattern.md): "prototype-pattern" (design-patterns-core layer) is traded against "Copy Semantics" (design-patterns-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Copy Semantics" and choosing an explicit operating point.
- [Singleton Pattern / Testability](https://banes-lab.com/records/tension/singleton-pattern-testability.md): "singleton-pattern" (design-patterns-core layer) is traded against "Testability" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Testability" and choosing an explicit operating point.
- [Singleton Pattern / Dependency Injection](https://banes-lab.com/records/tension/dependency-injection-singleton-pattern.md): "singleton-pattern" (design-patterns-core layer) is traded against "Dependency Injection" (extensibility-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Dependency Injection" and choosing an explicit operating point.
- [Domain-Driven Design (DDD) / Simple CRUD](https://banes-lab.com/records/tension/domain-driven-design-ddd-simple-crud.md): "domain-driven-design" (domain-modeling layer) is traded against "Simple CRUD" (domain-modeling layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Simple CRUD" and choosing an explicit operating point.
- [Domain Model / Persistence Simplicity](https://banes-lab.com/records/tension/domain-model-persistence-simplicity.md): "domain-model" (domain-modeling layer) is traded against "Persistence Simplicity" (domain-modeling layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Persistence Simplicity" and choosing an explicit operating point.
- [Bounded Context / Cross-Context Reuse](https://banes-lab.com/records/tension/bounded-context-cross-context-reuse.md): "bounded-context" (domain-modeling layer) is traded against "Cross-Context Reuse" (domain-modeling layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Cross-Context Reuse" and choosing an explicit operating point.
- [Context Mapping / Documentation Overhead](https://banes-lab.com/records/tension/context-mapping-documentation-overhead.md): "context-mapping" (domain-modeling layer) is traded against "Documentation Overhead" (domain-modeling layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Documentation Overhead" and choosing an explicit operating point.
- [Anti-Corruption Layer / Mapping Overhead](https://banes-lab.com/records/tension/anti-corruption-layer-mapping-overhead.md): "anti-corruption-layer" (domain-modeling layer) is traded against "Mapping Overhead" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Mapping Overhead" and choosing an explicit operating point.
- [Explicit Boundaries / Cross-Cutting Concerns](https://banes-lab.com/records/tension/cross-cutting-concerns-explicit-boundaries.md): "explicit-boundaries" (domain-modeling layer) is traded against "Cross-Cutting Concerns" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Cross-Cutting Concerns" and choosing an explicit operating point.
- [Aggregate / Aggregate Size](https://banes-lab.com/records/tension/aggregate-aggregate-size.md): "aggregate" (domain-modeling layer) is traded against "Aggregate Size" (domain-modeling layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Aggregate Size" and choosing an explicit operating point.
- [Value Object / Object Count](https://banes-lab.com/records/tension/object-count-value-object.md): "value-object" (domain-modeling layer) is traded against "Object Count" (domain-modeling layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Object Count" and choosing an explicit operating point.
- [Entity / Value Object](https://banes-lab.com/records/tension/entity-value-object.md): "entity" (domain-modeling layer) is traded against "Value Object" (domain-modeling layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Value Object" and choosing an explicit operating point.
- [Domain Service / Aggregate](https://banes-lab.com/records/tension/aggregate-domain-service.md): "domain-service" (domain-modeling layer) is traded against "Aggregate" (domain-modeling layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Aggregate" and choosing an explicit operating point.
- [Defensive Programming / Verbosity](https://banes-lab.com/records/tension/defensive-programming-verbosity.md): "defensive-programming" (correctness-core layer) is traded against "Verbosity" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Verbosity" and choosing an explicit operating point.
- [Fail Fast / Graceful Degradation](https://banes-lab.com/records/tension/fail-fast-graceful-degradation.md): "fail-fast" (correctness-core layer) is traded against "Graceful Degradation" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Graceful Degradation" and choosing an explicit operating point.
- [Fail Safe / Availability](https://banes-lab.com/records/tension/availability-fail-safe.md): "fail-safe" (correctness-core layer) is traded against "Availability" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Availability" and choosing an explicit operating point.
- [Fail Secure / Availability](https://banes-lab.com/records/tension/availability-fail-secure.md): "fail-secure" (correctness-core layer) is traded against "Availability" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Availability" and choosing an explicit operating point.
- [Graceful Degradation / Consistency / Feature Completeness](https://banes-lab.com/records/tension/consistency-feature-completeness-graceful-degradation.md): "graceful-degradation" (correctness-core layer) is traded against "Consistency / Feature Completeness" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Consistency / Feature Completeness" and choosing an explicit operating point.
- [Fault Tolerance / Cost](https://banes-lab.com/records/tension/cost-fault-tolerance.md): "fault-tolerance" (correctness-core layer) is traded against "Cost" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Cost" and choosing an explicit operating point.
- [Resilience / Complexity](https://banes-lab.com/records/tension/complexity-resilience.md): "resilience" (correctness-core layer) is traded against "Complexity" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Complexity" and choosing an explicit operating point.
- [Robustness Principle / Strict Validation](https://banes-lab.com/records/tension/robustness-principle-strict-validation.md): "robustness-principle" (correctness-core layer) is traded against "Strict Validation" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Strict Validation" and choosing an explicit operating point.
- [Error Handling / Simplicity](https://banes-lab.com/records/tension/error-handling-simplicity.md): "error-handling" (correctness-core layer) is traded against "Simplicity" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Simplicity" and choosing an explicit operating point.
- [Error Boundaries / Hidden Errors](https://banes-lab.com/records/tension/error-boundaries-hidden-errors.md): "error-boundaries" (correctness-core layer) is traded against "Hidden Errors" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Hidden Errors" and choosing an explicit operating point.
- [Fallback Pattern / Stale/Reduced Results](https://banes-lab.com/records/tension/fallback-pattern-stale-reduced-results.md): "fallback-pattern" (correctness-core layer) is traded against "Stale/Reduced Results" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Stale/Reduced Results" and choosing an explicit operating point.
- [Retry Pattern / Load Amplification](https://banes-lab.com/records/tension/load-amplification-retry-pattern.md): "retry-pattern" (correctness-core layer) is traded against "Load Amplification" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Load Amplification" and choosing an explicit operating point.
- [Timeout Pattern / Slow Operation Tolerance](https://banes-lab.com/records/tension/slow-operation-tolerance-timeout-pattern.md): "timeout-pattern" (correctness-core layer) is traded against "Slow Operation Tolerance" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Slow Operation Tolerance" and choosing an explicit operating point.
- [Circuit Breaker Pattern / Availability of Degraded Dependency](https://banes-lab.com/records/tension/availability-of-degraded-dependency-circuit-breaker-pattern.md): "circuit-breaker-pattern" (correctness-core layer) is traded against "Availability of Degraded Dependency" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Availability of Degraded Dependency" and choosing an explicit operating point.
- [Bulkhead Pattern / Resource Utilization](https://banes-lab.com/records/tension/bulkhead-pattern-resource-utilization.md): "bulkhead-pattern" (correctness-core layer) is traded against "Resource Utilization" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Resource Utilization" and choosing an explicit operating point.
- [Backpressure / Throughput](https://banes-lab.com/records/tension/backpressure-throughput.md): "backpressure" (correctness-core layer) is traded against "Throughput" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Throughput" and choosing an explicit operating point.
- [Event-Driven Architecture / Debuggability](https://banes-lab.com/records/tension/debuggability-event-driven-architecture.md): "event-driven-architecture" (execution-core layer) is traded against "Debuggability" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Debuggability" and choosing an explicit operating point.
- [Event-Driven Architecture / Strong Consistency](https://banes-lab.com/records/tension/event-driven-architecture-strong-consistency.md): "event-driven-architecture" (execution-core layer) is traded against "Strong Consistency" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Strong Consistency" and choosing an explicit operating point.
- [Publish/Subscribe Pattern / Delivery Ordering](https://banes-lab.com/records/tension/delivery-ordering-publish-subscribe-pattern.md): "publish-subscribe-pattern" (execution-core layer) is traded against "Delivery Ordering" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Delivery Ordering" and choosing an explicit operating point.
- [Message Queue / Latency](https://banes-lab.com/records/tension/latency-message-queue.md): "message-queue" (execution-core layer) is traded against "Latency" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Latency" and choosing an explicit operating point.
- [Message Broker / Operational Dependency](https://banes-lab.com/records/tension/message-broker-operational-dependency.md): "message-broker" (execution-core layer) is traded against "Operational Dependency" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Operational Dependency" and choosing an explicit operating point.
- [Event Bus / Event Storm / Traceability](https://banes-lab.com/records/tension/event-bus-event-storm-traceability.md): "event-bus" (execution-core layer) is traded against "Event Storm / Traceability" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Event Storm / Traceability" and choosing an explicit operating point.
- [Event Stream / Storage Volume](https://banes-lab.com/records/tension/event-stream-storage-volume.md): "event-stream" (execution-core layer) is traded against "Storage Volume" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Storage Volume" and choosing an explicit operating point.
- [Event Sourcing / Query Complexity](https://banes-lab.com/records/tension/event-sourcing-query-complexity.md): "event-sourcing" (execution-core layer) is traded against "Query Complexity" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Query Complexity" and choosing an explicit operating point.
- [CQRS / Eventual Consistency](https://banes-lab.com/records/tension/cqrs-eventual-consistency.md): "command-query-responsibility-segregation" (execution-core layer) is traded against "Eventual Consistency" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Eventual Consistency" and choosing an explicit operating point.
- [Domain Events / Event Granularity](https://banes-lab.com/records/tension/domain-events-event-granularity.md): "domain-events" (execution-core layer) is traded against "Event Granularity" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Event Granularity" and choosing an explicit operating point.
- [Integration Events / Duplication with Domain Events](https://banes-lab.com/records/tension/duplication-with-domain-events-integration-events.md): "integration-events" (execution-core layer) is traded against "Duplication with Domain Events" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Duplication with Domain Events" and choosing an explicit operating point.
- [Asynchronous Communication / Immediate Consistency](https://banes-lab.com/records/tension/asynchronous-communication-immediate-consistency.md): "asynchronous-communication" (execution-core layer) is traded against "Immediate Consistency" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Immediate Consistency" and choosing an explicit operating point.
- [Service Autonomy / Global Consistency](https://banes-lab.com/records/tension/global-consistency-service-autonomy.md): "service-autonomy" (execution-core layer) is traded against "Global Consistency" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Global Consistency" and choosing an explicit operating point.
- [Eventual Consistency / User Expectations](https://banes-lab.com/records/tension/eventual-consistency-user-expectations.md): "eventual-consistency" (execution-core layer) is traded against "User Expectations" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "User Expectations" and choosing an explicit operating point.
- [Eventual Consistency / Strong Immediate Consistency](https://banes-lab.com/records/tension/eventual-consistency-strong-immediate-consistency.md): "eventual-consistency" (execution-core layer) is traded against "Strong Immediate Consistency" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Strong Immediate Consistency" and choosing an explicit operating point.
- [Saga Pattern / Workflow Complexity](https://banes-lab.com/records/tension/saga-pattern-workflow-complexity.md): "saga-pattern" (execution-core layer) is traded against "Workflow Complexity" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Workflow Complexity" and choosing an explicit operating point.
- [Outbox Pattern / Relay Complexity](https://banes-lab.com/records/tension/outbox-pattern-relay-complexity.md): "outbox-pattern" (execution-core layer) is traded against "Relay Complexity" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Relay Complexity" and choosing an explicit operating point.
- [Compensating Transaction / Business Complexity](https://banes-lab.com/records/tension/business-complexity-compensating-transaction.md): "compensating-transaction" (execution-core layer) is traded against "Business Complexity" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Business Complexity" and choosing an explicit operating point.
- [Append-Only Log / Storage Growth](https://banes-lab.com/records/tension/append-only-log-storage-growth.md): "append-only-log" (execution-core layer) is traded against "Storage Growth" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Storage Growth" and choosing an explicit operating point.
- [Dead-Letter Queue / Operational Overhead](https://banes-lab.com/records/tension/dead-letter-queue-operational-overhead.md): "dead-letter-queue" (execution-core layer) is traded against "Operational Overhead" (resource-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Operational Overhead" and choosing an explicit operating point.
- [Idempotent Consumer / State Overhead](https://banes-lab.com/records/tension/idempotent-consumer-state-overhead.md): "idempotent-consumer" (execution-core layer) is traded against "State Overhead" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "State Overhead" and choosing an explicit operating point.
- [Competing Consumers / Ordering](https://banes-lab.com/records/tension/competing-consumers-ordering.md): "competing-consumers" (execution-core layer) is traded against "Ordering" (causality-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Ordering" and choosing an explicit operating point.
- [Self-Describing Architecture / Metadata Drift](https://banes-lab.com/records/tension/metadata-drift-self-describing-architecture.md): "self-describing-architecture" (declarative-core layer) is traded against "Metadata Drift" (declarative-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Metadata Drift" and choosing an explicit operating point.
- [Self-Describing API / Payload Verbosity](https://banes-lab.com/records/tension/payload-verbosity-self-describing-api.md): "self-describing-api" (declarative-core layer) is traded against "Payload Verbosity" (declarative-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Payload Verbosity" and choosing an explicit operating point.
- [Self-Describing Structures / Size Overhead](https://banes-lab.com/records/tension/self-describing-structures-size-overhead.md): "self-describing-structures" (declarative-core layer) is traded against "Size Overhead" (declarative-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Size Overhead" and choosing an explicit operating point.
- [Metadata-Driven Design / Debuggability](https://banes-lab.com/records/tension/debuggability-metadata-driven-design.md): "metadata-driven-design" (declarative-core layer) is traded against "Debuggability" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Debuggability" and choosing an explicit operating point.
- [Declarative Configuration / Dynamic Complexity](https://banes-lab.com/records/tension/declarative-configuration-dynamic-complexity.md): "declarative-configuration" (declarative-core layer) is traded against "Dynamic Complexity" (declarative-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Dynamic Complexity" and choosing an explicit operating point.
- [Convention over Configuration / Explicitness](https://banes-lab.com/records/tension/convention-over-configuration-explicitness.md): "convention-over-configuration" (declarative-core layer) is traded against "Explicitness" (declarative-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Explicitness" and choosing an explicit operating point.
- [Capability Declaration / Declaration Drift](https://banes-lab.com/records/tension/capability-declaration-declaration-drift.md): "capability-declaration" (declarative-core layer) is traded against "Declaration Drift" (declarative-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Declaration Drift" and choosing an explicit operating point.
- [Manifest-Based Design / Manifest Drift](https://banes-lab.com/records/tension/manifest-based-design-manifest-drift.md): "manifest-based-design" (declarative-core layer) is traded against "Manifest Drift" (declarative-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Manifest Drift" and choosing an explicit operating point.
- [Homoiconicity / Readability](https://banes-lab.com/records/tension/homoiconicity-readability.md): "homoiconicity" (declarative-core layer) is traded against "Readability" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Readability" and choosing an explicit operating point.
- [Code as Data / Safety/Debuggability](https://banes-lab.com/records/tension/code-as-data-safety-debuggability.md): "code-as-data" (declarative-core layer) is traded against "Safety/Debuggability" (declarative-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Safety/Debuggability" and choosing an explicit operating point.
- [Metaprogramming / Debuggability](https://banes-lab.com/records/tension/debuggability-metaprogramming.md): "metaprogramming" (declarative-core layer) is traded against "Debuggability" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Debuggability" and choosing an explicit operating point.
- [Metaprogramming / Static Analysis](https://banes-lab.com/records/tension/metaprogramming-static-analysis.md): "metaprogramming" (declarative-core layer) is traded against "Static Analysis" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Static Analysis" and choosing an explicit operating point.
- [Metaprogramming / Explicit Handwritten Code](https://banes-lab.com/records/tension/explicit-handwritten-code-metaprogramming.md): "metaprogramming" (declarative-core layer) is traded against "Explicit Handwritten Code" (declarative-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Explicit Handwritten Code" and choosing an explicit operating point.
- [Reflection / Performance/Safety](https://banes-lab.com/records/tension/performance-safety-reflection.md): "reflection" (declarative-core layer) is traded against "Performance/Safety" (declarative-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Performance/Safety" and choosing an explicit operating point.
- [Reflection / Static Analysis](https://banes-lab.com/records/tension/reflection-static-analysis.md): "reflection" (declarative-core layer) is traded against "Static Analysis" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Static Analysis" and choosing an explicit operating point.
- [Introspection / Encapsulation](https://banes-lab.com/records/tension/encapsulation-introspection.md): "introspection" (declarative-core layer) is traded against "Encapsulation" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Encapsulation" and choosing an explicit operating point.
- [Compile-Time Evaluation / Build Complexity](https://banes-lab.com/records/tension/build-complexity-compile-time-evaluation.md): "compile-time-evaluation" (declarative-core layer) is traded against "Build Complexity" (declarative-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Build Complexity" and choosing an explicit operating point.
- [Compile-Time Evaluation / Runtime Dynamic Evaluation](https://banes-lab.com/records/tension/compile-time-evaluation-runtime-dynamic-evaluation.md): "compile-time-evaluation" (declarative-core layer) is traded against "Runtime Dynamic Evaluation" (declarative-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Runtime Dynamic Evaluation" and choosing an explicit operating point.
- [Runtime Code Generation / Security/Debugging](https://banes-lab.com/records/tension/runtime-code-generation-security-debugging.md): "runtime-code-generation" (declarative-core layer) is traded against "Security/Debugging" (declarative-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Security/Debugging" and choosing an explicit operating point.
- [Runtime Code Generation / Static Safety](https://banes-lab.com/records/tension/runtime-code-generation-static-safety.md): "runtime-code-generation" (declarative-core layer) is traded against "Static Safety" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Static Safety" and choosing an explicit operating point.
- [Domain-Specific Language (DSL) / Tooling/Maintenance](https://banes-lab.com/records/tension/domain-specific-language-dsl-tooling-maintenance.md): "domain-specific-language" (declarative-core layer) is traded against "Tooling/Maintenance" (declarative-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Tooling/Maintenance" and choosing an explicit operating point.
- [Language-Oriented Programming / Toolchain Complexity](https://banes-lab.com/records/tension/language-oriented-programming-toolchain-complexity.md): "language-oriented-programming" (declarative-core layer) is traded against "Toolchain Complexity" (declarative-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Toolchain Complexity" and choosing an explicit operating point.
- [Language-Oriented Programming / One-Size General-Purpose Code](https://banes-lab.com/records/tension/language-oriented-programming-one-size-general-purpose-code.md): "language-oriented-programming" (declarative-core layer) is traded against "One-Size General-Purpose Code" (declarative-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "One-Size General-Purpose Code" and choosing an explicit operating point.
- [Artificial Intelligence Architecture / Determinism](https://banes-lab.com/records/tension/artificial-intelligence-architecture-determinism.md): "artificial-intelligence-architecture" (correctness-core layer) is traded against "Determinism" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Determinism" and choosing an explicit operating point.
- [Artificial Intelligence Architecture / Explainability](https://banes-lab.com/records/tension/artificial-intelligence-architecture-explainability.md): "artificial-intelligence-architecture" (correctness-core layer) is traded against "Explainability" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Explainability" and choosing an explicit operating point.
- [Machine Learning Architecture / Experimentation Speed](https://banes-lab.com/records/tension/experimentation-speed-machine-learning-architecture.md): "machine-learning-architecture" (correctness-core layer) is traded against "Experimentation Speed" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Experimentation Speed" and choosing an explicit operating point.
- [Model Governance / Experiment Velocity](https://banes-lab.com/records/tension/experiment-velocity-model-governance.md): "model-governance" (correctness-core layer) is traded against "Experiment Velocity" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Experiment Velocity" and choosing an explicit operating point.
- [Model Evaluation / Metric Completeness](https://banes-lab.com/records/tension/metric-completeness-model-evaluation.md): "model-evaluation" (correctness-core layer) is traded against "Metric Completeness" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Metric Completeness" and choosing an explicit operating point.
- [Model Inference / Latency/Cost](https://banes-lab.com/records/tension/latency-cost-model-inference.md): "model-inference" (correctness-core layer) is traded against "Latency/Cost" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Latency/Cost" and choosing an explicit operating point.
- [Retrieval-Augmented Generation (RAG) / Retrieval Quality/Latency](https://banes-lab.com/records/tension/retrieval-augmented-generation-rag-retrieval-quality-latency.md): "retrieval-augmented-generation" (correctness-core layer) is traded against "Retrieval Quality/Latency" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Retrieval Quality/Latency" and choosing an explicit operating point.
- [Vector Search / Explainability/Recall](https://banes-lab.com/records/tension/explainability-recall-vector-search.md): "vector-search" (correctness-core layer) is traded against "Explainability/Recall" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Explainability/Recall" and choosing an explicit operating point.
- [Knowledge Graphs / Curation Cost](https://banes-lab.com/records/tension/curation-cost-knowledge-graphs.md): "knowledge-graphs" (correctness-core layer) is traded against "Curation Cost" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Curation Cost" and choosing an explicit operating point.
- [Explainability / Model Complexity](https://banes-lab.com/records/tension/explainability-model-complexity.md): "explainability" (correctness-core layer) is traded against "Model Complexity" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Model Complexity" and choosing an explicit operating point.
- [Model Safety / Capability/Utility](https://banes-lab.com/records/tension/capability-utility-model-safety.md): "model-safety" (correctness-core layer) is traded against "Capability/Utility" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Capability/Utility" and choosing an explicit operating point.
- [Prompt Engineering / Robustness](https://banes-lab.com/records/tension/prompt-engineering-robustness.md): "prompt-engineering" (correctness-core layer) is traded against "Robustness" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Robustness" and choosing an explicit operating point.
- [Model Drift Monitoring / Monitoring Cost](https://banes-lab.com/records/tension/model-drift-monitoring-monitoring-cost.md): "model-drift-monitoring" (correctness-core layer) is traded against "Monitoring Cost" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Monitoring Cost" and choosing an explicit operating point.
- [Agentic Architecture / Determinism](https://banes-lab.com/records/tension/agentic-architecture-determinism.md): "agentic-architecture" (correctness-core layer) is traded against "Determinism" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Determinism" and choosing an explicit operating point.
- [Observability / Cost/Noise](https://banes-lab.com/records/tension/cost-noise-observability.md): "observability" (observability layer) is traded against "Cost/Noise" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Cost/Noise" and choosing an explicit operating point.
- [Logging / Noise/Personal Data Leakage](https://banes-lab.com/records/tension/logging-noise-personal-data-leakage.md): "logging" (observability layer) is traded against "Noise/Personal Data Leakage" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Noise/Personal Data Leakage" and choosing an explicit operating point.
- [Monitoring / Alert Noise](https://banes-lab.com/records/tension/alert-noise-monitoring.md): "monitoring" (observability layer) is traded against "Alert Noise" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Alert Noise" and choosing an explicit operating point.
- [Alerting / Alert Fatigue](https://banes-lab.com/records/tension/alert-fatigue-alerting.md): "alerting" (observability layer) is traded against "Alert Fatigue" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Alert Fatigue" and choosing an explicit operating point.
- [Auditability / Storage/Privacy](https://banes-lab.com/records/tension/auditability-storage-privacy.md): "auditability" (observability layer) is traded against "Storage/Privacy" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Storage/Privacy" and choosing an explicit operating point.
- [Audit Logging / Privacy](https://banes-lab.com/records/tension/audit-logging-privacy.md): "audit-logging" (observability layer) is traded against "Privacy" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Privacy" and choosing an explicit operating point.
- [Traceability / Metadata Propagation Overhead](https://banes-lab.com/records/tension/metadata-propagation-overhead-traceability.md): "traceability" (observability layer) is traded against "Metadata Propagation Overhead" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Metadata Propagation Overhead" and choosing an explicit operating point.
- [Correlation ID / Header/Metadata Management](https://banes-lab.com/records/tension/correlation-id-header-metadata-management.md): "correlation-id" (observability layer) is traded against "Header/Metadata Management" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Header/Metadata Management" and choosing an explicit operating point.
- [Causation ID / Metadata Verbosity](https://banes-lab.com/records/tension/causation-id-metadata-verbosity.md): "causation-id" (observability layer) is traded against "Metadata Verbosity" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Metadata Verbosity" and choosing an explicit operating point.
- [Distributed Tracing / Overhead/Sampling](https://banes-lab.com/records/tension/distributed-tracing-overhead-sampling.md): "distributed-tracing" (observability layer) is traded against "Overhead/Sampling" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Overhead/Sampling" and choosing an explicit operating point.
- [SLO/SLI / Feature Velocity](https://banes-lab.com/records/tension/feature-velocity-slo-sli.md): "slo-sli" (observability layer) is traded against "Feature Velocity" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Feature Velocity" and choosing an explicit operating point.
- [Dashboards / Dashboard Sprawl](https://banes-lab.com/records/tension/dashboard-sprawl-dashboards.md): "dashboards" (observability layer) is traded against "Dashboard Sprawl" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Dashboard Sprawl" and choosing an explicit operating point.
- [Plugin Architecture / Static Analysis](https://banes-lab.com/records/tension/plugin-architecture-static-analysis.md): "plugin-architecture" (extensibility-core layer) is traded against "Static Analysis" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Static Analysis" and choosing an explicit operating point.
- [Plugin Architecture / Security](https://banes-lab.com/records/tension/plugin-architecture-security.md): "plugin-architecture" (extensibility-core layer) is traded against "Security" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Security" and choosing an explicit operating point.
- [Extension Points / API Surface Growth](https://banes-lab.com/records/tension/api-surface-growth-extension-points.md): "extension-points" (extensibility-core layer) is traded against "API Surface Growth" (extensibility-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "API Surface Growth" and choosing an explicit operating point.
- [Inversion of Control (IoC) / Traceability](https://banes-lab.com/records/tension/inversion-of-control-ioc-traceability.md): "inversion-of-control" (extensibility-core layer) is traded against "Traceability" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Traceability" and choosing an explicit operating point.
- [Dependency Injection / Constructor Complexity](https://banes-lab.com/records/tension/constructor-complexity-dependency-injection.md): "dependency-injection" (extensibility-core layer) is traded against "Constructor Complexity" (extensibility-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Constructor Complexity" and choosing an explicit operating point.
- [Service Registry / Registry Availability](https://banes-lab.com/records/tension/registry-availability-service-registry.md): "service-registry" (extensibility-core layer) is traded against "Registry Availability" (extensibility-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Registry Availability" and choosing an explicit operating point.
- [Registry Pattern / Global State](https://banes-lab.com/records/tension/global-state-registry-pattern.md): "registry-pattern" (extensibility-core layer) is traded against "Global State" (extensibility-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Global State" and choosing an explicit operating point.
- [Service Locator Pattern / Testability](https://banes-lab.com/records/tension/service-locator-pattern-testability.md): "service-locator-pattern" (extensibility-core layer) is traded against "Testability" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Testability" and choosing an explicit operating point.
- [Service Locator Pattern / Dependency Inversion Principle (DIP)](https://banes-lab.com/records/tension/dependency-inversion-principle-dip-service-locator-pattern.md): "service-locator-pattern" (extensibility-core layer) is traded against "DIP" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "DIP" and choosing an explicit operating point.
- [Service Locator Pattern / Explicit Dependencies](https://banes-lab.com/records/tension/explicit-dependencies-service-locator-pattern.md): "service-locator-pattern" (extensibility-core layer) is traded against "Explicit Dependencies" (extensibility-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Explicit Dependencies" and choosing an explicit operating point.
- [Feature Toggle / Flag Debt](https://banes-lab.com/records/tension/feature-toggle-flag-debt.md): "feature-toggle" (extensibility-core layer) is traded against "Flag Debt" (extensibility-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Flag Debt" and choosing an explicit operating point.
- [Portability / Platform Optimization](https://banes-lab.com/records/tension/platform-optimization-portability.md): "portability" (resource-core layer) is traded against "Platform Optimization" (resource-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Platform Optimization" and choosing an explicit operating point.
- [Platform Independence / Native Optimization](https://banes-lab.com/records/tension/native-optimization-platform-independence.md): "platform-independence" (resource-core layer) is traded against "Native Optimization" (resource-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Native Optimization" and choosing an explicit operating point.
- [Environment Parity / Cost](https://banes-lab.com/records/tension/cost-environment-parity.md): "environment-parity" (resource-core layer) is traded against "Cost" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Cost" and choosing an explicit operating point.
- [Containerization / Image Complexity](https://banes-lab.com/records/tension/containerization-image-complexity.md): "containerization" (resource-core layer) is traded against "Image Complexity" (resource-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Image Complexity" and choosing an explicit operating point.
- [Infrastructure as Code / Tooling Complexity](https://banes-lab.com/records/tension/infrastructure-as-code-tooling-complexity.md): "infrastructure-as-code" (resource-core layer) is traded against "Tooling Complexity" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Tooling Complexity" and choosing an explicit operating point.
- [Standards Compliance / Innovation/Flexibility](https://banes-lab.com/records/tension/innovation-flexibility-standards-compliance.md): "standards-compliance" (resource-core layer) is traded against "Innovation/Flexibility" (resource-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Innovation/Flexibility" and choosing an explicit operating point.
- [Protocol Independence / Protocol-Specific Features](https://banes-lab.com/records/tension/protocol-independence-protocol-specific-features.md): "protocol-independence" (resource-core layer) is traded against "Protocol-Specific Features" (resource-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Protocol-Specific Features" and choosing an explicit operating point.
- [Configuration Externalization / Config Sprawl](https://banes-lab.com/records/tension/config-sprawl-configuration-externalization.md): "configuration-externalization" (resource-core layer) is traded against "Config Sprawl" (resource-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Config Sprawl" and choosing an explicit operating point.
- [Immutable Infrastructure / Deploy Time](https://banes-lab.com/records/tension/deploy-time-immutable-infrastructure.md): "immutable-infrastructure" (resource-core layer) is traded against "Deploy Time" (resource-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Deploy Time" and choosing an explicit operating point.
- [Runtime Discovery / Predictability](https://banes-lab.com/records/tension/predictability-runtime-discovery.md): "runtime-discovery" (extensibility-core layer) is traded against "Predictability" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Predictability" and choosing an explicit operating point.
- [Runtime Discovery / Static Analysis](https://banes-lab.com/records/tension/runtime-discovery-static-analysis.md): "runtime-discovery" (extensibility-core layer) is traded against "Static Analysis" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Static Analysis" and choosing an explicit operating point.
- [Service Discovery / Operational Complexity](https://banes-lab.com/records/tension/operational-complexity-service-discovery.md): "service-discovery" (extensibility-core layer) is traded against "Operational Complexity" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Operational Complexity" and choosing an explicit operating point.
- [Auto-Discovery / Startup Cost](https://banes-lab.com/records/tension/auto-discovery-startup-cost.md): "auto-discovery" (extensibility-core layer) is traded against "Startup Cost" (extensibility-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Startup Cost" and choosing an explicit operating point.
- [Dynamic Binding / Static Safety](https://banes-lab.com/records/tension/dynamic-binding-static-safety.md): "dynamic-binding" (extensibility-core layer) is traded against "Static Safety" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Static Safety" and choosing an explicit operating point.
- [Late Binding / Predictability](https://banes-lab.com/records/tension/late-binding-predictability.md): "late-binding" (extensibility-core layer) is traded against "Predictability" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Predictability" and choosing an explicit operating point.
- [Runtime Binding / Debugging](https://banes-lab.com/records/tension/debugging-runtime-binding.md): "runtime-binding" (extensibility-core layer) is traded against "Debugging" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Debugging" and choosing an explicit operating point.
- [Dynamic Dispatch / Traceability](https://banes-lab.com/records/tension/dynamic-dispatch-traceability.md): "dynamic-dispatch" (extensibility-core layer) is traded against "Traceability" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Traceability" and choosing an explicit operating point.
- [Runtime Extensibility / Predictability](https://banes-lab.com/records/tension/predictability-runtime-extensibility.md): "runtime-extensibility" (extensibility-core layer) is traded against "Predictability" (computation-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Predictability" and choosing an explicit operating point.
- [Runtime Extensibility / Security](https://banes-lab.com/records/tension/runtime-extensibility-security.md): "runtime-extensibility" (extensibility-core layer) is traded against "Security" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Security" and choosing an explicit operating point.
- [Scalability / Simplicity](https://banes-lab.com/records/tension/scalability-simplicity.md): "scalability" (performance-core layer) is traded against "Simplicity" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Simplicity" and choosing an explicit operating point.
- [Scalability / Consistency](https://banes-lab.com/records/tension/consistency-scalability.md): "scalability" (performance-core layer) is traded against "Consistency" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Consistency" and choosing an explicit operating point.
- [Horizontal Scaling / Distributed Coordination](https://banes-lab.com/records/tension/distributed-coordination-horizontal-scaling.md): "horizontal-scaling" (performance-core layer) is traded against "Distributed Coordination" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Distributed Coordination" and choosing an explicit operating point.
- [Vertical Scaling / Cost/Limit](https://banes-lab.com/records/tension/cost-limit-vertical-scaling.md): "vertical-scaling" (performance-core layer) is traded against "Cost/Limit" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Cost/Limit" and choosing an explicit operating point.
- [Elasticity / Warm-Up Latency](https://banes-lab.com/records/tension/elasticity-warm-up-latency.md): "elasticity" (performance-core layer) is traded against "Warm-Up Latency" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Warm-Up Latency" and choosing an explicit operating point.
- [Load Balancing / Session Affinity](https://banes-lab.com/records/tension/load-balancing-session-affinity.md): "load-balancing" (performance-core layer) is traded against "Session Affinity" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Session Affinity" and choosing an explicit operating point.
- [Sharding / Cross-Shard Queries](https://banes-lab.com/records/tension/cross-shard-queries-sharding.md): "sharding" (performance-core layer) is traded against "Cross-Shard Queries" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Cross-Shard Queries" and choosing an explicit operating point.
- [Partitioning / Rebalancing Complexity](https://banes-lab.com/records/tension/partitioning-rebalancing-complexity.md): "partitioning" (performance-core layer) is traded against "Rebalancing Complexity" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Rebalancing Complexity" and choosing an explicit operating point.
- [Caching / Consistency](https://banes-lab.com/records/tension/caching-consistency.md): "caching" (performance-core layer) is traded against "Consistency" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Consistency" and choosing an explicit operating point.
- [Caching / Always-Fresh Reads](https://banes-lab.com/records/tension/always-fresh-reads-caching.md): "caching" (performance-core layer) is traded against "Always-Fresh Reads" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Always-Fresh Reads" and choosing an explicit operating point.
- [Statelessness / State Access Latency](https://banes-lab.com/records/tension/state-access-latency-statelessness.md): "statelessness" (performance-core layer) is traded against "State Access Latency" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "State Access Latency" and choosing an explicit operating point.
- [Concurrency / Complexity](https://banes-lab.com/records/tension/complexity-concurrency.md): "concurrency" (performance-core layer) is traded against "Complexity" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Complexity" and choosing an explicit operating point.
- [Parallelism / Coordination Overhead](https://banes-lab.com/records/tension/coordination-overhead-parallelism.md): "parallelism" (performance-core layer) is traded against "Coordination Overhead" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Coordination Overhead" and choosing an explicit operating point.
- [Throughput / Latency](https://banes-lab.com/records/tension/latency-throughput.md): "throughput" (performance-core layer) is traded against "Latency" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Latency" and choosing an explicit operating point.
- [Latency / Throughput/Batching](https://banes-lab.com/records/tension/latency-throughput-batching.md): "latency" (performance-core layer) is traded against "Throughput/Batching" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Throughput/Batching" and choosing an explicit operating point.
- [Performance Engineering / Maintainability](https://banes-lab.com/records/tension/maintainability-performance-engineering.md): "performance-engineering" (performance-core layer) is traded against "Maintainability" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Maintainability" and choosing an explicit operating point.
- [Algorithmic Efficiency / Implementation Simplicity](https://banes-lab.com/records/tension/algorithmic-efficiency-implementation-simplicity.md): "algorithmic-efficiency" (performance-core layer) is traded against "Implementation Simplicity" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Implementation Simplicity" and choosing an explicit operating point.
- [Time Complexity / Space Complexity](https://banes-lab.com/records/tension/space-complexity-time-complexity.md): "time-complexity" (performance-core layer) is traded against "Space Complexity" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Space Complexity" and choosing an explicit operating point.
- [Big O Notation / Constant-Factor Practicality](https://banes-lab.com/records/tension/big-o-notation-constant-factor-practicality.md): "big-o-notation" (performance-core layer) is traded against "Constant-Factor Practicality" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Constant-Factor Practicality" and choosing an explicit operating point.
- [Optimization / Readability/Maintainability](https://banes-lab.com/records/tension/optimization-readability-maintainability.md): "optimization" (performance-core layer) is traded against "Readability/Maintainability" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Readability/Maintainability" and choosing an explicit operating point.
- [Profiling / Measurement Overhead](https://banes-lab.com/records/tension/measurement-overhead-profiling.md): "profiling" (performance-core layer) is traded against "Measurement Overhead" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Measurement Overhead" and choosing an explicit operating point.
- [Benchmarking / Environment Drift](https://banes-lab.com/records/tension/benchmarking-environment-drift.md): "benchmarking" (performance-core layer) is traded against "Environment Drift" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Environment Drift" and choosing an explicit operating point.
- [Bottleneck Analysis / Distributed Complexity](https://banes-lab.com/records/tension/bottleneck-analysis-distributed-complexity.md): "bottleneck-analysis" (performance-core layer) is traded against "Distributed Complexity" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Distributed Complexity" and choosing an explicit operating point.
- [Resource Utilization / Over-Provisioning](https://banes-lab.com/records/tension/over-provisioning-resource-utilization.md): "resource-utilization" (performance-core layer) is traded against "Over-Provisioning" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Over-Provisioning" and choosing an explicit operating point.
- [Rate Limiting / User Experience](https://banes-lab.com/records/tension/rate-limiting-user-experience.md): "rate-limiting" (performance-core layer) is traded against "User Experience" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "User Experience" and choosing an explicit operating point.
- [Memory Efficiency / CPU Cost](https://banes-lab.com/records/tension/cpu-cost-memory-efficiency.md): "memory-efficiency" (performance-core layer) is traded against "CPU Cost" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "CPU Cost" and choosing an explicit operating point.
- [CDN / Edge Caching / Cache Invalidation](https://banes-lab.com/records/tension/cache-invalidation-cdn-edge-caching.md): "cdn-edge-caching" (performance-core layer) is traded against "Cache Invalidation" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Cache Invalidation" and choosing an explicit operating point.
- [Read Replica / Read-Your-Writes Consistency](https://banes-lab.com/records/tension/read-replica-read-your-writes-consistency.md): "read-replica" (performance-core layer) is traded against "Read-Your-Writes Consistency" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Read-Your-Writes Consistency" and choosing an explicit operating point.
- [Queuing Theory / Model Assumptions](https://banes-lab.com/records/tension/model-assumptions-queuing-theory.md): "queuing-theory" (performance-core layer) is traded against "Model Assumptions" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Model Assumptions" and choosing an explicit operating point.
- [Schema Validation / Flexible Input](https://banes-lab.com/records/tension/flexible-input-schema-validation.md): "schema-validation" (contracts-core layer) is traded against "Flexible Input" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Flexible Input" and choosing an explicit operating point.
- [Type Safety / Rapid Scripting](https://banes-lab.com/records/tension/rapid-scripting-type-safety.md): "type-safety" (contracts-core layer) is traded against "Rapid Scripting" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Rapid Scripting" and choosing an explicit operating point.
- [Canonical Model / Bounded Context Autonomy](https://banes-lab.com/records/tension/bounded-context-autonomy-canonical-model.md): "canonical-model" (contracts-core layer) is traded against "Bounded Context Autonomy" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Bounded Context Autonomy" and choosing an explicit operating point.
- [Canonical Data Model / Bounded Context Purity](https://banes-lab.com/records/tension/bounded-context-purity-canonical-data-model.md): "canonical-data-model" (contracts-core layer) is traded against "Bounded Context Purity" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Bounded Context Purity" and choosing an explicit operating point.
- [Canonical Data Model / Local Model Autonomy](https://banes-lab.com/records/tension/canonical-data-model-local-model-autonomy.md): "canonical-data-model" (contracts-core layer) is traded against "Local Model Autonomy" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Local Model Autonomy" and choosing an explicit operating point.
- [Canonical Schema / Service-Specific Schemas](https://banes-lab.com/records/tension/canonical-schema-service-specific-schemas.md): "canonical-schema" (contracts-core layer) is traded against "Service-Specific Schemas" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Service-Specific Schemas" and choosing an explicit operating point.
- [Canonicalization / Lossless Preservation](https://banes-lab.com/records/tension/canonicalization-lossless-preservation.md): "canonicalization" (contracts-core layer) is traded against "Lossless Preservation" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Lossless Preservation" and choosing an explicit operating point.
- [Single Source of Truth / Availability](https://banes-lab.com/records/tension/availability-single-source-of-truth.md): "single-source-of-truth" (contracts-core layer) is traded against "Availability" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Availability" and choosing an explicit operating point.
- [Single Source of Truth / Decentralization](https://banes-lab.com/records/tension/decentralization-single-source-of-truth.md): "single-source-of-truth" governs the contracts-core layer and "Decentralization" the execution-core layer — two principles in different layers; apply each within its own layer instead of trading one off inside the other.
- [Normalization / Query Performance](https://banes-lab.com/records/tension/normalization-query-performance.md): The source of truth is normalized into one canonical store with no duplication. Derived read models, or projections, are denormalized for query performance, and the canonical store never is, so the two live in separate scopes: the system of record and the read projection.
- [Normalization / Denormalized Read Models](https://banes-lab.com/records/tension/denormalized-read-models-normalization.md): The canonical store is normalized, and only the read models rebuilt from it are denormalized. Normalization governs the write model and denormalization governs the read projection, so the two never compete over one store.
- [Semantic Consistency / Polysemy Across Contexts](https://banes-lab.com/records/tension/polysemy-across-contexts-semantic-consistency.md): "semantic-consistency" (contracts-core layer) is traded against "Polysemy Across Contexts" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Polysemy Across Contexts" and choosing an explicit operating point.
- [Ubiquitous Language / Cross-Context Terminology](https://banes-lab.com/records/tension/cross-context-terminology-ubiquitous-language.md): "ubiquitous-language" (contracts-core layer) is traded against "Cross-Context Terminology" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Cross-Context Terminology" and choosing an explicit operating point.
- [Intent-Revealing Interface / Concise Naming](https://banes-lab.com/records/tension/concise-naming-intent-revealing-interface.md): "intent-revealing-interface" (contracts-core layer) is traded against "Concise Naming" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Concise Naming" and choosing an explicit operating point.
- [Principle of Least Surprise / Clever Abstractions](https://banes-lab.com/records/tension/clever-abstractions-principle-of-least-surprise.md): "principle-of-least-surprise" (contracts-core layer) is traded against "Clever Abstractions" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Clever Abstractions" and choosing an explicit operating point.
- [Database Normalization / Read Performance](https://banes-lab.com/records/tension/database-normalization-read-performance.md): The canonical schema stays normalized. Read performance comes from derived, denormalized projections rebuilt from it, never from denormalizing the source of truth.
- [Security by Design / Developer Ergonomics](https://banes-lab.com/records/tension/developer-ergonomics-security-by-design.md): "security-by-design" (security-core layer) is traded against "Developer Ergonomics" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Developer Ergonomics" and choosing an explicit operating point.
- [Defense in Depth / Complexity](https://banes-lab.com/records/tension/complexity-defense-in-depth.md): "defense-in-depth" (security-core layer) is traded against "Complexity" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Complexity" and choosing an explicit operating point.
- [Least Privilege / Operational Convenience](https://banes-lab.com/records/tension/least-privilege-operational-convenience.md): "least-privilege" (security-core layer) is traded against "Operational Convenience" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Operational Convenience" and choosing an explicit operating point.
- [Zero Trust Architecture / Latency/Complexity](https://banes-lab.com/records/tension/latency-complexity-zero-trust-architecture.md): "zero-trust-architecture" (security-core layer) is traded against "Latency/Complexity" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Latency/Complexity" and choosing an explicit operating point.
- [Secure by Default / Ease of Initial Use](https://banes-lab.com/records/tension/ease-of-initial-use-secure-by-default.md): "secure-by-default" (security-core layer) is traded against "Ease of Initial Use" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Ease of Initial Use" and choosing an explicit operating point.
- [Attack Surface Reduction / Feature Exposure](https://banes-lab.com/records/tension/attack-surface-reduction-feature-exposure.md): "attack-surface-reduction" (security-core layer) is traded against "Feature Exposure" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Feature Exposure" and choosing an explicit operating point.
- [Threat Modeling / Delivery Speed](https://banes-lab.com/records/tension/delivery-speed-threat-modeling.md): "threat-modeling" (security-core layer) is traded against "Delivery Speed" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Delivery Speed" and choosing an explicit operating point.
- [Authentication / User Experience](https://banes-lab.com/records/tension/authentication-user-experience.md): "authentication" (security-core layer) is traded against "UX" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "UX" and choosing an explicit operating point.
- [Authorization / Policy Complexity](https://banes-lab.com/records/tension/authorization-policy-complexity.md): "authorization" (security-core layer) is traded against "Policy Complexity" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Policy Complexity" and choosing an explicit operating point.
- [Access Control / Usability](https://banes-lab.com/records/tension/access-control-usability.md): "access-control" (security-core layer) is traded against "Usability" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Usability" and choosing an explicit operating point.
- [RBAC / Role Explosion](https://banes-lab.com/records/tension/rbac-role-explosion.md): "role-based-access-control" (security-core layer) is traded against "Role Explosion" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Role Explosion" and choosing an explicit operating point.
- [ABAC / Policy Complexity](https://banes-lab.com/records/tension/abac-policy-complexity.md): "attribute-based-access-control" (security-core layer) is traded against "Policy Complexity" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Policy Complexity" and choosing an explicit operating point.
- [Input Validation / Input Flexibility](https://banes-lab.com/records/tension/input-flexibility-input-validation.md): "input-validation" (security-core layer) is traded against "Input Flexibility" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Input Flexibility" and choosing an explicit operating point.
- [Output Encoding / Formatting Flexibility](https://banes-lab.com/records/tension/formatting-flexibility-output-encoding.md): "output-encoding" (security-core layer) is traded against "Formatting Flexibility" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Formatting Flexibility" and choosing an explicit operating point.
- [Encryption at Rest / Key Operations](https://banes-lab.com/records/tension/encryption-at-rest-key-operations.md): "encryption-at-rest" (security-core layer) is traded against "Key Operations" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Key Operations" and choosing an explicit operating point.
- [Encryption in Transit / Certificate Management](https://banes-lab.com/records/tension/certificate-management-encryption-in-transit.md): "encryption-in-transit" (security-core layer) is traded against "Certificate Management" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Certificate Management" and choosing an explicit operating point.
- [Secrets Management / Operational Complexity](https://banes-lab.com/records/tension/operational-complexity-secrets-management.md): "secrets-management" (security-core layer) is traded against "Operational Complexity" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Operational Complexity" and choosing an explicit operating point.
- [Privacy by Design / Analytics/Personalization](https://banes-lab.com/records/tension/analytics-personalization-privacy-by-design.md): "privacy-by-design" (security-core layer) is traded against "Analytics/Personalization" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Analytics/Personalization" and choosing an explicit operating point.
- [Compliance / Delivery Speed](https://banes-lab.com/records/tension/compliance-delivery-speed.md): "compliance" (security-core layer) is traded against "Delivery Speed" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Delivery Speed" and choosing an explicit operating point.
- [Governance / Team Velocity](https://banes-lab.com/records/tension/governance-team-velocity.md): "governance" (security-core layer) is traded against "Team Velocity" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Team Velocity" and choosing an explicit operating point.
- [Policy Enforcement / False Positives](https://banes-lab.com/records/tension/false-positives-policy-enforcement.md): "policy-enforcement" (security-core layer) is traded against "False Positives" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "False Positives" and choosing an explicit operating point.
- [Policy as Code / Policy Maintenance](https://banes-lab.com/records/tension/policy-as-code-policy-maintenance.md): "policy-as-code" (security-core layer) is traded against "Policy Maintenance" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Policy Maintenance" and choosing an explicit operating point.
- [Risk Management / Speed](https://banes-lab.com/records/tension/risk-management-speed.md): "risk-management" (security-core layer) is traded against "Speed" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Speed" and choosing an explicit operating point.
- [Continuous Compliance / Pipeline Complexity](https://banes-lab.com/records/tension/continuous-compliance-pipeline-complexity.md): "continuous-compliance" (security-core layer) is traded against "Pipeline Complexity" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Pipeline Complexity" and choosing an explicit operating point.
- [CSRF Protection / Client Complexity](https://banes-lab.com/records/tension/client-complexity-csrf-protection.md): "csrf-protection" (security-core layer) is traded against "Client Complexity" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Client Complexity" and choosing an explicit operating point.
- [Parameterized Queries / Dynamic Query Flexibility](https://banes-lab.com/records/tension/dynamic-query-flexibility-parameterized-queries.md): "parameterized-queries" (security-core layer) is traded against "Dynamic Query Flexibility" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Dynamic Query Flexibility" and choosing an explicit operating point.
- [Session Management / User Convenience](https://banes-lab.com/records/tension/session-management-user-convenience.md): "session-management" (security-core layer) is traded against "User Convenience" (security-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "User Convenience" and choosing an explicit operating point.
- [Self-Healing Architecture / Automation Risk](https://banes-lab.com/records/tension/automation-risk-self-healing-architecture.md): "self-healing-architecture" (correctness-core layer) is traded against "Automation Risk" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Automation Risk" and choosing an explicit operating point.
- [Autonomous Recovery / False Recovery Actions](https://banes-lab.com/records/tension/autonomous-recovery-false-recovery-actions.md): "autonomous-recovery" (correctness-core layer) is traded against "False Recovery Actions" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "False Recovery Actions" and choosing an explicit operating point.
- [Health Checks / False Positives](https://banes-lab.com/records/tension/false-positives-health-checks.md): "health-checks" (correctness-core layer) is traded against "False Positives" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "False Positives" and choosing an explicit operating point.
- [Failover / Consistency](https://banes-lab.com/records/tension/consistency-failover.md): "failover" (correctness-core layer) is traded against "Consistency" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Consistency" and choosing an explicit operating point.
- [Redundancy / Cost](https://banes-lab.com/records/tension/cost-redundancy.md): "redundancy" (correctness-core layer) is traded against "Cost" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Cost" and choosing an explicit operating point.
- [Replication / Consistency Lag](https://banes-lab.com/records/tension/consistency-lag-replication.md): "replication" (correctness-core layer) is traded against "Consistency Lag" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Consistency Lag" and choosing an explicit operating point.
- [Auto-Scaling / Cost/Cold Start](https://banes-lab.com/records/tension/auto-scaling-cost-cold-start.md): "auto-scaling" (correctness-core layer) is traded against "Cost/Cold Start" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Cost/Cold Start" and choosing an explicit operating point.
- [Auto-Scaling / Fixed Capacity](https://banes-lab.com/records/tension/auto-scaling-fixed-capacity.md): "auto-scaling" (correctness-core layer) is traded against "Fixed Capacity" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Fixed Capacity" and choosing an explicit operating point.
- [Auto-Remediation / Unsafe Automation](https://banes-lab.com/records/tension/auto-remediation-unsafe-automation.md): "auto-remediation" (correctness-core layer) is traded against "Unsafe Automation" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Unsafe Automation" and choosing an explicit operating point.
- [Auto-Remediation / Manual Remediation](https://banes-lab.com/records/tension/auto-remediation-manual-remediation.md): "auto-remediation" (correctness-core layer) is traded against "Manual Remediation" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Manual Remediation" and choosing an explicit operating point.
- [Rollback / Data Migration Compatibility](https://banes-lab.com/records/tension/data-migration-compatibility-rollback.md): "rollback" (correctness-core layer) is traded against "Data Migration Compatibility" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Data Migration Compatibility" and choosing an explicit operating point.
- [Blue-Green Deployment / Infrastructure Cost](https://banes-lab.com/records/tension/blue-green-deployment-infrastructure-cost.md): "blue-green-deployment" (correctness-core layer) is traded against "Infrastructure Cost" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Infrastructure Cost" and choosing an explicit operating point.
- [Canary Deployment / Rollout Complexity](https://banes-lab.com/records/tension/canary-deployment-rollout-complexity.md): "canary-deployment" (correctness-core layer) is traded against "Rollout Complexity" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Rollout Complexity" and choosing an explicit operating point.
- [Chaos Engineering / Production Risk](https://banes-lab.com/records/tension/chaos-engineering-production-risk.md): "chaos-engineering" (correctness-core layer) is traded against "Production Risk" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Production Risk" and choosing an explicit operating point.
- [Graceful Shutdown / Shutdown Latency](https://banes-lab.com/records/tension/graceful-shutdown-shutdown-latency.md): "graceful-shutdown" (correctness-core layer) is traded against "Shutdown Latency" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Shutdown Latency" and choosing an explicit operating point.
- [RAID Redundancy / Write Amplification](https://banes-lab.com/records/tension/raid-redundancy-write-amplification.md): "raid-redundancy" (correctness-core layer) is traded against "Write Amplification" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Write Amplification" and choosing an explicit operating point.
- [Interface Segregation Principle (ISP) / Interface Proliferation](https://banes-lab.com/records/tension/interface-proliferation-interface-segregation-principle-isp.md): "interface-segregation" (structural-core layer) is traded against "Interface Proliferation" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Interface Proliferation" and choosing an explicit operating point.
- [Dependency Inversion Principle (DIP) / Runtime Indirection](https://banes-lab.com/records/tension/dependency-inversion-principle-dip-runtime-indirection.md): "dependency-inversion" (structural-core layer) is traded against "Runtime Indirection" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Runtime Indirection" and choosing an explicit operating point.
- [Open/Closed Principle (OCP) / Simplicity](https://banes-lab.com/records/tension/open-closed-principle-ocp-simplicity.md): "open-closed" (structural-core layer) is traded against "Simplicity" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Simplicity" and choosing an explicit operating point.
- [Liskov Substitution Principle (LSP) / Narrow Specialized Behavior](https://banes-lab.com/records/tension/liskov-substitution-principle-lsp-narrow-specialized-behavior.md): "liskov-substitution" (structural-core layer) is traded against "Narrow Specialized Behavior" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Narrow Specialized Behavior" and choosing an explicit operating point.
- [Polymorphism / Traceability](https://banes-lab.com/records/tension/polymorphism-traceability.md): "polymorphism" (structural-core layer) is traded against "Traceability" (observability layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Traceability" and choosing an explicit operating point.
- [Streaming Architecture / Ordering/State](https://banes-lab.com/records/tension/ordering-state-streaming-architecture.md): "streaming-architecture" (execution-core layer) is traded against "Ordering/State" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Ordering/State" and choosing an explicit operating point.
- [Streaming Architecture / Batch-Only Processing](https://banes-lab.com/records/tension/batch-only-processing-streaming-architecture.md): "streaming-architecture" (execution-core layer) is traded against "Batch-Only Processing" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Batch-Only Processing" and choosing an explicit operating point.
- [Single-Pass Processing / Global Optimization](https://banes-lab.com/records/tension/global-optimization-single-pass-processing.md): "single-pass-processing" (execution-core layer) is traded against "Global Optimization" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Global Optimization" and choosing an explicit operating point.
- [Single-Pass Processing / Multi-Pass Full Materialization](https://banes-lab.com/records/tension/multi-pass-full-materialization-single-pass-processing.md): "single-pass-processing" (execution-core layer) is traded against "Multi-Pass Full Materialization" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Multi-Pass Full Materialization" and choosing an explicit operating point.
- [Pipeline Architecture / Error Propagation/Debugging](https://banes-lab.com/records/tension/error-propagation-debugging-pipeline-architecture.md): "pipeline-architecture" (execution-core layer) is traded against "Error Propagation/Debugging" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Error Propagation/Debugging" and choosing an explicit operating point.
- [Lazy Evaluation / Debuggability/Resource Lifetime](https://banes-lab.com/records/tension/debuggability-resource-lifetime-lazy-evaluation.md): "lazy-evaluation" (execution-core layer) is traded against "Debuggability/Resource Lifetime" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Debuggability/Resource Lifetime" and choosing an explicit operating point.
- [Lazy Evaluation / Eager Full Materialization](https://banes-lab.com/records/tension/eager-full-materialization-lazy-evaluation.md): "lazy-evaluation" (execution-core layer) is traded against "Eager Full Materialization" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Eager Full Materialization" and choosing an explicit operating point.
- [Sequential Access / Lookup Performance](https://banes-lab.com/records/tension/lookup-performance-sequential-access.md): "sequential-access" (execution-core layer) is traded against "Lookup Performance" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Lookup Performance" and choosing an explicit operating point.
- [Sequential Access / Random Access Requirement](https://banes-lab.com/records/tension/random-access-requirement-sequential-access.md): "sequential-access" (execution-core layer) is traded against "Random Access Requirement" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Random Access Requirement" and choosing an explicit operating point.
- [Forward-Only Processing / Complex Grammar/Global State](https://banes-lab.com/records/tension/complex-grammar-global-state-forward-only-processing.md): "forward-only-processing" (execution-core layer) is traded against "Complex Grammar/Global State" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Complex Grammar/Global State" and choosing an explicit operating point.
- [Forward-Only Processing / Backtracking Algorithm](https://banes-lab.com/records/tension/backtracking-algorithm-forward-only-processing.md): "forward-only-processing" (execution-core layer) is traded against "Backtracking Algorithm" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Backtracking Algorithm" and choosing an explicit operating point.
- [Dataflow Architecture / State Coordination](https://banes-lab.com/records/tension/dataflow-architecture-state-coordination.md): "dataflow-architecture" (execution-core layer) is traded against "State Coordination" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "State Coordination" and choosing an explicit operating point.
- [Stateless Processing / Stateful Business Rules](https://banes-lab.com/records/tension/stateful-business-rules-stateless-processing.md): "stateless-processing" (execution-core layer) is traded against "Stateful Business Rules" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Stateful Business Rules" and choosing an explicit operating point.
- [Windowing / Late-Data Handling](https://banes-lab.com/records/tension/late-data-handling-windowing.md): "windowing" (execution-core layer) is traded against "Late-Data Handling" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Late-Data Handling" and choosing an explicit operating point.
- [Fan-out/Fan-in / Coordination Overhead](https://banes-lab.com/records/tension/coordination-overhead-fan-out-fan-in.md): "fan-out-fan-in" (execution-core layer) is traded against "Coordination Overhead" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Coordination Overhead" and choosing an explicit operating point.
- [Fan-out/Fan-in / Serial Item Processing](https://banes-lab.com/records/tension/fan-out-fan-in-serial-item-processing.md): "fan-out-fan-in" (execution-core layer) is traded against "Serial Item Processing" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Serial Item Processing" and choosing an explicit operating point.
- [Batch-vs-Stream / Operational Duplication](https://banes-lab.com/records/tension/batch-vs-stream-operational-duplication.md): "batch-vs-stream" (execution-core layer) is traded against "Operational Duplication" (execution-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Operational Duplication" and choosing an explicit operating point.
- [Adapter Pattern / Mapping Overhead](https://banes-lab.com/records/tension/adapter-pattern-mapping-overhead.md): "adapter-pattern" (design-patterns-core layer) is traded against "Mapping Overhead" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Mapping Overhead" and choosing an explicit operating point.
- [Facade Pattern / Over-Centralization](https://banes-lab.com/records/tension/facade-pattern-over-centralization.md): "facade-pattern" (design-patterns-core layer) is traded against "Over-Centralization" (design-patterns-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Over-Centralization" and choosing an explicit operating point.
- [Proxy Pattern / Transparency / Debugging](https://banes-lab.com/records/tension/proxy-pattern-transparency-debugging.md): "proxy-pattern" (design-patterns-core layer) is traded against "Transparency / Debugging" (design-patterns-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Transparency / Debugging" and choosing an explicit operating point.
- [Bridge Pattern / Indirection](https://banes-lab.com/records/tension/bridge-pattern-indirection.md): "bridge-pattern" (design-patterns-core layer) is traded against "Indirection" (design-patterns-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Indirection" and choosing an explicit operating point.
- [Decorator Pattern / Stack Debugging](https://banes-lab.com/records/tension/decorator-pattern-stack-debugging.md): "decorator-pattern" (design-patterns-core layer) is traded against "Stack Debugging" (design-patterns-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Stack Debugging" and choosing an explicit operating point.
- [Composite Pattern / Type Safety](https://banes-lab.com/records/tension/composite-pattern-type-safety.md): "composite-pattern" (design-patterns-core layer) is traded against "Type Safety" (contracts-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Type Safety" and choosing an explicit operating point.
- [Flyweight Pattern / Complexity](https://banes-lab.com/records/tension/complexity-flyweight-pattern.md): "flyweight-pattern" (design-patterns-core layer) is traded against "Complexity" (human-factors layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Complexity" and choosing an explicit operating point.
- [Closed Vocabulary / Naming Expressiveness](https://banes-lab.com/records/tension/closed-vocabulary-naming-expressiveness.md): "closed-vocabulary" (structural-core layer) is traded against "Naming Expressiveness" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Naming Expressiveness" and choosing an explicit operating point.
- [Bounded Nesting Depth / Tree Compactness](https://banes-lab.com/records/tension/bounded-nesting-depth-tree-compactness.md): "bounded-nesting-depth" (structural-core layer) is traded against "Tree Compactness" (structural-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Tree Compactness" and choosing an explicit operating point.
- [Idempotency / State Tracking](https://banes-lab.com/records/tension/idempotency-state-tracking.md): "idempotency" (atomic-boundary layer) is traded against "State Tracking" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "State Tracking" and choosing an explicit operating point.
- [Atomicity / Distributed Scalability](https://banes-lab.com/records/tension/atomicity-distributed-scalability.md): "atomicity" (atomic-boundary layer) is traded against "Distributed Scalability" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Distributed Scalability" and choosing an explicit operating point.
- [ACID / Distributed Availability](https://banes-lab.com/records/tension/acid-distributed-availability.md): "acid" (atomic-boundary layer) is traded against "Distributed Availability" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Distributed Availability" and choosing an explicit operating point.
- [ACID / BASE/Eventual Consistency](https://banes-lab.com/records/tension/acid-base-eventual-consistency.md): "acid" (atomic-boundary layer) is traded against "BASE/Eventual Consistency" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "BASE/Eventual Consistency" and choosing an explicit operating point.
- [Transaction Boundary / Large Transaction Scope](https://banes-lab.com/records/tension/large-transaction-scope-transaction-boundary.md): "transaction-boundary" (atomic-boundary layer) is traded against "Large Transaction Scope" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Large Transaction Scope" and choosing an explicit operating point.
- [Unit of Work Pattern / Repository Complexity](https://banes-lab.com/records/tension/repository-complexity-unit-of-work-pattern.md): "unit-of-work-pattern" (atomic-boundary layer) is traded against "Repository Complexity" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Repository Complexity" and choosing an explicit operating point.
- [Consistency / Availability](https://banes-lab.com/records/tension/availability-consistency.md): "consistency" (atomic-boundary layer) is traded against "Availability" (correctness-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Availability" and choosing an explicit operating point.
- [Consistency / Latency](https://banes-lab.com/records/tension/consistency-latency.md): "consistency" (atomic-boundary layer) is traded against "Latency" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Latency" and choosing an explicit operating point.
- [Isolation / Throughput](https://banes-lab.com/records/tension/isolation-throughput.md): "isolation" (atomic-boundary layer) is traded against "Throughput" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Throughput" and choosing an explicit operating point.
- [Concurrency Control / Performance](https://banes-lab.com/records/tension/concurrency-control-performance.md): "concurrency-control" (atomic-boundary layer) is traded against "Performance" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Performance" and choosing an explicit operating point.
- [Optimistic Locking / Retry Complexity](https://banes-lab.com/records/tension/optimistic-locking-retry-complexity.md): "optimistic-locking" (atomic-boundary layer) is traded against "Retry Complexity" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Retry Complexity" and choosing an explicit operating point.
- [Pessimistic Locking / Deadlocks](https://banes-lab.com/records/tension/deadlocks-pessimistic-locking.md): "pessimistic-locking" (atomic-boundary layer) is traded against "Deadlocks" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Deadlocks" and choosing an explicit operating point.
- [Pessimistic Locking / Latency](https://banes-lab.com/records/tension/latency-pessimistic-locking.md): "pessimistic-locking" (atomic-boundary layer) is traded against "Latency" (performance-core layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Latency" and choosing an explicit operating point.
- [Pessimistic Locking / Lock-Free Throughput](https://banes-lab.com/records/tension/lock-free-throughput-pessimistic-locking.md): "pessimistic-locking" (atomic-boundary layer) is traded against "Lock-Free Throughput" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Lock-Free Throughput" and choosing an explicit operating point.
- [State Isolation / Data Sharing](https://banes-lab.com/records/tension/data-sharing-state-isolation.md): "state-isolation" (atomic-boundary layer) is traded against "Data Sharing" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Data Sharing" and choosing an explicit operating point.
- [Controlled Side Effects / Performance Optimization](https://banes-lab.com/records/tension/controlled-side-effects-performance-optimization.md): "controlled-side-effects" (atomic-boundary layer) is traded against "Performance Optimization" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Performance Optimization" and choosing an explicit operating point.
- [Petri Nets / Modeling Overhead](https://banes-lab.com/records/tension/modeling-overhead-petri-nets.md): "petri-nets" (atomic-boundary layer) is traded against "Modeling Overhead" (atomic-boundary layer) — a principle cannot be scope-separated from a quality, metric, or cost it competes with; resolve by measuring "Modeling Overhead" and choosing an explicit operating point.