# Lexicon terms, part 3 of 4

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

## Entries

- [Retrieval Quality/Latency](https://banes-lab.com/records/lexicon/retrieval-quality-latency.md): The degree to which retrieval must trade result quality against speed.
- [Cost/Noise](https://banes-lab.com/records/lexicon/cost-noise.md): The degree to which collecting more telemetry adds cost and noise that can obscure the signals that matter.
- [Incident Diagnosis](https://banes-lab.com/records/lexicon/incident-diagnosis.md): The ability to diagnose the cause of an incident from a system's observable signals.
- [Logs](https://banes-lab.com/records/lexicon/logs.md): A record of discrete, timestamped events a system emits about what it did.
- [Traces](https://banes-lab.com/records/lexicon/traces.md): A record of the path and timing of a request as it moves through a system's components.
- [Incident Analysis](https://banes-lab.com/records/lexicon/incident-analysis.md): The ability to reconstruct and analyze an incident from the events a system logged.
- [Noise/Personal Data Leakage](https://banes-lab.com/records/lexicon/noise-personal-data-leakage.md): The degree to which verbose logging adds noise and risks leaking personal or sensitive data.
- [Structured Events](https://banes-lab.com/records/lexicon/structured-events.md): Log entries emitted as structured, machine-parsable records rather than free-form text.
- [Alert Noise](https://banes-lab.com/records/lexicon/alert-noise.md): The degree to which monitoring many signals generates alerts that drown out the meaningful ones.
- [Blind Operation](https://banes-lab.com/records/lexicon/blind-operation.md): Running a system in production with no monitoring, so problems are noticed only when users report them.
- [Failure Detection](https://banes-lab.com/records/lexicon/failure-detection.md): The ability to detect that a system has failed or degraded by watching its monitored signals.
- [Alert Fatigue](https://banes-lab.com/records/lexicon/alert-fatigue.md): The degree to which too many alerts desensitize responders, so the ones that matter are ignored.
- [Incident Response](https://banes-lab.com/records/lexicon/incident-response.md): Detecting, triaging, and resolving an operational incident once an alert fires.
- [Timely Intervention](https://banes-lab.com/records/lexicon/timely-intervention.md): The ability to intervene on a problem quickly by being alerted the moment it arises.
- [Accountability](https://banes-lab.com/records/lexicon/accountability.md): The ability to attribute every consequential action to the actor responsible for it.
- [Opaque Mutation](https://banes-lab.com/records/lexicon/opaque-mutation.md): Changing state with no record of who changed what or when, so the change cannot be audited.
- [Storage/Privacy](https://banes-lab.com/records/lexicon/storage-privacy.md): The degree to which retaining a full audit history grows storage and raises privacy concerns.
- [Action](https://banes-lab.com/records/lexicon/action.md): A field of an audit record identifying the operation that was performed.
- [Actor](https://banes-lab.com/records/lexicon/actor.md): A field of an audit record identifying who or what performed an action.
- [Forensics](https://banes-lab.com/records/lexicon/forensics.md): The ability to reconstruct after the fact what happened from an immutable audit record.
- [Privacy](https://banes-lab.com/records/lexicon/privacy.md): The degree to which a system limits the collection and exposure of personal or sensitive information.
- [Target](https://banes-lab.com/records/lexicon/target.md): A field of an audit record identifying the resource an action was performed on.
- [Timestamp](https://banes-lab.com/records/lexicon/timestamp.md): A field of an audit record marking when an action occurred.
- [Untracked Mutation](https://banes-lab.com/records/lexicon/untracked-mutation.md): Mutating state without writing an audit entry, so the change leaves no trace.
- [Anonymous Flow](https://banes-lab.com/records/lexicon/anonymous-flow.md): Data or requests flowing through a system with no identifiers, so their path cannot be reconstructed.
- [End-to-End Causality](https://banes-lab.com/records/lexicon/end-to-end-causality.md): The ability to follow a request's cause-and-effect chain across every component it touches.
- [Logs/Traces](https://banes-lab.com/records/lexicon/logs-traces.md): The combined log and trace records that let a request be followed from end to end.
- [Metadata Propagation Overhead](https://banes-lab.com/records/lexicon/metadata-propagation-overhead.md): The degree to which carrying trace metadata through every call adds size and processing cost.
- [Context Propagation](https://banes-lab.com/records/lexicon/context-propagation.md): The requirement that request context be carried across service boundaries so related calls can be correlated.
- [Header/Metadata Management](https://banes-lab.com/records/lexicon/header-metadata-management.md): The degree to which threading correlation identifiers through headers adds handling to every call.
- [Request-Level Traceability](https://banes-lab.com/records/lexicon/request-level-traceability.md): The ability to trace all work belonging to one request by a shared correlation identifier.
- [Uncorrelated Events](https://banes-lab.com/records/lexicon/uncorrelated-events.md): Emitting events with no shared identifier, so those belonging to one request cannot be tied together.
- [Audit Trail](https://banes-lab.com/records/lexicon/audit-trail.md): A chronological record linking each event to the one that caused it.
- [Cause-Effect Reconstruction](https://banes-lab.com/records/lexicon/cause-effect-reconstruction.md): The ability to reconstruct which event triggered which by following causation identifiers.
- [Event Metadata](https://banes-lab.com/records/lexicon/event-metadata.md): Descriptive fields attached to an event, such as its identifiers, timestamps, and causation links.
- [Metadata Verbosity](https://banes-lab.com/records/lexicon/metadata-verbosity.md): The degree to which stamping every event with causation metadata makes the event payload verbose.
- [Unlinked Events](https://banes-lab.com/records/lexicon/unlinked-events.md): Recording events with no link to their cause, so cause-and-effect chains cannot be rebuilt.
- [Latency/Failure Root Cause Analysis](https://banes-lab.com/records/lexicon/latency-failure-root-cause-analysis.md): The ability to pinpoint which service caused a request's latency or failure by tracing it across hops.
- [Opaque Distributed Calls](https://banes-lab.com/records/lexicon/opaque-distributed-calls.md): Calls crossing service boundaries with no tracing, so a request's path and bottlenecks are invisible.
- [Overhead/Sampling](https://banes-lab.com/records/lexicon/overhead-sampling.md): The degree to which tracing every request adds overhead, forcing sampling that can miss rare cases.
- [Trace Context Propagation](https://banes-lab.com/records/lexicon/trace-context-propagation.md): The requirement that trace identifiers be propagated across every hop of a distributed request.
- [Error-Budget Decisions](https://banes-lab.com/records/lexicon/error-budget-decisions.md): The ability to decide how much risk to take by spending against a defined reliability error budget.
- [Feature Velocity](https://banes-lab.com/records/lexicon/feature-velocity.md): The degree to which holding to strict reliability targets limits how fast new features can ship.
- [Vague Reliability Goals](https://banes-lab.com/records/lexicon/vague-reliability-goals.md): Stating reliability aims in vague, unmeasurable terms, so no check can tell whether they are met.
- [At-a-Glance System Health](https://banes-lab.com/records/lexicon/at-a-glance-system-health.md): The ability to see a system's overall health at a glance from a consolidated visual display.
- [Dashboard Sprawl](https://banes-lab.com/records/lexicon/dashboard-sprawl.md): The degree to which unchecked creation of dashboards scatters attention across too many redundant views.
- [Log-Grep-Only Diagnosis](https://banes-lab.com/records/lexicon/log-grep-only-diagnosis.md): Diagnosing problems solely by grepping raw logs, with no aggregated view of system health.
- [Trend Visibility](https://banes-lab.com/records/lexicon/trend-visibility.md): The ability to see how a metric is trending over time from a visualized history.
- [Direct Callback Coupling](https://banes-lab.com/records/lexicon/direct-callback-coupling.md): Wiring a source to notify specific recipients by direct call, coupling it to each one.
- [Direct Method Invocation](https://banes-lab.com/records/lexicon/direct-method-invocation.md): Invoking an operation by direct method call, so it cannot be queued, logged, or undone.
- [Duplicated Workflow](https://banes-lab.com/records/lexicon/duplicated-workflow.md): Repeating the same overall algorithm in many places, each copy re-implementing the shared steps.
- [Exposed Internal Representation](https://banes-lab.com/records/lexicon/exposed-internal-representation.md): Forcing clients to traverse a collection through its internal structure, coupling them to that structure.
- [External State Reach-In](https://banes-lab.com/records/lexicon/external-state-reach-in.md): Reading or writing an object's internal state from outside to snapshot it, breaking its encapsulation.
- [Flat State Explosion](https://banes-lab.com/records/lexicon/flat-state-explosion.md): Enumerating every combination of conditions as a separate flat state, so the state count explodes.
- [Large Conditional Logic](https://banes-lab.com/records/lexicon/large-conditional-logic.md): Selecting behavior with a large branching conditional instead of pluggable strategy objects.
- [Mesh Dependencies](https://banes-lab.com/records/lexicon/mesh-dependencies.md): Letting every object refer directly to every other, forming a dense mesh of point-to-point dependencies.
- [Monolithic Handler](https://banes-lab.com/records/lexicon/monolithic-handler.md): Handling every case in one large handler instead of a chain of focused, single-purpose handlers.
- [Type-Switch Dispatch](https://banes-lab.com/records/lexicon/type-switch-dispatch.md): Dispatching behavior with a switch on an object's type instead of double dispatch through a visitor.
- [Centralized Interaction Logic](https://banes-lab.com/records/lexicon/centralized-interaction-logic.md): The ability to concentrate how a set of objects interact within one mediating component.
- [Controlled Variation](https://banes-lab.com/records/lexicon/controlled-variation.md): The ability to let subclasses vary only the designated steps of a fixed algorithm.
- [Decoupled Notification](https://banes-lab.com/records/lexicon/decoupled-notification.md): The ability to notify interested parties of a change without the source knowing who they are.
- [Deferred Execution](https://banes-lab.com/records/lexicon/deferred-execution.md): The ability to capture a request as an object so it can be run later, held in a queue, or logged.
- [Exhaustive State Reasoning](https://banes-lab.com/records/lexicon/exhaustive-state-reasoning.md): The ability to enumerate and reason about every state a system can occupy and every transition between them.
- [Framework Reuse](https://banes-lab.com/records/lexicon/framework-reuse.md): The ability to reuse a fixed algorithm skeleton across many concrete implementations.
- [Guarded Transitions](https://banes-lab.com/records/lexicon/guarded-transitions.md): The ability to permit a state transition only when a specified condition holds.
- [Hierarchical States](https://banes-lab.com/records/lexicon/hierarchical-states.md): The ability to nest states so shared behavior is defined once on an enclosing state.
- [Lazy Traversal](https://banes-lab.com/records/lexicon/lazy-traversal.md): The ability to produce a collection's elements one at a time on demand rather than all at once.
- [Null-Check Elimination](https://banes-lab.com/records/lexicon/null-check-elimination.md): The ability to remove scattered null checks by substituting a benign do-nothing object.
- [Operation Extension Without Element Change](https://banes-lab.com/records/lexicon/operation-extension-without-element-change.md): The ability to add new operations over a structure without modifying its element classes.
- [Ordered Fallthrough](https://banes-lab.com/records/lexicon/ordered-fallthrough.md): The ability to offer a request to handlers in sequence until one of them accepts it.
- [Parallel Regions](https://banes-lab.com/records/lexicon/parallel-regions.md): The ability to model concurrently-active, independent regions of state within one machine.
- [Pluggable Handling](https://banes-lab.com/records/lexicon/pluggable-handling.md): The ability to add or reorder request handlers without changing the ones already in the chain.
- [Runtime Behavior Selection](https://banes-lab.com/records/lexicon/runtime-behavior-selection.md): The ability to choose among interchangeable algorithms at runtime.
- [Snapshot/Restore](https://banes-lab.com/records/lexicon/snapshot-restore.md): The ability to capture an object's state and later restore it to that captured point.
- [State-Local Behavior](https://banes-lab.com/records/lexicon/state-local-behavior.md): The ability to attach behavior to each state so an object acts according to its current state.
- [Structure-Agnostic Iteration](https://banes-lab.com/records/lexicon/structure-agnostic-iteration.md): The ability to traverse a collection without depending on how it is internally organized.
- [Fail-Safe Defaults](https://banes-lab.com/records/lexicon/fail-safe-defaults.md): Defaulting to safe, benign behavior when a value or handler is absent rather than failing or branching.
- [Explicit State Model](https://banes-lab.com/records/lexicon/explicit-state-model.md): The requirement that an object's states and their transitions be modeled explicitly.
- [Explicit State Set](https://banes-lab.com/records/lexicon/explicit-state-set.md): The requirement that the complete set of possible states be defined up front.
- [Interchangeable Algorithms](https://banes-lab.com/records/lexicon/interchangeable-algorithms.md): The requirement that competing algorithms share one interface so they can be swapped freely.
- [Shared Behavioral Interface](https://banes-lab.com/records/lexicon/shared-behavioral-interface.md): The requirement that the real object and its null stand-in implement one common interface.
- [Stable Algorithm Skeleton](https://banes-lab.com/records/lexicon/stable-algorithm-skeleton.md): The requirement that the overall algorithm's structure stay fixed while specific steps vary.
- [Stable Element Hierarchy](https://banes-lab.com/records/lexicon/stable-element-hierarchy.md): The requirement that the set of element types stay fixed so new operations can be added over them.
- [Subject/Subscriber Contract](https://banes-lab.com/records/lexicon/subject-subscriber-contract.md): The requirement of an agreed interface by which subjects notify and subscribers receive updates.
- [Uniform Handler Interface](https://banes-lab.com/records/lexicon/uniform-handler-interface.md): The requirement that every handler in a chain share one interface so requests pass along uniformly.
- [Uniform Traversal Interface](https://banes-lab.com/records/lexicon/uniform-traversal-interface.md): The requirement that collections expose one common interface for stepping through their elements.
- [Class Count](https://banes-lab.com/records/lexicon/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/lexicon/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/lexicon/coordination-complexity.md): The degree of complexity in how objects must coordinate, which motivates a mediator.
- [Element Stability](https://banes-lab.com/records/lexicon/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/lexicon/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/lexicon/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/lexicon/memory-footprint.md): The degree of memory consumed by retaining state snapshots for later restoration.
- [Silent No-Op Risk](https://banes-lab.com/records/lexicon/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/lexicon/state-explosion.md): The degree to which the number of explicit states grows unmanageably as conditions multiply.
- [Complex Factory Hierarchies](https://banes-lab.com/records/lexicon/complex-factory-hierarchies.md): Building elaborate parallel factory class hierarchies where cloning an existing configured instance would suffice.
- [Concrete Constructor Coupling](https://banes-lab.com/records/lexicon/concrete-constructor-coupling.md): Instantiating concrete classes directly with constructors, coupling callers to specific implementations.
- [Global Mutable State](https://banes-lab.com/records/lexicon/global-mutable-state.md): Exposing global variables that any code can mutate, creating hidden coupling and nondeterminism.
- [Mixed Product Families](https://banes-lab.com/records/lexicon/mixed-product-families.md): Combining products from different incompatible families, producing inconsistent sets of objects.
- [Scattered Construction Logic](https://banes-lab.com/records/lexicon/scattered-construction-logic.md): Spreading object-creation logic across many call sites instead of centralizing it in a factory.
- [Telescoping Constructor](https://banes-lab.com/records/lexicon/telescoping-constructor.md): Overloading constructors with ever more parameters to cover optional fields, producing unreadable call sites.
- [Controlled Instantiation](https://banes-lab.com/records/lexicon/controlled-instantiation.md): The ability to govern how and when an object is created.
- [Deferred Instantiation](https://banes-lab.com/records/lexicon/deferred-instantiation.md): The ability to let subclasses decide which class to instantiate, deferring the choice from the base class.
- [Dynamic Object Creation](https://banes-lab.com/records/lexicon/dynamic-object-creation.md): The ability to create new objects at runtime by cloning existing configured instances.
- [Family-Level Replacement](https://banes-lab.com/records/lexicon/family-level-replacement.md): The ability to swap an entire family of related products by changing a single factory.
- [Polymorphic Construction](https://banes-lab.com/records/lexicon/polymorphic-construction.md): The ability to create objects through a common interface without naming their concrete classes.
- [Shared Resource Access](https://banes-lab.com/records/lexicon/shared-resource-access.md): The ability to give many callers coordinated access to one shared resource.
- [Valid Object Creation](https://banes-lab.com/records/lexicon/valid-object-creation.md): The ability to construct an object only once all its required parts are supplied and validated.
- [Cloneable Template Object](https://banes-lab.com/records/lexicon/cloneable-template-object.md): The requirement that a prototype object support being copied to produce new instances.
- [Creation Variation](https://banes-lab.com/records/lexicon/creation-variation.md): A precondition that different variants of a product must be produced depending on runtime context.
- [Related Product Variants](https://banes-lab.com/records/lexicon/related-product-variants.md): The requirement that products form families of related variants meant to be used together.
- [Single-Instance Need](https://banes-lab.com/records/lexicon/single-instance-need.md): A precondition that exactly one instance of a type must exist across the system.
- [Subclass-Controlled Creation](https://banes-lab.com/records/lexicon/subclass-controlled-creation.md): The requirement that subclasses determine which concrete product a creator instantiates.
- [Complex Construction](https://banes-lab.com/records/lexicon/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/lexicon/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/lexicon/inheritance-complexity.md): The degree to which relying on subclassing to vary creation adds to the inheritance hierarchy's complexity.
- [Cartesian Inheritance Explosion](https://banes-lab.com/records/lexicon/cartesian-inheritance-explosion.md): Modeling every combination of two independent dimensions as its own subclass, so the class count grows multiplicatively.
- [Direct Access](https://banes-lab.com/records/lexicon/direct-access.md): Reaching a resource directly with no intermediary, bypassing the access control, caching, or laziness a proxy would add.
- [Direct External Coupling](https://banes-lab.com/records/lexicon/direct-external-coupling.md): Coupling code directly to an incompatible external interface, spreading its idiosyncrasies through the codebase.
- [Leaf-vs-Container Special-Casing](https://banes-lab.com/records/lexicon/leaf-vs-container-special-casing.md): Branching client code on whether an element is a leaf or a container instead of treating them through one interface.
- [Leaky Subsystem API](https://banes-lab.com/records/lexicon/leaky-subsystem-api.md): Exposing a subsystem's internal complexity directly to clients instead of hiding it behind a simplifying interface.
- [Per-Instance Duplicate State](https://banes-lab.com/records/lexicon/per-instance-duplicate-state.md): Storing identical shared state separately in every object instance, wasting memory at high object counts.
- [Subclass Explosion](https://banes-lab.com/records/lexicon/subclass-explosion.md): Creating a distinct subclass for every combination of optional features instead of composing them at runtime.
- [High-Cardinality Object Reuse](https://banes-lab.com/records/lexicon/high-cardinality-object-reuse.md): The ability to represent large numbers of similar objects economically by sharing their common intrinsic state.
- [Implementation Swap](https://banes-lab.com/records/lexicon/implementation-swap.md): The ability to change an abstraction's underlying implementation without altering the abstraction itself.
- [Lazy Load](https://banes-lab.com/records/lexicon/lazy-load.md): The ability to defer creating or loading a costly resource until it is first used.
- [Leaf/Composite Transparency](https://banes-lab.com/records/lexicon/leaf-composite-transparency.md): The ability to treat individual objects and compositions of objects through one uniform interface.
- [Recursive Composition](https://banes-lab.com/records/lexicon/recursive-composition.md): The ability to build tree structures in which composites contain other composites to arbitrary depth.
- [Runtime Behavior Extension](https://banes-lab.com/records/lexicon/runtime-behavior-extension.md): The ability to add responsibilities to an object dynamically at runtime by wrapping it.
- [Shared Immutable State](https://banes-lab.com/records/lexicon/shared-immutable-state.md): The ability to safely share one immutable state object across many contexts at once.
- [Simplified Access](https://banes-lab.com/records/lexicon/simplified-access.md): The ability to use a complex subsystem through a small, convenient interface.
- [Remote Stub](https://banes-lab.com/records/lexicon/remote-stub.md): A local stand-in object that forwards calls to an object living in another process or machine.
- [Common Interface](https://banes-lab.com/records/lexicon/common-interface.md): The requirement that a wrapper and the object it wraps share one interface so they remain interchangeable.
- [Incompatible Interfaces](https://banes-lab.com/records/lexicon/incompatible-interfaces.md): A precondition of two interfaces that must cooperate yet expose mismatched signatures.
- [Independent Variation Axes](https://banes-lab.com/records/lexicon/independent-variation-axes.md): The requirement that an abstraction and its implementation vary along separate axes so they can be decoupled.
- [Separable Intrinsic State](https://banes-lab.com/records/lexicon/separable-intrinsic-state.md): The requirement that an object's shared, context-independent state be separable from its per-use state.
- [Uniform Component Interface](https://banes-lab.com/records/lexicon/uniform-component-interface.md): The requirement that leaves and composites implement one shared interface so clients treat them alike.
- [Indirection](https://banes-lab.com/records/lexicon/indirection.md): The degree of extra indirection introduced by separating an abstraction from its implementation.
- [Over-Centralization](https://banes-lab.com/records/lexicon/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/lexicon/stack-debugging.md): The degree to which layers of wrapping deepen the call stack and complicate debugging.
- [Subsystem Complexity](https://banes-lab.com/records/lexicon/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/lexicon/transparency-debugging.md): The degree to which interposing a proxy hides the real object and complicates tracing calls to it.
- [Anecdotal Performance Claims](https://banes-lab.com/records/lexicon/anecdotal-performance-claims.md): Asserting performance characteristics from anecdote or intuition rather than measured evidence.
- [Anecdotal Timing](https://banes-lab.com/records/lexicon/anecdotal-timing.md): Judging how fast code runs from casual observation instead of controlled measurement.
- [Bottlenecks](https://banes-lab.com/records/lexicon/bottlenecks.md): A single stage that constrains overall throughput because all work must pass through it.
- [Fixed Provisioning](https://banes-lab.com/records/lexicon/fixed-provisioning.md): Allocating a static amount of capacity regardless of demand, so the system is either starved or wasteful.
- [Fixed-Capacity Design](https://banes-lab.com/records/lexicon/fixed-capacity-design.md): Building a system around a fixed capacity ceiling that cannot grow when load increases.
- [Full Materialization](https://banes-lab.com/records/lexicon/full-materialization.md): Loading an entire dataset into memory at once when streaming or chunking would suffice, risking exhaustion.
- [Global Shared State](https://banes-lab.com/records/lexicon/global-shared-state.md): A single mutable state shared across all workers, forcing coordination and preventing independent scaling.
- [Guess-Based Capacity](https://banes-lab.com/records/lexicon/guess-based-capacity.md): Sizing capacity from guesswork rather than a model of arrival and service rates.
- [Guess-Based Optimization](https://banes-lab.com/records/lexicon/guess-based-optimization.md): Optimizing based on assumptions about where time is spent rather than profiling evidence.
- [Guesswork](https://banes-lab.com/records/lexicon/guesswork.md): Deciding where to optimize by intuition instead of measured profiling data.
- [Hard Resource Ceiling](https://banes-lab.com/records/lexicon/hard-resource-ceiling.md): A fixed upper bound on a single machine's resources that caps how far vertical scaling can go.
- [Inefficient Algorithm Choice](https://banes-lab.com/records/lexicon/inefficient-algorithm-choice.md): Selecting an algorithm whose complexity scales poorly for the expected input size.
- [Instance Affinity](https://banes-lab.com/records/lexicon/instance-affinity.md): Binding a client to a specific server instance for its state, preventing free rebalancing across instances.
- [Instance-Local State](https://banes-lab.com/records/lexicon/instance-local-state.md): Holding request-spanning state on one instance, so requests cannot be served by any other instance.
- [Local Micro-Optimization](https://banes-lab.com/records/lexicon/local-micro-optimization.md): Tuning a non-bottleneck section for marginal gains while the constraint that limits performance goes unaddressed.
- [Long Blocking Work](https://banes-lab.com/records/lexicon/long-blocking-work.md): Performing lengthy synchronous work on a request path, blocking it and inflating latency.
- [Origin-Only Serving](https://banes-lab.com/records/lexicon/origin-only-serving.md): Serving all content directly from the origin with no edge caching, concentrating load and adding distance latency.
- [Premature Optimization](https://banes-lab.com/records/lexicon/premature-optimization.md): Optimizing code before evidence shows it matters, adding complexity for gains that may never be needed.
- [Resource Waste/Saturation](https://banes-lab.com/records/lexicon/resource-waste-saturation.md): Running resources far below or far above healthy utilization, either wasting capacity or saturating it.
- [Sequential Bottleneck](https://banes-lab.com/records/lexicon/sequential-bottleneck.md): A portion of work that must run serially, capping the speedup that parallelism can achieve.
- [Single Monolithic Store](https://banes-lab.com/records/lexicon/single-monolithic-store.md): Concentrating all data in one store that cannot be partitioned, capping write and storage scalability.
- [Single Target Routing](https://banes-lab.com/records/lexicon/single-target-routing.md): Directing all traffic to one target instead of distributing it, wasting capacity and creating a bottleneck.
- [Single-Primary Read Contention](https://banes-lab.com/records/lexicon/single-primary-read-contention.md): Serving all reads from the single primary, so read load contends with writes and limits throughput.
- [Unbounded Access](https://banes-lab.com/records/lexicon/unbounded-access.md): Permitting callers to make unlimited requests with no rate limit, allowing overload and abuse.
- [Unbounded Memory Growth](https://banes-lab.com/records/lexicon/unbounded-memory-growth.md): Accumulating state without bound so memory usage grows until the process exhausts it.
- [Unbounded Runtime Growth](https://banes-lab.com/records/lexicon/unbounded-runtime-growth.md): An algorithm whose running time grows without bound as input scales, becoming infeasible at size.
- [Arrival and Service Rates](https://banes-lab.com/records/lexicon/arrival-and-service-rates.md): The measured rates at which requests arrive and at which a server completes them, the inputs a queuing model needs.
- [Bottleneck Awareness](https://banes-lab.com/records/lexicon/bottleneck-awareness.md): The ability to recognize which component limits a system's overall throughput.
- [Bottleneck Evidence](https://banes-lab.com/records/lexicon/bottleneck-evidence.md): Measured data identifying which component constrains performance, justifying where to optimize.
- [Cacheable Content](https://banes-lab.com/records/lexicon/cacheable-content.md): The requirement that content be stable enough to serve from a cache without harmful staleness.
- [Capacity Model](https://banes-lab.com/records/lexicon/capacity-model.md): A representation of how a system's capacity responds to load, used to predict its limits.
- [Complexity Awareness](https://banes-lab.com/records/lexicon/complexity-awareness.md): The ability to reason about how an algorithm's cost grows with input size.
- [Complexity Model](https://banes-lab.com/records/lexicon/complexity-model.md): A representation of how an algorithm's resource use scales with input size.
- [Externalized State](https://banes-lab.com/records/lexicon/externalized-state.md): The requirement that session or request state be held outside the serving instance, in a shared store.
- [Input Size Model](https://banes-lab.com/records/lexicon/input-size-model.md): A representation of the input dimension against which an algorithm's running time is measured.
- [Invalidation Policy](https://banes-lab.com/records/lexicon/invalidation-policy.md): The rules determining when cached entries are considered stale and must be refreshed or evicted.
- [Load Model](https://banes-lab.com/records/lexicon/load-model.md): A representation of the expected volume and pattern of demand a system must handle.
- [Memory Model](https://banes-lab.com/records/lexicon/memory-model.md): A representation of how an algorithm's memory use grows with input size.
- [Multiple Targets](https://banes-lab.com/records/lexicon/multiple-targets.md): The precondition that more than one interchangeable backend exists across which traffic can be spread.
- [Partition Key](https://banes-lab.com/records/lexicon/partition-key.md): The field whose value determines which shard or partition a record belongs to.
- [Partition Strategy](https://banes-lab.com/records/lexicon/partition-strategy.md): A scheme for dividing data or work across independent partitions to distribute load and enable parallelism.
- [Quota Policy](https://banes-lab.com/records/lexicon/quota-policy.md): The declared limits on how many requests a caller may make within a time window.
- [Repeatable Test Environment](https://banes-lab.com/records/lexicon/repeatable-test-environment.md): A controlled, reproducible environment in which measurements can be compared meaningfully across runs.
- [Representative Workload](https://banes-lab.com/records/lexicon/representative-workload.md): A workload that reflects production usage closely enough that measurements generalize.
- [Resource Headroom](https://banes-lab.com/records/lexicon/resource-headroom.md): The degree of spare capacity remaining on a machine before its resource ceiling is reached.
- [Space Complexity Awareness](https://banes-lab.com/records/lexicon/space-complexity-awareness.md): The ability to reason about how an algorithm's memory use grows with input size.
- [Statelessness or Shared State Strategy](https://banes-lab.com/records/lexicon/statelessness-or-shared-state-strategy.md): A decision to make instances stateless or externalize state to a shared store, so any instance can serve any request.
- [Abuse/Overload Protection](https://banes-lab.com/records/lexicon/abuse-overload-protection.md): The ability to shield a system from abusive or excessive request volume.
- [Bottleneck Detection](https://banes-lab.com/records/lexicon/bottleneck-detection.md): The ability to locate the component that most constrains overall performance.
- [Capacity Increase without Distribution](https://banes-lab.com/records/lexicon/capacity-increase-without-distribution.md): The ability to raise capacity by enlarging a single machine rather than adding more machines.
- [Comparative Analysis](https://banes-lab.com/records/lexicon/comparative-analysis.md): The ability to compare algorithms by how their cost grows, independent of hardware.
- [Cost Efficiency](https://banes-lab.com/records/lexicon/cost-efficiency.md): The degree to which a system delivers its work at the lowest resource cost.
- [Dynamic Capacity](https://banes-lab.com/records/lexicon/dynamic-capacity.md): The ability to add or remove capacity automatically as demand rises and falls.
- [Efficient Processing](https://banes-lab.com/records/lexicon/efficient-processing.md): The ability to complete work using the fewest operations and least resource for the input.
- [Geographically-Local Delivery](https://banes-lab.com/records/lexicon/geographically-local-delivery.md): The ability to serve content from a location near the user, cutting distance latency.
- [Growth Handling](https://banes-lab.com/records/lexicon/growth-handling.md): The ability to absorb increasing load without redesign.
- [Large Dataset Scaling](https://banes-lab.com/records/lexicon/large-dataset-scaling.md): The ability to grow storage and throughput by spreading a dataset across many shards.
- [Latency Reduction](https://banes-lab.com/records/lexicon/latency-reduction.md): The ability to lower response time by serving results from a nearer or faster source.
- [Load Handling](https://banes-lab.com/records/lexicon/load-handling.md): The ability to process a high volume of work without degrading.
- [Memory Scalability](https://banes-lab.com/records/lexicon/memory-scalability.md): The ability to handle larger inputs without memory use growing prohibitively.
- [Multi-Core Utilization](https://banes-lab.com/records/lexicon/multi-core-utilization.md): The ability to use multiple processor cores simultaneously for a single workload.
- [Origin Offload](https://banes-lab.com/records/lexicon/origin-offload.md): The ability to relieve the origin server by serving cached copies from the edge.
- [Overlapping Work](https://banes-lab.com/records/lexicon/overlapping-work.md): The ability to make progress on multiple tasks over the same period by interleaving them.
- [Read Traffic Offload](https://banes-lab.com/records/lexicon/read-traffic-offload.md): The ability to divert read queries to replicas, relieving the primary.
- [Reduced Load](https://banes-lab.com/records/lexicon/reduced-load.md): The ability to lessen work reaching a backend by serving repeat results from a cache.
- [Regression Detection](https://banes-lab.com/records/lexicon/regression-detection.md): The ability to catch a performance regression by comparing measurements against a baseline.
- [Responsiveness](https://banes-lab.com/records/lexicon/responsiveness.md): The degree to which a system reacts quickly to user actions or requests.
- [Scalability Analysis](https://banes-lab.com/records/lexicon/scalability-analysis.md): The activity of assessing how a system's cost grows as load or input increases.
- [Scale-Out](https://banes-lab.com/records/lexicon/scale-out.md): The ability to add capacity by adding more machines that share the load.
- [Targeted Improvement](https://banes-lab.com/records/lexicon/targeted-improvement.md): The ability to direct optimization effort at the specific constraint that limits performance.
- [Traffic Distribution](https://banes-lab.com/records/lexicon/traffic-distribution.md): The ability to spread incoming requests across multiple backends evenly.
- [Utilization-Based Sizing](https://banes-lab.com/records/lexicon/utilization-based-sizing.md): The ability to size capacity from measured utilization and wait-time targets.
- [Wait-Time Prediction](https://banes-lab.com/records/lexicon/wait-time-prediction.md): The ability to predict how long work will wait given arrival and service rates.
- [Always-Fresh Reads](https://banes-lab.com/records/lexicon/always-fresh-reads.md): The degree to which every read returns the most recent write, which caching trades away for speed.
- [Cache Invalidation](https://banes-lab.com/records/lexicon/cache-invalidation.md): The activity of removing or refreshing cached entries so stale data is not served.
- [Constant-Factor Practicality](https://banes-lab.com/records/lexicon/constant-factor-practicality.md): The degree to which constant factors, ignored by asymptotic analysis, affect measured performance.
- [Cost/Limit](https://banes-lab.com/records/lexicon/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/lexicon/cpu-cost.md): The degree of processor time a technique consumes, often traded against memory savings.
- [Cross-Shard Queries](https://banes-lab.com/records/lexicon/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/lexicon/distributed-complexity.md): The degree of intricacy introduced by spreading work across distributed nodes.
- [Distributed Coordination](https://banes-lab.com/records/lexicon/distributed-coordination.md): The degree of coordination overhead required to keep distributed instances consistent.
- [Environment Drift](https://banes-lab.com/records/lexicon/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/lexicon/implementation-simplicity.md): The degree to which code stays simple and clear, sometimes traded against maximal efficiency.
- [Measurement Overhead](https://banes-lab.com/records/lexicon/measurement-overhead.md): The degree of performance cost that the act of measuring imposes on the system being measured.
- [Model Assumptions](https://banes-lab.com/records/lexicon/model-assumptions.md): The simplifying premises a performance model depends on, which limit how well it matches reality.
- [Over-Provisioning](https://banes-lab.com/records/lexicon/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/lexicon/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/lexicon/readability-maintainability.md): The degree to which code stays readable and maintainable, sometimes sacrificed for performance.
- [Rebalancing Complexity](https://banes-lab.com/records/lexicon/rebalancing-complexity.md): The degree of difficulty of redistributing data when partitions are added or removed.
- [Session Affinity](https://banes-lab.com/records/lexicon/session-affinity.md): Routing all of a client's requests to the same server instance so its session state stays local.
- [State Access Latency](https://banes-lab.com/records/lexicon/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/lexicon/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/lexicon/warm-up-latency.md): The degree of delay before newly-added capacity becomes ready to serve traffic.
- [Batch-Only Processing](https://banes-lab.com/records/lexicon/batch-only-processing.md): Processing data in scheduled batches rather than as a continuous low-latency stream.
- [Ordering/State](https://banes-lab.com/records/lexicon/ordering-state.md): The degree to which processing an unbounded stream complicates preserving event order and bounded state.
- [Forward-Only State Model](https://banes-lab.com/records/lexicon/forward-only-state-model.md): The requirement that processing keep only forward-moving state, never needing to revisit earlier input.
- [Global Optimization](https://banes-lab.com/records/lexicon/global-optimization.md): The degree to which processing data in a single pass forgoes optimizations that need a full view of the data.
- [Multi-Pass Full Materialization](https://banes-lab.com/records/lexicon/multi-pass-full-materialization.md): Loading a full dataset into memory and traversing it in multiple passes, rather than in a single streaming pass.
- [Error Propagation/Debugging](https://banes-lab.com/records/lexicon/error-propagation-debugging.md): The degree to which splitting work into pipeline stages makes an error harder to trace back to its origin.
- [Monolithic Processing Function](https://banes-lab.com/records/lexicon/monolithic-processing-function.md): One large function that performs every processing step at once, so stages cannot be tested or reused independently.
- [Stage Contracts](https://banes-lab.com/records/lexicon/stage-contracts.md): The requirement that each pipeline stage declare a typed contract for what it consumes and produces.
- [Stepwise Transformation](https://banes-lab.com/records/lexicon/stepwise-transformation.md): The ability to transform data through a sequence of small, composable stages.
- [Streaming](https://banes-lab.com/records/lexicon/streaming.md): The ability to process data continuously as it arrives rather than in complete batches.
- [Avoiding Unneeded Work](https://banes-lab.com/records/lexicon/avoiding-unneeded-work.md): The ability to skip computing results that are never used.
- [Debuggability/Resource Lifetime](https://banes-lab.com/records/lexicon/debuggability-resource-lifetime.md): The degree to which deferring computation makes execution order harder to debug and resource lifetimes harder to reason about.
- [Deferred Execution Semantics](https://banes-lab.com/records/lexicon/deferred-execution-semantics.md): The requirement that a computation's semantics defer its work until the result is demanded.
- [Eager Full Materialization](https://banes-lab.com/records/lexicon/eager-full-materialization.md): Computing and materializing a complete result up front, rather than deferring computation until parts are needed.
- [Large Data Processing](https://banes-lab.com/records/lexicon/large-data-processing.md): The ability to process datasets larger than memory by reading them in order, a piece at a time.
- [Lookup Performance](https://banes-lab.com/records/lexicon/lookup-performance.md): The degree to which reading strictly in sequence makes locating a specific item by key slow.
- [Ordered Read Model](https://banes-lab.com/records/lexicon/ordered-read-model.md): The requirement that data be read in a fixed forward order rather than by arbitrary index.
- [Random Access Requirement](https://banes-lab.com/records/lexicon/random-access-requirement.md): A need to read arbitrary items by position or key on demand rather than strictly in sequence.
- [Backtracking Algorithm](https://banes-lab.com/records/lexicon/backtracking-algorithm.md): A method that explores options and reverts to an earlier point when one fails, requiring the ability to look back.
- [Complex Grammar/Global State](https://banes-lab.com/records/lexicon/complex-grammar-global-state.md): The degree to which forbidding backtracking makes complex grammars or global-state logic hard to express.
- [Streaming Parsers](https://banes-lab.com/records/lexicon/streaming-parsers.md): The ability to parse input incrementally as it streams in, without buffering the whole document.
- [Control-Flow-Centric Monolith](https://banes-lab.com/records/lexicon/control-flow-centric-monolith.md): A monolith driven by imperative control flow rather than data dependencies, so stages cannot run or scale independently.
- [Data Dependencies](https://banes-lab.com/records/lexicon/data-dependencies.md): The requirement that the data each stage needs from others be declared as explicit dependencies.
- [Parallel/Stream Processing](https://banes-lab.com/records/lexicon/parallel-stream-processing.md): The ability to run independent stages in parallel or stream data between them as it is produced.
- [Stages](https://banes-lab.com/records/lexicon/stages.md): The requirement that processing be decomposed into discrete stages connected by data flow.
- [State Coordination](https://banes-lab.com/records/lexicon/state-coordination.md): The degree to which a data-driven design must still coordinate shared state across concurrent stages.
- [No Hidden State](https://banes-lab.com/records/lexicon/no-hidden-state.md): The requirement that a processor keep no state between invocations, so each call starts afresh from what it is given.
- [Parallel Processing](https://banes-lab.com/records/lexicon/parallel-processing.md): The ability to process many records at once because each is handled independently of the others.
- [Stateful Business Rules](https://banes-lab.com/records/lexicon/stateful-business-rules.md): The degree to which rules that inherently depend on accumulated state resist a purely stateless design.
- [Stateful Hidden Accumulation](https://banes-lab.com/records/lexicon/stateful-hidden-accumulation.md): Accumulating state inside a processor across records, so results depend on invisible history.
- [Bounded Aggregation over Unbounded Streams](https://banes-lab.com/records/lexicon/bounded-aggregation-over-unbounded-streams.md): The ability to aggregate an endless stream by grouping its events into bounded windows.
- [Bounded State](https://banes-lab.com/records/lexicon/bounded-state.md): The degree to which processing keeps its working state within a fixed bound regardless of input size.
- [Event Time](https://banes-lab.com/records/lexicon/event-time.md): The time at which an event occurred, carried on the event and used to assign it to a window.
- [Late-Data Handling](https://banes-lab.com/records/lexicon/late-data-handling.md): The degree to which windowing by event time must reckon with events that arrive after their window has closed.
- [Unbounded Accumulation](https://banes-lab.com/records/lexicon/unbounded-accumulation.md): Aggregating an endless stream into ever-growing state that eventually exhausts memory.
- [Parallel Branch Processing](https://banes-lab.com/records/lexicon/parallel-branch-processing.md): The ability to process independent branches of work simultaneously across workers.
- [Result Aggregation](https://banes-lab.com/records/lexicon/result-aggregation.md): The ability to combine the outputs of parallel branches back into a single result.
- [Serial Item Processing](https://banes-lab.com/records/lexicon/serial-item-processing.md): Processing independent items one at a time in sequence, rather than in parallel.
- [Fitness for Purpose](https://banes-lab.com/records/lexicon/fitness-for-purpose.md): The degree to which the chosen processing model matches the latency and volume the problem needs.
- [Latency Requirement Clarity](https://banes-lab.com/records/lexicon/latency-requirement-clarity.md): The requirement that a workload's latency and freshness needs be made explicit before a processing model is chosen.
- [Latency-Appropriate Processing Model](https://banes-lab.com/records/lexicon/latency-appropriate-processing-model.md): The ability to choose batch or stream processing to match a workload's latency needs.
- [One-Size-Fits-All Processing](https://banes-lab.com/records/lexicon/one-size-fits-all-processing.md): Forcing every workload through a single processing model regardless of its latency or volume needs.
- [Operational Duplication](https://banes-lab.com/records/lexicon/operational-duplication.md): The degree to which supporting both batch and streaming paths duplicates operational effort and code.
- [Closed Core](https://banes-lab.com/records/lexicon/closed-core.md): A core that cannot be extended without modifying its own source, so every addition edits the core.
- [Direct Control Ownership](https://banes-lab.com/records/lexicon/direct-control-ownership.md): Application code driving the overall control flow itself instead of ceding it to a framework or container.
- [Direct Reference](https://banes-lab.com/records/lexicon/direct-reference.md): Referring to a specific implementation directly instead of looking it up through a registry.
- [Hardcoded Branch Constant](https://banes-lab.com/records/lexicon/hardcoded-branch-constant.md): Controlling a feature with a hardcoded constant in the code instead of an externally-managed flag.
- [Hardcoded Extensions](https://banes-lab.com/records/lexicon/hardcoded-extensions.md): Wiring extensions directly into the core so adding one requires editing and rebuilding the core.
- [Hardcoded Instantiation](https://banes-lab.com/records/lexicon/hardcoded-instantiation.md): Creating dependencies with hardcoded constructors inside a class instead of injecting them.
- [Hardcoded Lookup](https://banes-lab.com/records/lexicon/hardcoded-lookup.md): Hardcoding a service's address or instance instead of resolving it through a registry.
- [Continuous Delivery](https://banes-lab.com/records/lexicon/continuous-delivery.md): The ability to release changes to production continuously through an automated pipeline.
- [Decoupled Deploy and Release](https://banes-lab.com/records/lexicon/decoupled-deploy-and-release.md): The ability to deploy code and separately decide when to activate it for users.
- [Dynamic Lookup](https://banes-lab.com/records/lexicon/dynamic-lookup.md): The ability to find a registered component by key at runtime.
- [Dynamic Resolution](https://banes-lab.com/records/lexicon/dynamic-resolution.md): The ability to resolve a service's current location or instance at runtime.
- [Framework Control Flow](https://banes-lab.com/records/lexicon/framework-control-flow.md): The ability to let a framework drive the overall control flow and call into application code.
- [Gradual Rollout](https://banes-lab.com/records/lexicon/gradual-rollout.md): The ability to enable a feature for a growing subset of users over time.
- [Late Resolution](https://banes-lab.com/records/lexicon/late-resolution.md): The ability to defer resolving which implementation to use until the moment it is needed.
- [Mocking](https://banes-lab.com/records/lexicon/mocking.md): The ability to substitute test doubles for real dependencies by injecting them.
- [Runtime Lookup](https://banes-lab.com/records/lexicon/runtime-lookup.md): The ability to look up a needed service by name at runtime.
- [Third-Party Extension](https://banes-lab.com/records/lexicon/third-party-extension.md): The ability for outside developers to extend the system through published extension points.
- [Registry](https://banes-lab.com/records/lexicon/registry.md): A central store that maps keys to registered components for later lookup.
- [Externalized Flag State](https://banes-lab.com/records/lexicon/externalized-flag-state.md): The requirement that feature-flag values live in external configuration, not hardcoded in the code.
- [Keyed Registration](https://banes-lab.com/records/lexicon/keyed-registration.md): The requirement that each component register under a unique key by which it can be retrieved.
- [Registration Protocol](https://banes-lab.com/records/lexicon/registration-protocol.md): The requirement of a defined protocol by which services register and deregister themselves.
- [API Surface Growth](https://banes-lab.com/records/lexicon/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/lexicon/constructor-complexity.md): The degree to which injecting many dependencies through constructors makes them long and unwieldy.
- [Explicit Dependencies](https://banes-lab.com/records/lexicon/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/lexicon/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/lexicon/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/lexicon/registry-availability.md): The degree to which the whole system's operation depends on the service registry staying available.
- [Availability](https://banes-lab.com/records/lexicon/availability.md): The proportion of time a system is operational and able to serve requests.
- [Security](https://banes-lab.com/records/lexicon/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/lexicon/simplicity.md): The absence of unnecessary structure, keeping a system easy to understand and change.
- [Debuggability](https://banes-lab.com/records/lexicon/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/lexicon/maintainability.md): The ease with which a system can be corrected, adapted, and extended over its lifetime.
- [Complexity](https://banes-lab.com/records/lexicon/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/lexicon/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/lexicon/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/lexicon/coordination-overhead.md): The additional cost incurred to synchronize and coordinate concurrent or distributed units of work.
- [Data Integrity](https://banes-lab.com/records/lexicon/data-integrity.md): The accuracy, consistency, and validity of data maintained over its entire lifecycle.
- [Discoverability](https://banes-lab.com/records/lexicon/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/lexicon/mapping-overhead.md): The additional cost of translating data or calls between two differing representations or models.
- [Operational Overhead](https://banes-lab.com/records/lexicon/operational-overhead.md): The ongoing effort and resource cost of deploying, running, and maintaining a system in production.
- [Ordering](https://banes-lab.com/records/lexicon/ordering.md): The guarantee that events or messages are processed in a well-defined, consistent sequence.
- [Partial Availability](https://banes-lab.com/records/lexicon/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/lexicon/performance.md): The speed, throughput, and resource efficiency with which a system performs its work.
- [Policy Complexity](https://banes-lab.com/records/lexicon/policy-complexity.md): The difficulty of understanding, maintaining, and reasoning about a policy as its rules multiply.
- [Readability](https://banes-lab.com/records/lexicon/readability.md): The ease with which source code can be read and understood by a developer.
- [Reliability](https://banes-lab.com/records/lexicon/reliability.md): The degree to which a system performs its required functions correctly and consistently over time.
- [Resource Efficiency](https://banes-lab.com/records/lexicon/resource-efficiency.md): The degree to which a system accomplishes its work using minimal computational resources.
- [Retry Safety](https://banes-lab.com/records/lexicon/retry-safety.md): The property that an operation can be retried without producing duplicate or inconsistent effects.
- [Robustness](https://banes-lab.com/records/lexicon/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/lexicon/static-safety.md): The guarantee that whole classes of errors are caught at compile time, before code runs.
- [Substitutability](https://banes-lab.com/records/lexicon/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/lexicon/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/lexicon/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/lexicon/user-experience.md): The overall quality of a user's interaction with a system, including responsiveness, clarity, and ease of use.
- [Health Signal](https://banes-lab.com/records/lexicon/health-signal.md): A machine-readable signal that reports whether a component is currently healthy, or that a fault or anomaly in it has been detected.
- [Reduced Mean Time to Recovery](https://banes-lab.com/records/lexicon/reduced-mean-time-to-recovery.md): The ability to shorten the mean time to recover from a failure by acting automatically.
- [Blind Routing](https://banes-lab.com/records/lexicon/blind-routing.md): Routing traffic to instances without checking their health, so requests hit dead or degraded nodes.
- [Observable Health Criteria](https://banes-lab.com/records/lexicon/observable-health-criteria.md): The requirement that explicit, observable criteria define when a component counts as healthy.
- [Readiness/Liveness Routing](https://banes-lab.com/records/lexicon/readiness-liveness-routing.md): The ability to route traffic only to instances that report themselves ready and alive.
- [Continuity During Failure](https://banes-lab.com/records/lexicon/continuity-during-failure.md): The ability to keep serving requests by switching to a standby when the primary fails.
- [Health Detection](https://banes-lab.com/records/lexicon/health-detection.md): The ability to detect that a component has failed so a switchover can be triggered.
- [Single Instance Dependency](https://banes-lab.com/records/lexicon/single-instance-dependency.md): Depending on a single instance with no standby, so its failure takes down the whole service.
- [Replication or Alternate Capacity](https://banes-lab.com/records/lexicon/replication-or-alternate-capacity.md): The requirement that duplicate copies or spare capacity exist to take over when a component fails.
- [Consistency Lag](https://banes-lab.com/records/lexicon/consistency-lag.md): The degree to which replicas trail the primary, so reads served from them may return stale data.
- [Consistency Policy](https://banes-lab.com/records/lexicon/consistency-policy.md): The requirement that a defined policy specify how and when replicas converge to a consistent state.
- [Read Scaling](https://banes-lab.com/records/lexicon/read-scaling.md): The ability to serve more read traffic by distributing it across replicas.
- [Single Copy State](https://banes-lab.com/records/lexicon/single-copy-state.md): Keeping only one copy of state, so its loss or unavailability takes down the whole system.
- [Cost/Cold Start](https://banes-lab.com/records/lexicon/cost-cold-start.md): The degree to which scaling capacity up and down incurs added cost and cold-start latency.
- [Fixed Capacity](https://banes-lab.com/records/lexicon/fixed-capacity.md): Provisioning a fixed, preset amount of capacity, rather than adapting it to demand.
- [Horizontal Scalability](https://banes-lab.com/records/lexicon/horizontal-scalability.md): The degree to which a system can grow by adding more interchangeable instances rather than enlarging one.
- [Incident Reduction](https://banes-lab.com/records/lexicon/incident-reduction.md): The ability to reduce the number of incidents that reach human responders by fixing them automatically.
- [Manual Remediation](https://banes-lab.com/records/lexicon/manual-remediation.md): Recovering from incidents through human-operated fixes, rather than automated remediation.
- [Remediation Workflow](https://banes-lab.com/records/lexicon/remediation-workflow.md): A defined corrective action, or sequence of steps, carried out to return a system to a healthy state after a fault is detected.
- [Unsafe Automation](https://banes-lab.com/records/lexicon/unsafe-automation.md): The degree to which automated remediation may take wrong or harmful corrective actions, for example on a faulty signal, faster than the developer can intervene.
- [Data Migration Compatibility](https://banes-lab.com/records/lexicon/data-migration-compatibility.md): The degree to which reverting code is constrained by forward data migrations that cannot easily be undone.
- [Fast Failure Recovery](https://banes-lab.com/records/lexicon/fast-failure-recovery.md): The ability to recover quickly from a bad release by reverting to the last good version.
- [Irreversible Deployment](https://banes-lab.com/records/lexicon/irreversible-deployment.md): Deploying in a way that cannot be undone, so a bad release cannot be rolled back.
- [Reversible Deployment](https://banes-lab.com/records/lexicon/reversible-deployment.md): The requirement that a deployment be structured so it can be safely reverted to a prior version.
- [Versioned Artifact](https://banes-lab.com/records/lexicon/versioned-artifact.md): A build artifact tagged with a distinct version so a prior one can be redeployed.
- [In-Place Mutation Only](https://banes-lab.com/records/lexicon/in-place-mutation-only.md): Upgrading by mutating the running environment in place, with no parallel target to cut over to or fall back from.
- [Infrastructure Cost](https://banes-lab.com/records/lexicon/infrastructure-cost.md): The degree to which running two full parallel environments doubles infrastructure cost during a cutover.
- [Low-Risk Cutover](https://banes-lab.com/records/lexicon/low-risk-cutover.md): The ability to switch traffic to a new version with low risk by keeping the old one ready to fall back to.
- [Parallel Environments](https://banes-lab.com/records/lexicon/parallel-environments.md): The requirement that two full production-equivalent environments run side by side for cutover.
- [Controlled Exposure](https://banes-lab.com/records/lexicon/controlled-exposure.md): The ability to expose a new version to a small, controlled fraction of traffic first.
- [Progressive Delivery](https://banes-lab.com/records/lexicon/progressive-delivery.md): A release strategy that rolls out changes gradually to widening audiences while monitoring for regressions.
- [Rollout Complexity](https://banes-lab.com/records/lexicon/rollout-complexity.md): The degree to which staging a release in gradual increments adds orchestration complexity.
- [Traffic Splitting](https://banes-lab.com/records/lexicon/traffic-splitting.md): A facility that routes a configurable proportion of traffic to different versions of a service.
- [Empirical Resilience Verification](https://banes-lab.com/records/lexicon/empirical-resilience-verification.md): The ability to verify a system's resilience empirically by injecting faults and observing recovery.
- [Production Risk](https://banes-lab.com/records/lexicon/production-risk.md): The degree to which deliberately injecting faults in production risks causing user-facing incidents.
- [Untested Failure Assumptions](https://banes-lab.com/records/lexicon/untested-failure-assumptions.md): Assuming a system will survive failures without ever testing those assumptions against injected faults.
- [Connection Cleanup](https://banes-lab.com/records/lexicon/connection-cleanup.md): The ability to close open connections cleanly when a process shuts down.
- [Hard Process Kill](https://banes-lab.com/records/lexicon/hard-process-kill.md): Terminating a process abruptly without draining work, dropping in-flight requests and risking corrupt state.
- [In-Flight Work Drain](https://banes-lab.com/records/lexicon/in-flight-work-drain.md): The ability to finish or safely hand off in-progress work before a process exits.
- [Lifecycle Signals](https://banes-lab.com/records/lexicon/lifecycle-signals.md): The requirement that a process receive lifecycle signals telling it when to start draining and stop.
- [Shutdown Latency](https://banes-lab.com/records/lexicon/shutdown-latency.md): The degree to which draining in-flight work before exit lengthens the time a shutdown takes.
- [Disk-Failure Survival](https://banes-lab.com/records/lexicon/disk-failure-survival.md): The ability to keep serving data after one or more disks fail, by reconstructing from redundancy.
- [Multiple Physical Disks](https://banes-lab.com/records/lexicon/multiple-physical-disks.md): The requirement that data span several physical disks so redundancy can survive a single-disk loss.
- [Parity-Based Recovery](https://banes-lab.com/records/lexicon/parity-based-recovery.md): The ability to reconstruct lost data from parity information stored across the disk array.
- [Single-Disk Point of Failure](https://banes-lab.com/records/lexicon/single-disk-point-of-failure.md): Storing data on a single disk with no redundancy, so that one disk's failure loses everything.
- [Write Amplification](https://banes-lab.com/records/lexicon/write-amplification.md): The degree to which maintaining parity on writes multiplies the underlying disk writes for each logical write.
- [Flexible Input](https://banes-lab.com/records/lexicon/flexible-input.md): The degree to which strictly validating every payload rejects the loosely-shaped input a caller might legitimately send.
- [Untyped Payloads](https://banes-lab.com/records/lexicon/untyped-payloads.md): Accepting data at a boundary with no schema, so malformed or unexpected shapes flow in unchecked.
- [Dynamic Untyped Boundaries](https://banes-lab.com/records/lexicon/dynamic-untyped-boundaries.md): Passing untyped values across module or service boundaries, so type errors surface only at runtime.
- [Explicit Types](https://banes-lab.com/records/lexicon/explicit-types.md): The requirement that values crossing a boundary carry explicit, declared types rather than open-ended ones.
- [Rapid Scripting](https://banes-lab.com/records/lexicon/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/lexicon/bounded-context-autonomy.md): The degree to which enforcing one canonical model limits each bounded context's freedom to model its own domain.
- [Multiple Competing Models](https://banes-lab.com/records/lexicon/multiple-competing-models.md): Several inconsistent models of the same concept coexisting, so translations between them drift and conflict.
- [Normalized Translation](https://banes-lab.com/records/lexicon/normalized-translation.md): The ability to translate between systems through one shared canonical form rather than many pairwise mappings.
- [Bounded Context Purity](https://banes-lab.com/records/lexicon/bounded-context-purity.md): The degree to which sharing one enterprise data model erodes the conceptual purity of each bounded context.
- [Cross-System Mapping](https://banes-lab.com/records/lexicon/cross-system-mapping.md): The ability to map data between systems through a single shared canonical representation.
- [Local Model Autonomy](https://banes-lab.com/records/lexicon/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/lexicon/service-specific-schemas.md): The degree to which a shared canonical schema competes with each service's need for its own tailored schema.
- [Ambiguous Encoding](https://banes-lab.com/records/lexicon/ambiguous-encoding.md): Representing the same value in multiple encodings without normalizing, so equal values compare as different.
- [Canonical Format](https://banes-lab.com/records/lexicon/canonical-format.md): The requirement that a single normalized form be defined for values before they are compared or stored.
- [Deduplication](https://banes-lab.com/records/lexicon/deduplication.md): The ability to recognize and collapse values that are equivalent once reduced to canonical form.
- [Lossless Preservation](https://banes-lab.com/records/lexicon/lossless-preservation.md): The degree to which reducing values to a canonical form can discard distinctions the original preserved.
- [Security Checks](https://banes-lab.com/records/lexicon/security-checks.md): The ability to apply security checks reliably by first reducing input to one unambiguous form.
- [Canonical Definition](https://banes-lab.com/records/lexicon/canonical-definition.md): The requirement that each fact have one authoritative definition that all consumers reference.
- [Duplicated Authority](https://banes-lab.com/records/lexicon/duplicated-authority.md): Two or more places each claiming to own the same fact, so they drift and disagree over time.
- [Data Semantics](https://banes-lab.com/records/lexicon/data-semantics.md): The requirement that the meaning and dependencies of data be understood before it is decomposed into relations.
- [Denormalized Read Models](https://banes-lab.com/records/lexicon/denormalized-read-models.md): A read-optimized model that deliberately duplicates data to serve queries fast, trading storage and write cost for read speed.
- [Non-Redundant Storage](https://banes-lab.com/records/lexicon/non-redundant-storage.md): The ability to store each fact once, so it cannot drift out of sync with copies and no update anomaly can arise.
- [Query Performance](https://banes-lab.com/records/lexicon/query-performance.md): The degree to which splitting data across normalized relations forces costly joins on read.
- [Reduced Redundancy](https://banes-lab.com/records/lexicon/reduced-redundancy.md): The ability to eliminate duplicated facts by referencing a single stored copy.
- [Disambiguation](https://banes-lab.com/records/lexicon/disambiguation.md): The ability to give each concept one unambiguous name and meaning across a domain.
- [Polysemy Across Contexts](https://banes-lab.com/records/lexicon/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/lexicon/cross-context-terminology.md): The degree to which agreeing on shared terms strains against the distinct vocabularies different contexts need.
- [Domain Collaboration](https://banes-lab.com/records/lexicon/domain-collaboration.md): The requirement that domain experts and developers collaborate to agree on shared terminology.
- [Technical/Domain Mismatch](https://banes-lab.com/records/lexicon/technical-domain-mismatch.md): Naming code in technical terms disconnected from the domain, so experts and developers talk past each other.
- [Ambiguous API](https://banes-lab.com/records/lexicon/ambiguous-api.md): An interface whose names and parameters hide what it does, so callers must guess or read the implementation.
- [Clear Semantics](https://banes-lab.com/records/lexicon/clear-semantics.md): The requirement that an interface's names convey what each operation does and expects.
- [Concise Naming](https://banes-lab.com/records/lexicon/concise-naming.md): The degree to which naming an interface fully for clarity works against keeping names short.
- [Correct Usage](https://banes-lab.com/records/lexicon/correct-usage.md): The ability of callers to use an interface correctly because its names reveal its intent.
- [Naming Consistency](https://banes-lab.com/records/lexicon/naming-consistency.md): The requirement that names for the same concept be used consistently across an interface.
- [Clever Abstractions](https://banes-lab.com/records/lexicon/clever-abstractions.md): The degree to which clever, non-obvious abstractions trade familiarity for surprise to the reader.
- [Convention](https://banes-lab.com/records/lexicon/convention.md): The requirement that a design follow established conventions so its behavior matches expectations.
- [Safe Use](https://banes-lab.com/records/lexicon/safe-use.md): The ability to use an interface safely because it behaves the way its name and shape suggest.
- [Duplicated Denormalized Columns](https://banes-lab.com/records/lexicon/duplicated-denormalized-columns.md): The same fact copied into many columns and rows, so updates must touch every copy or leave them inconsistent.
- [Functional Dependencies](https://banes-lab.com/records/lexicon/functional-dependencies.md): The requirement that the dependencies determining which attributes fix others be identified before decomposing a schema.
- [Read Performance](https://banes-lab.com/records/lexicon/read-performance.md): The degree to which normalizing a schema into many relations forces joins that slow reads.
- [Ad-Hoc Permission Checks](https://banes-lab.com/records/lexicon/ad-hoc-permission-checks.md): Authorization logic scattered inline throughout the codebase instead of centralized, leaving checks inconsistent and easy to omit.
- [Ambient-Credential Trust](https://banes-lab.com/records/lexicon/ambient-credential-trust.md): Treating any request that carries ambient credentials, such as a session cookie, as legitimate without verifying its origin or intent.
- [Anonymous Sensitive Access](https://banes-lab.com/records/lexicon/anonymous-sensitive-access.md): Permitting access to sensitive resources without first establishing the caller's identity.
- [Assumption-Driven Security](https://banes-lab.com/records/lexicon/assumption-driven-security.md): Designing defenses around assumed threats rather than a deliberate analysis of realistic attack vectors.
- [Authenticated-Equals-Authorized](https://banes-lab.com/records/lexicon/authenticated-equals-authorized.md): Conflating authentication with authorization, so any authenticated caller is granted access without a permission check.
- [Broad Admin Access](https://banes-lab.com/records/lexicon/broad-admin-access.md): Granting sweeping administrative privileges by default instead of the least access each role requires.
- [Hardcoded Rules](https://banes-lab.com/records/lexicon/hardcoded-rules.md): Embedding access rules directly in code, so changing policy requires a code change and cannot respond to runtime attributes.
- [Hardcoded Secrets](https://banes-lab.com/records/lexicon/hardcoded-secrets.md): Embedding credentials, keys, or tokens directly in source or configuration, exposing them to anyone who can read it.
- [Immortal Client-Trusted Session](https://banes-lab.com/records/lexicon/immortal-client-trusted-session.md): A session that never expires and is trusted from client-supplied state alone, so a captured token grants indefinite access.
- [Insecure Defaults](https://banes-lab.com/records/lexicon/insecure-defaults.md): Shipping default settings that favor convenience over safety, leaving a system exposed unless it is explicitly hardened.
- [Manual-Only Review](https://banes-lab.com/records/lexicon/manual-only-review.md): Relying solely on human review to catch policy violations, which neither scales nor reliably covers every case.
- [Plaintext Sensitive Storage](https://banes-lab.com/records/lexicon/plaintext-sensitive-storage.md): Storing sensitive data unencrypted at rest, exposing it to anyone who reaches the underlying storage.
- [Plaintext Transport](https://banes-lab.com/records/lexicon/plaintext-transport.md): Sending data over an unencrypted channel, exposing it to interception and tampering in transit.
- [Point-in-Time Audit Only](https://banes-lab.com/records/lexicon/point-in-time-audit-only.md): Verifying compliance only at isolated audit moments, leaving the intervals between checks unmonitored for drift.
- [Raw Output Rendering](https://banes-lab.com/records/lexicon/raw-output-rendering.md): Emitting untrusted data into output without encoding it for its context, enabling injection attacks such as cross-site scripting.
- [Security as Afterthought](https://banes-lab.com/records/lexicon/security-as-afterthought.md): Deferring security concerns until late in development, when vulnerabilities are costly and difficult to remediate.
- [Single Control Reliance](https://banes-lab.com/records/lexicon/single-control-reliance.md): Depending on one security control with no layered defenses, so a single bypass compromises the whole system.
- [String-Concatenated SQL](https://banes-lab.com/records/lexicon/string-concatenated-sql.md): Assembling SQL queries by concatenating untrusted input into strings, opening the system to SQL injection.
- [Trusted Internal Network Assumption](https://banes-lab.com/records/lexicon/trusted-internal-network-assumption.md): Assuming that traffic originating inside the network perimeter is inherently trustworthy, ignoring insider and lateral-movement threats.
- [Trusting External Input](https://banes-lab.com/records/lexicon/trusting-external-input.md): Accepting external input as well-formed and safe without validating it, exposing the system to malformed or malicious data.
- [Unbounded Autonomy](https://banes-lab.com/records/lexicon/unbounded-autonomy.md): Allowing an actor or component to act without governance limits, so unsafe or unauthorized actions go unchecked.
- [Uncontrolled Change](https://banes-lab.com/records/lexicon/uncontrolled-change.md): Permitting changes to a controlled system without review, approval, or record, undermining compliance and traceability.
- [Unnecessary Public Surface](https://banes-lab.com/records/lexicon/unnecessary-public-surface.md): Exposing more endpoints, ports, or interfaces publicly than the function requires, enlarging the attack surface.
- [Unrestricted Access](https://banes-lab.com/records/lexicon/unrestricted-access.md): Permitting access to a resource with no controls, so any caller can invoke any operation.
- [Assets](https://banes-lab.com/records/lexicon/assets.md): The data, systems, and capabilities of value that a threat model enumerates as the things worth protecting.
- [Attribute Definitions](https://banes-lab.com/records/lexicon/attribute-definitions.md): Declared descriptions of the subject, resource, action, and environment attributes that an access policy evaluates.
- [Authenticated Principal](https://banes-lab.com/records/lexicon/authenticated-principal.md): The verified identity of the user or service on whose behalf a request executes, against which permissions are checked.
- [Authorization Policy](https://banes-lab.com/records/lexicon/authorization-policy.md): The declared set of rules determining which principals may perform which actions on which resources.
- [Consent/Policy](https://banes-lab.com/records/lexicon/consent-policy.md): The recorded permission and governing rules under which personal data may lawfully be collected and processed.
- [Context-Aware Encoding](https://banes-lab.com/records/lexicon/context-aware-encoding.md): Choosing an output encoding matched to the destination context, such as HTML, an attribute, a URL or a script, so data is neutralized wherever it lands.
- [Continuous Authorization](https://banes-lab.com/records/lexicon/continuous-authorization.md): The practice of re-verifying a caller's authorization on every request rather than trusting a single earlier check.
- [Controls](https://banes-lab.com/records/lexicon/controls.md): The safeguards and countermeasures put in place to reduce security or compliance risk to an acceptable level.
- [Data Minimization](https://banes-lab.com/records/lexicon/data-minimization.md): Collecting and retaining only the personal data strictly necessary for a stated purpose.
- [Defined Policy](https://banes-lab.com/records/lexicon/defined-policy.md): An explicit, declared set of rules specifying what is permitted or denied, against which enforcement acts.
- [Evidence Automation](https://banes-lab.com/records/lexicon/evidence-automation.md): The ability to generate and collect compliance evidence automatically from live systems rather than assembling it by hand.
- [Identity Proof](https://banes-lab.com/records/lexicon/identity-proof.md): The evidence a principal presents to establish its identity, such as a password, token, or certificate.
- [Key Management](https://banes-lab.com/records/lexicon/key-management.md): The activity of generating, distributing, rotating, and revoking cryptographic keys across their lifecycle.
- [Layered Controls](https://banes-lab.com/records/lexicon/layered-controls.md): The requirement that multiple independent safeguards protect a resource, so no single failure exposes it.
- [Machine-Readable Policies](https://banes-lab.com/records/lexicon/machine-readable-policies.md): Security or compliance policies expressed in a structured, executable format that tools can evaluate directly.
- [Minimal Exposure](https://banes-lab.com/records/lexicon/minimal-exposure.md): The condition of exposing only the endpoints, ports, and capabilities strictly required.
- [Minimal Permissions](https://banes-lab.com/records/lexicon/minimal-permissions.md): The requirement that each principal hold only the permissions its function needs.
- [Mitigation](https://banes-lab.com/records/lexicon/mitigation.md): The activity of reducing a risk's likelihood or impact through deliberate countermeasures.
- [Policy Engine](https://banes-lab.com/records/lexicon/policy-engine.md): A runtime component that evaluates access requests against declared policies and returns permit or deny decisions.
- [Query Parameter Binding](https://banes-lab.com/records/lexicon/query-parameter-binding.md): Passing query values as bound parameters separate from the query text, so input can never alter the query structure.
- [Request Origin Verification](https://banes-lab.com/records/lexicon/request-origin-verification.md): Confirming that a state-changing request originates from a trusted client, typically via a token or origin check.
- [Review](https://banes-lab.com/records/lexicon/review.md): The activity of examining a change or artifact against standards before it is accepted.
- [Risk Identification](https://banes-lab.com/records/lexicon/risk-identification.md): The activity of discovering and cataloguing the risks that could affect a system or objective.
- [Role Definitions](https://banes-lab.com/records/lexicon/role-definitions.md): Declared sets of permissions grouped into named roles that are assigned to principals.
- [Rotation Policy](https://banes-lab.com/records/lexicon/rotation-policy.md): The specified interval and procedure by which secrets or keys must be replaced to limit the value of any single compromise.
- [Secret Store](https://banes-lab.com/records/lexicon/secret-store.md): A dedicated, access-controlled repository that holds credentials and keys outside of application code.
- [Threat Scenarios](https://banes-lab.com/records/lexicon/threat-scenarios.md): Concrete descriptions of how an attacker might attempt to compromise a system, enumerated during threat modeling.
- [TLS/mTLS](https://banes-lab.com/records/lexicon/tls-mtls.md): Transport-layer protocols that encrypt a connection and, with mutual TLS, mutually authenticate both endpoints.
- [Trust Boundaries](https://banes-lab.com/records/lexicon/trust-boundaries.md): The demarcations in a system where the level of trust changes and data crossing them must be validated.
- [Strong Identity](https://banes-lab.com/records/lexicon/strong-identity.md): The requirement that every actor prove a strong, verified identity before any access is granted.
- [Validation Rules](https://banes-lab.com/records/lexicon/validation-rules.md): Declared constraints that input must satisfy, such as type, range, format and length, before it is accepted.