# The lex records whose kind is quality-attribute

This index as JSON: https://banes-lab.com/json/api/facets/lex/kind/quality-attribute

## Entries

- [Analysis Overhead](https://banes-lab.com/records/lex/analysis-overhead.md): The degree to which analyzing the impact of every change before making it adds effort and slows delivery.
- [Architecture Foundation](https://banes-lab.com/records/lex/architecture-foundation.md): The degree to which a system rests on a sound, deliberately designed architectural base rather than accreted structure.
- [Change Safety](https://banes-lab.com/records/lex/change-safety.md): The degree to which a change can be made with confidence that its effects are understood and contained.
- [Competing Attributes](https://banes-lab.com/records/lex/competing-attributes.md): The degree to which improving one quality attribute forces a trade-off against another.
- [Documentation Maintenance](https://banes-lab.com/records/lex/documentation-maintenance.md): The degree to which keeping decision records current adds ongoing upkeep effort.
- [Future Scalability](https://banes-lab.com/records/lex/future-scalability.md): The degree to which a design can grow to meet higher future demand without rework.
- [Governance Discipline](https://banes-lab.com/records/lex/governance-discipline.md): The degree to which evolving an architecture continuously demands sustained governance to prevent uncontrolled drift.
- [Innovation/Autonomy](https://banes-lab.com/records/lex/innovation-autonomy.md): The degree to which enforcing standards constrains teams' freedom to innovate independently.
- [Local Autonomy](https://banes-lab.com/records/lex/local-autonomy.md): The degree to which enforcing architectural consistency limits individual teams' freedom to make local choices.
- [Local Optimization](https://banes-lab.com/records/lex/local-optimization.md): The degree to which enforcing shared patterns sacrifices locally optimal one-off solutions.
- [Operability](https://banes-lab.com/records/lex/operability.md): The degree to which a system is easy to run, monitor, and keep healthy in production.
- [Quality](https://banes-lab.com/records/lex/quality.md): The degree to which a system meets its functional and non-functional expectations.
- [Reuse of Established Patterns](https://banes-lab.com/records/lex/reuse-of-established-patterns.md): The degree to which designing from first principles forgoes the leverage of reusing proven patterns.
- [Unknown Requirements](https://banes-lab.com/records/lex/unknown-requirements.md): The degree to which starting on a clean slate forces early decisions while requirements are still unknown.
- [Rule Maintenance](https://banes-lab.com/records/lex/rule-maintenance.md): The degree to which keeping fitness-function rules current adds ongoing upkeep effort.
- [Class Count](https://banes-lab.com/records/lex/class-count.md): The degree to which extracting each algorithm into its own class raises the total number of classes.
- [Class Proliferation](https://banes-lab.com/records/lex/class-proliferation.md): The degree to which modeling each state as its own class multiplies the number of classes.
- [Coordination Complexity](https://banes-lab.com/records/lex/coordination-complexity.md): The degree of complexity in how objects must coordinate, which motivates a mediator.
- [Element Stability](https://banes-lab.com/records/lex/element-stability.md): The degree to which adding new operations stays easy only while the set of element types stays fixed.
- [Inheritance Coupling](https://banes-lab.com/records/lex/inheritance-coupling.md): The degree to which basing a template method on subclassing binds subclasses tightly to the base class.
- [Mediator God Object](https://banes-lab.com/records/lex/mediator-god-object.md): The degree to which concentrating interaction logic in a mediator risks growing it into an overloaded object.
- [Memory Footprint](https://banes-lab.com/records/lex/memory-footprint.md): The degree of memory consumed by retaining state snapshots for later restoration.
- [Silent No-Op Risk](https://banes-lab.com/records/lex/silent-no-op-risk.md): The degree to which a do-nothing stand-in can hide an error.
- [State Explosion](https://banes-lab.com/records/lex/state-explosion.md): The degree to which the number of explicit states grows unmanageably as conditions multiply.
- [Eventual Consistency Safety](https://banes-lab.com/records/lex/eventual-consistency-safety.md): The degree to which replicas can converge over time without ever exposing a causally impossible state.
- [Latency/Availability](https://banes-lab.com/records/lex/latency-availability.md): The degree to which enforcing causal ordering across replicas costs added latency and reduced availability.
- [Parallel Execution](https://banes-lab.com/records/lex/parallel-execution.md): The degree to which enforcing a happens-before order constrains how much work can run in parallel.
- [Graph Complexity](https://banes-lab.com/records/lex/graph-complexity.md): The degree to which tracking fine-grained causal dependencies grows the dependency graph large and hard to reason about.
- [Dynamic Loading](https://banes-lab.com/records/lex/dynamic-loading.md): The degree to which resolving dependencies dynamically at runtime undermines a statically analyzable dependency graph.
- [Bidirectional Collaboration](https://banes-lab.com/records/lex/bidirectional-collaboration.md): The degree to which forbidding cycles prevents two components from depending on each other bidirectionally.
- [Metadata Size](https://banes-lab.com/records/lex/metadata-size.md): The degree to which carrying a per-node counter for every node grows the ordering metadata with cluster size.
- [No Concurrent Causality Distinction](https://banes-lab.com/records/lex/no-concurrent-causality-distinction.md): The degree to which a single logical counter cannot tell concurrent events apart from causally ordered ones.
- [Clock Skew](https://banes-lab.com/records/lex/clock-skew.md): The degree to which physical clocks on different nodes drift apart, distorting time-based ordering.
- [Metadata Overhead](https://banes-lab.com/records/lex/metadata-overhead.md): The degree to which the bookkeeping a conflict-free type carries per value adds storage and transmission cost.
- [Anemic Layers](https://banes-lab.com/records/lex/anemic-layers.md): The degree to which strict layering produces thin pass-through layers that add indirection without logic.
- [End-to-End Traceability](https://banes-lab.com/records/lex/end-to-end-traceability.md): The degree to which decomposing flow into independent filters makes tracing a request end to end harder.
- [Feature Cohesion](https://banes-lab.com/records/lex/feature-cohesion.md): The degree to which all code serving one feature is grouped together rather than scattered by layer.
- [Independent Scaling](https://banes-lab.com/records/lex/independent-scaling.md): The degree to which a single deployable unit prevents scaling parts of the system independently.
- [Initial Complexity](https://banes-lab.com/records/lex/initial-complexity.md): The degree of upfront structural complexity introduced by defining ports and adapters.
- [Integration Overhead](https://banes-lab.com/records/lex/integration-overhead.md): The degree of effort required to wire independently-developed components together.
- [Operational Simplicity](https://banes-lab.com/records/lex/operational-simplicity.md): The degree to which a single deployable unit keeps building, deploying, and operating simple.
- [Shared Technical Concerns](https://banes-lab.com/records/lex/shared-technical-concerns.md): The degree to which grouping by feature complicates sharing cross-cutting technical code.
- [API Usability](https://banes-lab.com/records/lex/api-usability.md): The degree to which an API is easy for developers to learn and use correctly.
- [Client Compatibility](https://banes-lab.com/records/lex/client-compatibility.md): The degree to which existing clients continue to work as an API evolves.
- [Provider Change Safety](https://banes-lab.com/records/lex/provider-change-safety.md): The degree to which a provider can change without breaking its consumers, verified by their contracts.
- [Reliable Integration](https://banes-lab.com/records/lex/reliable-integration.md): The degree to which systems integrate correctly because their shared meaning is agreed, not just their shape.
- [Consumer Safety](https://banes-lab.com/records/lex/consumer-safety.md): The degree to which consumers are protected from breakage when a provider changes.
- [Data Quality](https://banes-lab.com/records/lex/data-quality.md): The degree to which data is accurate, complete, and fit for its intended use.
- [Integration](https://banes-lab.com/records/lex/integration.md): The degree to which separate systems are connected to operate as a unified whole.
- [Distributed Evolution](https://banes-lab.com/records/lex/distributed-evolution.md): The degree to which services can evolve independently, constrained by the contracts binding them.
- [Domain-Specific Optimization](https://banes-lab.com/records/lex/domain-specific-optimization.md): The degree to which a system is tuned for one domain, traded against broad interoperability.
- [Flexibility](https://banes-lab.com/records/lex/flexibility.md): The degree to which a component permits varied use, in tension with the invariants it must uphold.
- [Flexible Ingestion](https://banes-lab.com/records/lex/flexible-ingestion.md): The degree to which a system accepts loosely-structured input, in tension with a strict data contract.
- [Interface Overuse](https://banes-lab.com/records/lex/interface-overuse.md): The degree to which excessive interface abstraction adds indirection without proportional benefit.
- [Permissive APIs](https://banes-lab.com/records/lex/permissive-apis.md): The degree to which an API accepts loose or lenient input, in tension with strict preconditions.
- [Protocol Optimization](https://banes-lab.com/records/lex/protocol-optimization.md): The degree to which a protocol is tuned for performance, traded against broad compatibility.
- [Provider Autonomy](https://banes-lab.com/records/lex/provider-autonomy.md): The degree of freedom a provider retains to change, constrained by consumer-driven contracts.
- [Runtime Cost](https://banes-lab.com/records/lex/runtime-cost.md): The degree of runtime overhead incurred by checking conditions on every call.
- [Schema Flexibility](https://banes-lab.com/records/lex/schema-flexibility.md): The degree to which a schema tolerates variation, in tension with a strict contract.
- [Specialized Endpoints](https://banes-lab.com/records/lex/specialized-endpoints.md): The degree to which purpose-built endpoints are offered, traded against a uniform interface.
- [Strong Validation](https://banes-lab.com/records/lex/strong-validation.md): The degree to which input is strictly validated, in tension with tolerating unknown future fields.
- [Version Sprawl](https://banes-lab.com/records/lex/version-sprawl.md): The degree to which many concurrent versions accumulate and must be maintained.
- [Central Dependency Risk](https://banes-lab.com/records/lex/central-dependency-risk.md): The degree to which centralizing configuration makes the whole system depend on one config source.
- [Centralized Coordinator Coupling](https://banes-lab.com/records/lex/centralized-coordinator-coupling.md): The degree to which routing a workflow through a central coordinator couples participants to it.
- [Cost/Personal Data Exposure](https://banes-lab.com/records/lex/cost-personal-data-exposure.md): The degree to which aggregating all logs centrally raises storage cost and personal-data exposure.
- [Identity Provider Availability](https://banes-lab.com/records/lex/identity-provider-availability.md): The degree to which every login depends on the central identity provider staying available.
- [Coordination Cost](https://banes-lab.com/records/lex/coordination-cost.md): The degree of extra coordination required when components are made fully independent.
- [Excessive Fragmentation](https://banes-lab.com/records/lex/excessive-fragmentation.md): The degree to which splitting responsibilities too finely scatters logic across many small units.
- [Locality of Behavior](https://banes-lab.com/records/lex/locality-of-behavior.md): The degree to which keeping related behavior together can conflict with removing all duplication.
- [Over-Generalization](https://banes-lab.com/records/lex/over-generalization.md): The degree to which making code reusable for every case adds abstraction that harms clarity.
- [Over-Layering](https://banes-lab.com/records/lex/over-layering.md): The degree to which adding separating layers introduces indirection that outweighs the separation gained.
- [Over-Specialization](https://banes-lab.com/records/lex/over-specialization.md): The degree to which pursuing tight cohesion can narrow a unit's purpose too far to reuse.
- [Performance Overhead](https://banes-lab.com/records/lex/performance-overhead.md): The degree of runtime cost added by composing behavior from many small, indirected parts.
- [Simplicity for Trivial Reuse](https://banes-lab.com/records/lex/simplicity-for-trivial-reuse.md): The degree to which composition adds wiring that inheritance would make simpler for trivial reuse.
- [Specialized Optimization](https://banes-lab.com/records/lex/specialized-optimization.md): The degree to which optimizing for one implementation undermines the ability to swap implementations.
- [Boilerplate](https://banes-lab.com/records/lex/boilerplate.md): Repetitive, mandatory scaffolding code that adds ceremony without domain value.
- [Compatibility](https://banes-lab.com/records/lex/compatibility.md): The degree to which a component interoperates with other versions or systems without modification.
- [Operational Complexity](https://banes-lab.com/records/lex/operational-complexity.md): The effort and intricacy required to deploy, run, and maintain a system in production.
- [Allocation Cost](https://banes-lab.com/records/lex/allocation-cost.md): The degree of extra memory allocation incurred by creating new immutable values instead of mutating in place.
- [Continuous Updates](https://banes-lab.com/records/lex/continuous-updates.md): The degree to which pinning everything for reproducibility conflicts with continuously updating dependencies.
- [Cost/Complexity](https://banes-lab.com/records/lex/cost-complexity.md): The degree of cost and complexity added by formally proving a system correct.
- [Dynamic Runtime Behavior](https://banes-lab.com/records/lex/dynamic-runtime-behavior.md): The degree to which runtime-adaptive behavior undermines a system's predictability.
- [Encapsulation Extremes](https://banes-lab.com/records/lex/encapsulation-extremes.md): The degree to which hiding internals too strictly makes a unit's behavior hard to observe in tests.
- [Fitness for Use](https://banes-lab.com/records/lex/fitness-for-use.md): The degree to which a product meets the needs of its users.
- [Real-World Variability](https://banes-lab.com/records/lex/real-world-variability.md): The degree to which controlling conditions for repeatability diverges from real-world variability.
- [Runtime Adaptivity](https://banes-lab.com/records/lex/runtime-adaptivity.md): The degree to which making behavior deterministic limits adapting dynamically at runtime.
- [Shrinking/Debug Complexity](https://banes-lab.com/records/lex/shrinking-debug-complexity.md): The degree to which reducing a failing generated case to a minimal example adds debugging complexity.
- [Spec Maintenance](https://banes-lab.com/records/lex/spec-maintenance.md): The degree of ongoing effort to keep a specification current as the system evolves.
- [Stateful IO](https://banes-lab.com/records/lex/stateful-io.md): The degree to which stateful input/output conflicts with expressions being replaceable by their values.
- [Stateful Operations](https://banes-lab.com/records/lex/stateful-operations.md): The degree to which operations that depend on or mutate state conflict with purity.
- [Thread Safety](https://banes-lab.com/records/lex/thread-safety.md): The degree to which data can be accessed concurrently without corruption.
- [Complex Construction](https://banes-lab.com/records/lex/complex-construction.md): The degree of complexity in assembling an object that motivates a step-by-step builder.
- [Copy Semantics](https://banes-lab.com/records/lex/copy-semantics.md): The degree of care required to define correct deep versus shallow copying when cloning objects.
- [Inheritance Complexity](https://banes-lab.com/records/lex/inheritance-complexity.md): The degree to which relying on subclassing to vary creation adds to the inheritance hierarchy's complexity.
- [Aggregate Size](https://banes-lab.com/records/lex/aggregate-size.md): The degree to which enlarging an aggregate to enforce invariants increases contention and load on it.
- [Cross-Context Reuse](https://banes-lab.com/records/lex/cross-context-reuse.md): The degree to which isolating each context's model limits reusing models across contexts.
- [Documentation Overhead](https://banes-lab.com/records/lex/documentation-overhead.md): The degree of ongoing effort to document and maintain the map of relationships between contexts.
- [Domain Purity](https://banes-lab.com/records/lex/domain-purity.md): The degree to which the domain model stays free of external and infrastructure concerns.
- [Integration Clarity](https://banes-lab.com/records/lex/integration-clarity.md): The degree to which relationships between contexts are made explicit and understandable.
- [Object Count](https://banes-lab.com/records/lex/object-count.md): The degree to which modeling many concepts as distinct value objects increases the number of objects.
- [Persistence Simplicity](https://banes-lab.com/records/lex/persistence-simplicity.md): The degree to which a rich domain model complicates straightforward mapping to storage.
- [Simple CRUD](https://banes-lab.com/records/lex/simple-crud.md): The degree to which a full domain model adds overhead where simple create-read-update-delete would suffice.
- [Availability of Degraded Dependency](https://banes-lab.com/records/lex/availability-of-degraded-dependency.md): The degree to which tripping a breaker to protect the system also cuts off a still-partly-working dependency.
- [Consistency / Feature Completeness](https://banes-lab.com/records/lex/consistency-feature-completeness.md): The degree to which serving reduced functionality during failure sacrifices full consistency or completeness.
- [Hidden Errors](https://banes-lab.com/records/lex/hidden-errors.md): The degree to which catching failures at a boundary can obscure the underlying errors from view.
- [Load Amplification](https://banes-lab.com/records/lex/load-amplification.md): The degree to which retrying failed operations multiplies load on an already-struggling dependency.
- [Slow Operation Tolerance](https://banes-lab.com/records/lex/slow-operation-tolerance.md): The degree to which enforcing timeouts sacrifices tolerance for legitimately slow operations.
- [Stability](https://banes-lab.com/records/lex/stability.md): The degree to which a system keeps operating steadily without collapsing under load.
- [Stale/Reduced Results](https://banes-lab.com/records/lex/stale-reduced-results.md): The degree to which serving a fallback yields stale or reduced-quality results.
- [Strict Validation](https://banes-lab.com/records/lex/strict-validation.md): The degree to which rejecting deviant input conflicts with accepting it tolerantly.
- [Verbosity](https://banes-lab.com/records/lex/verbosity.md): The degree to which pervasive defensive checks add verbosity and clutter to the code.
- [At-Least-Once Delivery Safety](https://banes-lab.com/records/lex/at-least-once-delivery-safety.md): The degree to which a message is guaranteed to be delivered at least once, tolerating duplicates.
- [Decoupling](https://banes-lab.com/records/lex/decoupling.md): The degree to which components depend on one another minimally, so each can change independently.
- [Event Reliability](https://banes-lab.com/records/lex/event-reliability.md): The degree to which events are guaranteed to be delivered despite failures.
- [Business Complexity](https://banes-lab.com/records/lex/business-complexity.md): The degree of domain intricacy that a coordination mechanism must accommodate.
- [Delivery Ordering](https://banes-lab.com/records/lex/delivery-ordering.md): The degree to which messages are delivered in a defined order, which broad fan-out can weaken.
- [Duplication with Domain Events](https://banes-lab.com/records/lex/duplication-with-domain-events.md): The degree of overlap between integration events and domain events that must be kept in sync.
- [Event Granularity](https://banes-lab.com/records/lex/event-granularity.md): The degree of coarseness or fineness at which events are defined, trading detail against volume.
- [Event Storm / Traceability](https://banes-lab.com/records/lex/event-storm-traceability.md): The degree to which a high volume of events makes end-to-end flows hard to trace.
- [Global Consistency](https://banes-lab.com/records/lex/global-consistency.md): The degree to which all nodes reflect the same state at once, which service autonomy gives up.
- [Immediate Consistency](https://banes-lab.com/records/lex/immediate-consistency.md): The degree to which a read reflects the latest write instantly, which asynchronous processing defers.
- [Operational Dependency](https://banes-lab.com/records/lex/operational-dependency.md): The degree to which a system's operation depends on a message broker remaining available.
- [Query Complexity](https://banes-lab.com/records/lex/query-complexity.md): The degree of difficulty of answering queries when state is stored as an event history rather than current rows.
- [Relay Complexity](https://banes-lab.com/records/lex/relay-complexity.md): The degree of added complexity of running a relay process that forwards messages from an outbox.
- [State Overhead](https://banes-lab.com/records/lex/state-overhead.md): The degree of extra state a consumer must retain to deduplicate or order messages.
- [Storage Growth](https://banes-lab.com/records/lex/storage-growth.md): The degree to which an append-only log's storage footprint grows unbounded over time.
- [Storage Volume](https://banes-lab.com/records/lex/storage-volume.md): The degree to which retaining a full event stream consumes large amounts of storage.
- [Strong Consistency](https://banes-lab.com/records/lex/strong-consistency.md): The degree to which all reads see the latest write, which event-driven asynchrony relaxes.
- [Strong Immediate Consistency](https://banes-lab.com/records/lex/strong-immediate-consistency.md): The degree to which every read reflects the most recent write without delay, which eventual consistency relaxes.
- [Workflow Complexity](https://banes-lab.com/records/lex/workflow-complexity.md): The degree of intricacy of coordinating a multi-step distributed workflow.
- [Declaration Drift](https://banes-lab.com/records/lex/declaration-drift.md): The degree to which a declared capability set drifts out of sync with the actual behavior.
- [Dynamic Complexity](https://banes-lab.com/records/lex/dynamic-complexity.md): The degree to which interpreting declarative configuration at runtime adds hidden dynamic complexity.
- [Explicitness](https://banes-lab.com/records/lex/explicitness.md): The degree to which relying on conventions reduces the explicitness of how a system is configured.
- [Manifest Drift](https://banes-lab.com/records/lex/manifest-drift.md): The degree to which a manifest drifts out of sync with the components it declares.
- [Metadata Drift](https://banes-lab.com/records/lex/metadata-drift.md): The degree to which self-describing metadata drifts out of sync with the actual system.
- [Payload Verbosity](https://banes-lab.com/records/lex/payload-verbosity.md): The degree to which embedding self-description in responses enlarges their payloads.
- [Self-Description](https://banes-lab.com/records/lex/self-description.md): The degree to which a component exposes its own capabilities and structure for inspection.
- [Size Overhead](https://banes-lab.com/records/lex/size-overhead.md): The degree to which embedding structural descriptions in data increases its size.
- [Safety/Debuggability](https://banes-lab.com/records/lex/safety-debuggability.md): The degree to which treating code as manipulable data can obscure what runs and make it harder to debug.
- [Performance/Safety](https://banes-lab.com/records/lex/performance-safety.md): The degree to which inspecting and dispatching on types at runtime costs performance and bypasses static safety.
- [Self-Describing Systems](https://banes-lab.com/records/lex/self-describing-systems.md): The degree to which a system carries enough metadata to describe its own structure and capabilities at runtime.
- [Build Complexity](https://banes-lab.com/records/lex/build-complexity.md): The degree to which moving work into the build to run at compile time makes the build harder to set up and reason about.
- [Security/Debugging](https://banes-lab.com/records/lex/security-debugging.md): The degree to which generating and running code at runtime widens the attack surface and complicates debugging.
- [Tooling/Maintenance](https://banes-lab.com/records/lex/tooling-maintenance.md): The degree to which owning a custom language burdens a team with building and maintaining its tooling.
- [Toolchain Complexity](https://banes-lab.com/records/lex/toolchain-complexity.md): The degree to which building custom languages adds compilers, parsers, and editors to a project's toolchain.
- [Knowledge Freshness](https://banes-lab.com/records/lex/knowledge-freshness.md): The degree to which a system's knowledge reflects current rather than stale information.
- [Trust](https://banes-lab.com/records/lex/trust.md): The degree to which users are willing to rely on a system's outputs.
- [Capability/Utility](https://banes-lab.com/records/lex/capability-utility.md): The degree of usefulness a model offers, which strict safety limits can constrain.
- [Curation Cost](https://banes-lab.com/records/lex/curation-cost.md): The degree of ongoing effort required to build and maintain a curated knowledge graph.
- [Explainability/Recall](https://banes-lab.com/records/lex/explainability-recall.md): The degree to which retrieval stays explainable and complete, traded against pure similarity ranking.
- [Latency/Cost](https://banes-lab.com/records/lex/latency-cost.md): The degree of latency and expense incurred to serve model predictions.
- [Metric Completeness](https://banes-lab.com/records/lex/metric-completeness.md): The degree to which evaluation metrics capture every dimension of a model's quality.
- [Model Complexity](https://banes-lab.com/records/lex/model-complexity.md): The degree of intricacy in a model, which raises accuracy but lowers explainability.
- [Monitoring Cost](https://banes-lab.com/records/lex/monitoring-cost.md): The degree of ongoing expense of continuously monitoring a deployed model.
- [Retrieval Quality/Latency](https://banes-lab.com/records/lex/retrieval-quality-latency.md): The degree to which retrieval must trade result quality against speed.
- [Cost/Noise](https://banes-lab.com/records/lex/cost-noise.md): The degree to which collecting more telemetry adds cost and noise that can obscure the signals that matter.
- [Noise/Personal Data Leakage](https://banes-lab.com/records/lex/noise-personal-data-leakage.md): The degree to which verbose logging adds noise and risks leaking personal or sensitive data.
- [Alert Noise](https://banes-lab.com/records/lex/alert-noise.md): The degree to which monitoring many signals generates alerts that drown out the meaningful ones.
- [Alert Fatigue](https://banes-lab.com/records/lex/alert-fatigue.md): The degree to which too many alerts desensitize responders, so the ones that matter are ignored.
- [Storage/Privacy](https://banes-lab.com/records/lex/storage-privacy.md): The degree to which retaining a full audit history grows storage and raises privacy concerns.
- [Privacy](https://banes-lab.com/records/lex/privacy.md): The degree to which a system limits the collection and exposure of personal or sensitive information.
- [Metadata Propagation Overhead](https://banes-lab.com/records/lex/metadata-propagation-overhead.md): The degree to which carrying trace metadata through every call adds size and processing cost.
- [Header/Metadata Management](https://banes-lab.com/records/lex/header-metadata-management.md): The degree to which threading correlation identifiers through headers adds handling to every call.
- [Metadata Verbosity](https://banes-lab.com/records/lex/metadata-verbosity.md): The degree to which stamping every event with causation metadata makes the event payload verbose.
- [Overhead/Sampling](https://banes-lab.com/records/lex/overhead-sampling.md): The degree to which tracing every request adds overhead, forcing sampling that can miss rare cases.
- [Feature Velocity](https://banes-lab.com/records/lex/feature-velocity.md): The degree to which holding to strict reliability targets limits how fast new features can ship.
- [Dashboard Sprawl](https://banes-lab.com/records/lex/dashboard-sprawl.md): The degree to which unchecked creation of dashboards scatters attention across too many redundant views.
- [API Surface Growth](https://banes-lab.com/records/lex/api-surface-growth.md): The degree to which adding extension points enlarges the public API that must be kept stable.
- [Constructor Complexity](https://banes-lab.com/records/lex/constructor-complexity.md): The degree to which injecting many dependencies through constructors makes them long and unwieldy.
- [Explicit Dependencies](https://banes-lab.com/records/lex/explicit-dependencies.md): The degree to which a component's dependencies are visible in its signature rather than acquired through hidden lookups.
- [Flag Debt](https://banes-lab.com/records/lex/flag-debt.md): The degree to which stale, unremoved feature flags accumulate and clutter the code over time.
- [Global State](https://banes-lab.com/records/lex/global-state.md): The degree to which a global registry behaves as shared global state that any code can reach.
- [Registry Availability](https://banes-lab.com/records/lex/registry-availability.md): The degree to which the whole system's operation depends on the service registry staying available.
- [Platform Optimization](https://banes-lab.com/records/lex/platform-optimization.md): The degree to which staying portable across platforms forgoes optimizations specific to any one of them.
- [Native Optimization](https://banes-lab.com/records/lex/native-optimization.md): The degree to which staying platform-independent forgoes optimizations native to a specific platform.
- [Image Complexity](https://banes-lab.com/records/lex/image-complexity.md): The degree to which packaging everything into a container image grows the image and its maintenance burden.
- [Innovation/Flexibility](https://banes-lab.com/records/lex/innovation-flexibility.md): The degree to which conforming to an external standard limits the freedom to innovate beyond it.
- [Protocol-Specific Features](https://banes-lab.com/records/lex/protocol-specific-features.md): The degree to which staying protocol-independent forgoes features unique to any one protocol.
- [Config Sprawl](https://banes-lab.com/records/lex/config-sprawl.md): The degree to which externalizing configuration across many sources scatters it and makes it hard to track.
- [Deploy Time](https://banes-lab.com/records/lex/deploy-time.md): The degree to which replacing whole instances rather than patching them in place lengthens deployment time.
- [Availability](https://banes-lab.com/records/lex/availability.md): The proportion of time a system is operational and able to serve requests.
- [Security](https://banes-lab.com/records/lex/security.md): The degree to which a system protects its data and behavior from unauthorized access, misuse, or attack.
- [Simplicity](https://banes-lab.com/records/lex/simplicity.md): The absence of unnecessary structure, keeping a system easy to understand and change.
- [Debuggability](https://banes-lab.com/records/lex/debuggability.md): The ease with which a fault can be located and understood from a system's observable behavior.
- [Maintainability](https://banes-lab.com/records/lex/maintainability.md): The ease with which a system can be corrected, adapted, and extended over its lifetime.
- [Complexity](https://banes-lab.com/records/lex/complexity.md): The degree of interdependence and intricacy that makes a system harder to reason about and change.
- [Fault Isolation](https://banes-lab.com/records/lex/fault-isolation.md): The degree to which a failure in one component is contained and prevented from cascading to others.
- [Architecture Compliance](https://banes-lab.com/records/lex/architecture-compliance.md): The degree to which an implementation conforms to its intended architectural rules, boundaries, and constraints.
- [Coordination Overhead](https://banes-lab.com/records/lex/coordination-overhead.md): The additional cost incurred to synchronize and coordinate concurrent or distributed units of work.
- [Data Integrity](https://banes-lab.com/records/lex/data-integrity.md): The accuracy, consistency, and validity of data maintained over its entire lifecycle.
- [Discoverability](https://banes-lab.com/records/lex/discoverability.md): The ease with which a system's components, capabilities, or endpoints can be found and understood.
- [Mapping Overhead](https://banes-lab.com/records/lex/mapping-overhead.md): The additional cost of translating data or calls between two differing representations or models.
- [Operational Overhead](https://banes-lab.com/records/lex/operational-overhead.md): The ongoing effort and resource cost of deploying, running, and maintaining a system in production.
- [Ordering](https://banes-lab.com/records/lex/ordering.md): The guarantee that events or messages are processed in a well-defined, consistent sequence.
- [Partial Availability](https://banes-lab.com/records/lex/partial-availability.md): The condition in which a system continues serving a subset of its functions while some components are unavailable.
- [Performance](https://banes-lab.com/records/lex/performance.md): The speed, throughput, and resource efficiency with which a system performs its work.
- [Policy Complexity](https://banes-lab.com/records/lex/policy-complexity.md): The difficulty of understanding, maintaining, and reasoning about a policy as its rules multiply.
- [Readability](https://banes-lab.com/records/lex/readability.md): The ease with which source code can be read and understood by a developer.
- [Reliability](https://banes-lab.com/records/lex/reliability.md): The degree to which a system performs its required functions correctly and consistently over time.
- [Resource Efficiency](https://banes-lab.com/records/lex/resource-efficiency.md): The degree to which a system accomplishes its work using minimal computational resources.
- [Retry Safety](https://banes-lab.com/records/lex/retry-safety.md): The property that an operation can be retried without producing duplicate or inconsistent effects.
- [Robustness](https://banes-lab.com/records/lex/robustness.md): The degree to which a system continues to operate correctly under invalid input, stress, or unexpected conditions.
- [Static Safety](https://banes-lab.com/records/lex/static-safety.md): The guarantee that whole classes of errors are caught at compile time, before code runs.
- [Substitutability](https://banes-lab.com/records/lex/substitutability.md): The degree to which a component can be replaced by another honoring the same contract without breaking clients.
- [Team Autonomy](https://banes-lab.com/records/lex/team-autonomy.md): The degree to which a team can make and deliver decisions independently, without cross-team coordination.
- [Tooling Complexity](https://banes-lab.com/records/lex/tooling-complexity.md): The effort required to set up, learn, and maintain the tools a technique or approach depends on.
- [User Experience](https://banes-lab.com/records/lex/user-experience.md): The overall quality of a user's interaction with a system, including responsiveness, clarity, and ease of use.
- [Extensibility](https://banes-lab.com/records/lex/extensibility.md): The degree to which new behavior can be added with minimal change to existing code.
- [Startup Cost](https://banes-lab.com/records/lex/startup-cost.md): The degree to which scanning for components at startup slows the system's initialization.
- [Resource Headroom](https://banes-lab.com/records/lex/resource-headroom.md): The degree of spare capacity remaining on a machine before its resource ceiling is reached.
- [Cost Efficiency](https://banes-lab.com/records/lex/cost-efficiency.md): The degree to which a system delivers its work at the lowest resource cost.
- [Responsiveness](https://banes-lab.com/records/lex/responsiveness.md): The degree to which a system reacts quickly to user actions or requests.
- [Always-Fresh Reads](https://banes-lab.com/records/lex/always-fresh-reads.md): The degree to which every read returns the most recent write, which caching trades away for speed.
- [Constant-Factor Practicality](https://banes-lab.com/records/lex/constant-factor-practicality.md): The degree to which constant factors, ignored by asymptotic analysis, affect measured performance.
- [Cost/Limit](https://banes-lab.com/records/lex/cost-limit.md): The degree to which a bigger single machine costs disproportionately more and eventually hits a hard limit.
- [CPU Cost](https://banes-lab.com/records/lex/cpu-cost.md): The degree of processor time a technique consumes, often traded against memory savings.
- [Cross-Shard Queries](https://banes-lab.com/records/lex/cross-shard-queries.md): The degree of difficulty and cost of a query that must gather data from multiple shards.
- [Distributed Complexity](https://banes-lab.com/records/lex/distributed-complexity.md): The degree of intricacy introduced by spreading work across distributed nodes.
- [Distributed Coordination](https://banes-lab.com/records/lex/distributed-coordination.md): The degree of coordination overhead required to keep distributed instances consistent.
- [Environment Drift](https://banes-lab.com/records/lex/environment-drift.md): The degree to which a test or runtime environment diverges from a reference over time, undermining comparability.
- [Implementation Simplicity](https://banes-lab.com/records/lex/implementation-simplicity.md): The degree to which code stays simple and clear, sometimes traded against maximal efficiency.
- [Measurement Overhead](https://banes-lab.com/records/lex/measurement-overhead.md): The degree of performance cost that the act of measuring imposes on the system being measured.
- [Over-Provisioning](https://banes-lab.com/records/lex/over-provisioning.md): The degree to which allocated capacity exceeds demand, trading waste for safety margin.
- [Read-Your-Writes Consistency](https://banes-lab.com/records/lex/read-your-writes-consistency.md): The degree to which a client is guaranteed to see its own prior writes, which replica lag can break.
- [Readability/Maintainability](https://banes-lab.com/records/lex/readability-maintainability.md): The degree to which code stays readable and maintainable, sometimes sacrificed for performance.
- [Rebalancing Complexity](https://banes-lab.com/records/lex/rebalancing-complexity.md): The degree of difficulty of redistributing data when partitions are added or removed.
- [State Access Latency](https://banes-lab.com/records/lex/state-access-latency.md): The degree of added latency incurred when state is fetched from an external store rather than held locally.
- [Throughput/Batching](https://banes-lab.com/records/lex/throughput-batching.md): The degree to which batching work raises throughput at the cost of per-item latency.
- [Warm-Up Latency](https://banes-lab.com/records/lex/warm-up-latency.md): The degree of delay before newly-added capacity becomes ready to serve traffic.
- [Flexible Input](https://banes-lab.com/records/lex/flexible-input.md): The degree to which strictly validating every payload rejects the loosely-shaped input a caller might legitimately send.
- [Rapid Scripting](https://banes-lab.com/records/lex/rapid-scripting.md): The degree to which requiring explicit types slows the quick, exploratory coding that dynamic typing allows.
- [Bounded Context Autonomy](https://banes-lab.com/records/lex/bounded-context-autonomy.md): The degree to which enforcing one canonical model limits each bounded context's freedom to model its own domain.
- [Bounded Context Purity](https://banes-lab.com/records/lex/bounded-context-purity.md): The degree to which sharing one enterprise data model erodes the conceptual purity of each bounded context.
- [Local Model Autonomy](https://banes-lab.com/records/lex/local-model-autonomy.md): The degree to which a bounded context is free to define and evolve its own data model independently of a shared canonical one.
- [Service-Specific Schemas](https://banes-lab.com/records/lex/service-specific-schemas.md): The degree to which a shared canonical schema competes with each service's need for its own tailored schema.
- [Lossless Preservation](https://banes-lab.com/records/lex/lossless-preservation.md): The degree to which reducing values to a canonical form can discard distinctions the original preserved.
- [Query Performance](https://banes-lab.com/records/lex/query-performance.md): The degree to which splitting data across normalized relations forces costly joins on read.
- [Polysemy Across Contexts](https://banes-lab.com/records/lex/polysemy-across-contexts.md): The degree to which one term legitimately carries different meanings in different bounded contexts.
- [Cross-Context Terminology](https://banes-lab.com/records/lex/cross-context-terminology.md): The degree to which agreeing on shared terms strains against the distinct vocabularies different contexts need.
- [Concise Naming](https://banes-lab.com/records/lex/concise-naming.md): The degree to which naming an interface fully for clarity works against keeping names short.
- [Clever Abstractions](https://banes-lab.com/records/lex/clever-abstractions.md): The degree to which clever, non-obvious abstractions trade familiarity for surprise to the reader.
- [Read Performance](https://banes-lab.com/records/lex/read-performance.md): The degree to which normalizing a schema into many relations forces joins that slow reads.
- [Bounded Session Lifetime](https://banes-lab.com/records/lex/bounded-session-lifetime.md): The degree to which a session's validity is time-limited so that access does not persist indefinitely.
- [Confidentiality](https://banes-lab.com/records/lex/confidentiality.md): The degree to which data is kept secret from all but authorized parties.
- [Confidentiality of Stored Data](https://banes-lab.com/records/lex/confidentiality-of-stored-data.md): The degree to which data held at rest remains unreadable to anyone without authorized access.
- [Integrity](https://banes-lab.com/records/lex/integrity.md): The degree to which data is protected from unauthorized or undetected alteration.
- [Privacy Compliance](https://banes-lab.com/records/lex/privacy-compliance.md): The degree to which a system meets the privacy obligations imposed by law and policy.
- [Reduced Blast Radius](https://banes-lab.com/records/lex/reduced-blast-radius.md): The degree to which the impact of a compromise is confined to a limited scope.
- [Reduced Exploitability](https://banes-lab.com/records/lex/reduced-exploitability.md): The degree to which fewer exposed features leave a system harder to exploit.
- [Reduced Misconfiguration Risk](https://banes-lab.com/records/lex/reduced-misconfiguration-risk.md): The degree to which safe defaults lower the chance of an insecure configuration.
- [Regulatory Alignment](https://banes-lab.com/records/lex/regulatory-alignment.md): The degree to which a system conforms to the laws and regulations that govern it.
- [Secure Configuration](https://banes-lab.com/records/lex/secure-configuration.md): The degree to which a system's settings and secrets are arranged to minimize exposure.
- [Client Complexity](https://banes-lab.com/records/lex/client-complexity.md): The degree of additional effort a protective measure imposes on client implementations.
- [Developer Ergonomics](https://banes-lab.com/records/lex/developer-ergonomics.md): The degree to which a system is convenient and pleasant for developers to work with.
- [Dynamic Query Flexibility](https://banes-lab.com/records/lex/dynamic-query-flexibility.md): The degree of freedom to vary a query's structure at runtime, constrained when inputs must be bound as parameters.
- [Ease of Initial Use](https://banes-lab.com/records/lex/ease-of-initial-use.md): The degree to which a system is easy to start using without upfront configuration.
- [Feature Exposure](https://banes-lab.com/records/lex/feature-exposure.md): The degree to which functionality is made accessible, which broadens capability but enlarges the attack surface.
- [Formatting Flexibility](https://banes-lab.com/records/lex/formatting-flexibility.md): The degree of latitude to present output in varied formats, constrained when encoding must be strict.
- [Input Flexibility](https://banes-lab.com/records/lex/input-flexibility.md): The degree to which a system accepts varied or loosely-structured input, in tension with strict validation.
- [Key Operations](https://banes-lab.com/records/lex/key-operations.md): The degree of operational burden imposed by generating, rotating, and safeguarding cryptographic keys.
- [Latency/Complexity](https://banes-lab.com/records/lex/latency-complexity.md): The degree of added latency and complexity introduced by verifying every request rather than trusting a perimeter.
- [Operational Convenience](https://banes-lab.com/records/lex/operational-convenience.md): The degree to which broad access makes day-to-day operations easier, in tension with least privilege.
- [Pipeline Complexity](https://banes-lab.com/records/lex/pipeline-complexity.md): The degree of intricacy added to a delivery pipeline by embedding continuous checks within it.
- [Role Explosion](https://banes-lab.com/records/lex/role-explosion.md): The degree to which roles proliferate into many narrow definitions as access requirements grow.
- [Speed](https://banes-lab.com/records/lex/speed.md): The degree to which delivery proceeds rapidly, in tension with the caution that managing risk requires.
- [Usability](https://banes-lab.com/records/lex/usability.md): The ease with which users can accomplish their goals with a system.
- [User Convenience](https://banes-lab.com/records/lex/user-convenience.md): The degree to which a system minimizes friction and effort for its users.
- [Automation Risk](https://banes-lab.com/records/lex/automation-risk.md): The degree to which automated self-healing may take incorrect corrective actions without human oversight.
- [False Recovery Actions](https://banes-lab.com/records/lex/false-recovery-actions.md): The degree to which acting on faulty signals leads automated recovery to take wrong or harmful corrective actions.
- [Consistency Lag](https://banes-lab.com/records/lex/consistency-lag.md): The degree to which replicas trail the primary, so reads served from them may return stale data.
- [Cost/Cold Start](https://banes-lab.com/records/lex/cost-cold-start.md): The degree to which scaling capacity up and down incurs added cost and cold-start latency.
- [Horizontal Scalability](https://banes-lab.com/records/lex/horizontal-scalability.md): The degree to which a system can grow by adding more interchangeable instances rather than enlarging one.
- [Unsafe Automation](https://banes-lab.com/records/lex/unsafe-automation.md): The degree to which automating remediation risks taking harmful actions faster than a human can intervene.
- [Data Migration Compatibility](https://banes-lab.com/records/lex/data-migration-compatibility.md): The degree to which reverting code is constrained by forward data migrations that cannot easily be undone.
- [Infrastructure Cost](https://banes-lab.com/records/lex/infrastructure-cost.md): The degree to which running two full parallel environments doubles infrastructure cost during a cutover.
- [Rollout Complexity](https://banes-lab.com/records/lex/rollout-complexity.md): The degree to which staging a release in gradual increments adds orchestration complexity.
- [Production Risk](https://banes-lab.com/records/lex/production-risk.md): The degree to which deliberately injecting faults in production risks causing user-facing incidents.
- [Shutdown Latency](https://banes-lab.com/records/lex/shutdown-latency.md): The degree to which draining in-flight work before exit lengthens the time a shutdown takes.
- [Write Amplification](https://banes-lab.com/records/lex/write-amplification.md): The degree to which maintaining parity on writes multiplies the underlying disk writes for each logical write.
- [Interface Proliferation](https://banes-lab.com/records/lex/interface-proliferation.md): The degree to which splitting interfaces finely multiplies the number of small interfaces to manage.
- [Narrow Specialized Behavior](https://banes-lab.com/records/lex/narrow-specialized-behavior.md): The degree to which honoring a base type's contract constrains a subtype from specializing its own behavior.
- [Ordering/State](https://banes-lab.com/records/lex/ordering-state.md): The degree to which processing an unbounded stream complicates preserving event order and bounded state.
- [Global Optimization](https://banes-lab.com/records/lex/global-optimization.md): The degree to which processing data in a single pass forgoes optimizations that need a full view of the data.
- [Error Propagation/Debugging](https://banes-lab.com/records/lex/error-propagation-debugging.md): The degree to which splitting work into pipeline stages makes an error harder to trace back to its origin.
- [Debuggability/Resource Lifetime](https://banes-lab.com/records/lex/debuggability-resource-lifetime.md): The degree to which deferring computation makes execution order harder to debug and resource lifetimes harder to reason about.
- [Lookup Performance](https://banes-lab.com/records/lex/lookup-performance.md): The degree to which reading strictly in sequence makes locating a specific item by key slow.
- [Complex Grammar/Global State](https://banes-lab.com/records/lex/complex-grammar-global-state.md): The degree to which forbidding backtracking makes complex grammars or global-state logic hard to express.
- [State Coordination](https://banes-lab.com/records/lex/state-coordination.md): The degree to which a data-driven design must still coordinate shared state across concurrent stages.
- [Stateful Business Rules](https://banes-lab.com/records/lex/stateful-business-rules.md): The degree to which rules that inherently depend on accumulated state resist a purely stateless design.
- [Bounded State](https://banes-lab.com/records/lex/bounded-state.md): The degree to which processing keeps its working state within a fixed bound regardless of input size.
- [Late-Data Handling](https://banes-lab.com/records/lex/late-data-handling.md): The degree to which windowing by event time must reckon with events that arrive after their window has closed.
- [Fitness for Purpose](https://banes-lab.com/records/lex/fitness-for-purpose.md): The degree to which the chosen processing model matches the latency and volume the problem needs.
- [Operational Duplication](https://banes-lab.com/records/lex/operational-duplication.md): The degree to which supporting both batch and streaming paths duplicates operational effort and code.
- [Indirection](https://banes-lab.com/records/lex/indirection.md): The degree of extra indirection introduced by separating an abstraction from its implementation.
- [Over-Centralization](https://banes-lab.com/records/lex/over-centralization.md): The degree to which routing all access through one facade concentrates responsibility and can bottleneck change.
- [Stack Debugging](https://banes-lab.com/records/lex/stack-debugging.md): The degree to which layers of wrapping deepen the call stack and complicate debugging.
- [Subsystem Complexity](https://banes-lab.com/records/lex/subsystem-complexity.md): The degree of internal complexity in a subsystem that motivates hiding it behind a facade.
- [Transparency / Debugging](https://banes-lab.com/records/lex/transparency-debugging.md): The degree to which interposing a proxy hides the real object and complicates tracing calls to it.
- [Glob Resolvability](https://banes-lab.com/records/lex/glob-resolvability.md): The degree to which one depth-unanchored pattern resolves every file or every folder of a concern across the whole tree.
- [Placement Predictability](https://banes-lab.com/records/lex/placement-predictability.md): The degree to which a file's correct location is derivable from its role alone, with exactly one legal answer.
- [Naming Expressiveness](https://banes-lab.com/records/lex/naming-expressiveness.md): The degree to which a closed vocabulary limits how precisely the developer can name a file that its declared words do not yet cover.
- [Tree Compactness](https://banes-lab.com/records/lex/tree-compactness.md): The degree to which a small module can stay in few files and folders rather than expanding into one concern folder per role.
- [State Tracking](https://banes-lab.com/records/lex/state-tracking.md): The degree to which making operations idempotent requires tracking processed keys or prior state.
- [Distributed Scalability](https://banes-lab.com/records/lex/distributed-scalability.md): The degree to which enforcing atomic transactions across nodes limits how far a system can scale out.
- [Distributed Availability](https://banes-lab.com/records/lex/distributed-availability.md): The degree to which insisting on strong transactional consistency reduces availability across a distributed system.
- [Durability](https://banes-lab.com/records/lex/durability.md): The degree to which committed data survives crashes and is never lost once acknowledged.
- [Large Transaction Scope](https://banes-lab.com/records/lex/large-transaction-scope.md): The degree to which widening a transaction to cover more work increases contention and failure surface.
- [Repository Complexity](https://banes-lab.com/records/lex/repository-complexity.md): The degree to which coordinating saves through a unit of work adds indirection to the persistence layer.
- [Retry Complexity](https://banes-lab.com/records/lex/retry-complexity.md): The degree to which rejecting conflicting writes pushes retry-and-merge logic onto callers.
- [Deadlocks](https://banes-lab.com/records/lex/deadlocks.md): The degree to which acquiring multiple locks pessimistically risks two holders waiting on each other forever.
- [Lock-Free Throughput](https://banes-lab.com/records/lex/lock-free-throughput.md): The degree to which a design sustains high throughput by coordinating concurrent access without holding locks.
- [Concurrency Safety](https://banes-lab.com/records/lex/concurrency-safety.md): The degree to which isolating state per unit keeps concurrent execution free of races.
- [Data Sharing](https://banes-lab.com/records/lex/data-sharing.md): The degree to which strictly isolating state limits components from directly sharing data.
- [Performance Optimization](https://banes-lab.com/records/lex/performance-optimization.md): The degree to which pushing side effects to the edges can forgo in-place optimizations that mutate for speed.
- [Concurrency Correctness](https://banes-lab.com/records/lex/concurrency-correctness.md): The degree to which concurrent flows produce correct results free of races and lost updates.
- [Deadlock Freedom](https://banes-lab.com/records/lex/deadlock-freedom.md): The degree to which a concurrent design is provably free of states where progress halts permanently.
- [Modeling Overhead](https://banes-lab.com/records/lex/modeling-overhead.md): The degree to which formally modeling concurrency as a net adds effort over writing the code directly.