# Lexicon terms, part 3 of 5

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

## Entries

- [HATEOAS-style Navigation](https://banes-lab.com/records/lexicon/hateoas-style-navigation.md): The ability for clients to navigate an API by following links it returns in its responses.
- [Plugin Loading](https://banes-lab.com/records/lexicon/plugin-loading.md): The ability to discover and load plugins declared in manifests at runtime.
- [Reduced Boilerplate](https://banes-lab.com/records/lexicon/reduced-boilerplate.md): The ability to avoid repetitive boilerplate by relying on conventions.
- [Runtime Configuration without Code Change](https://banes-lab.com/records/lexicon/runtime-configuration-without-code-change.md): The ability to change a system's behavior by editing configuration rather than code.
- [Manifest](https://banes-lab.com/records/lexicon/manifest.md): A declarative document listing a component's capabilities and metadata.
- [Manifest Schema](https://banes-lab.com/records/lexicon/manifest-schema.md): A formal definition of the structure a manifest must follow.
- [Metadata Schema](https://banes-lab.com/records/lexicon/metadata-schema.md): A formal definition of the metadata fields that drive a system's behavior.
- [Explicit Semantics](https://banes-lab.com/records/lexicon/explicit-semantics.md): The requirement that declarative configuration carry an explicit, defined meaning.
- [Stable Conventions](https://banes-lab.com/records/lexicon/stable-conventions.md): The requirement that the conventions a system relies on stay stable and well-known.
- [Declaration Drift](https://banes-lab.com/records/lexicon/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/lexicon/dynamic-complexity.md): The degree to which interpreting declarative configuration at runtime adds hidden dynamic complexity.
- [Explicitness](https://banes-lab.com/records/lexicon/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/lexicon/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/lexicon/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/lexicon/payload-verbosity.md): The degree to which embedding self-description in responses enlarges their payloads.
- [Self-Description](https://banes-lab.com/records/lexicon/self-description.md): The degree to which a component exposes its own capabilities and structure for inspection.
- [Size Overhead](https://banes-lab.com/records/lexicon/size-overhead.md): The degree to which embedding structural descriptions in data increases its size.
- [Runtime Topology Report](https://banes-lab.com/records/lexicon/runtime-topology-report.md): A technique for having a system report its loaded components and their bindings at startup.
- [Binding Decision Log](https://banes-lab.com/records/lexicon/binding-decision-log.md): A technique for logging which implementation was bound to each extension point and why.
- [Declare Capability](https://banes-lab.com/records/lexicon/declare-capability.md): A technique for having each component state in metadata what it provides and what it requires.
- [Unvalidated Metadata](https://banes-lab.com/records/lexicon/unvalidated-metadata.md): A defect in which metadata that drives behavior is read without being validated against a schema.
- [Code-as-Data Representation](https://banes-lab.com/records/lexicon/code-as-data-representation.md): The requirement that a program's code be representable in the same data structures the language manipulates.
- [Macro Systems](https://banes-lab.com/records/lexicon/macro-systems.md): A facility that lets code transform other code at compile time by operating on its data representation.
- [Opaque Syntax Trees](https://banes-lab.com/records/lexicon/opaque-syntax-trees.md): Syntax trees a program cannot inspect or manipulate as data, so code cannot be transformed programmatically.
- [AST or Data Representation](https://banes-lab.com/records/lexicon/ast-or-data-representation.md): The requirement that code be represented as a structured syntax tree or data rather than as raw text.
- [Program Transformation](https://banes-lab.com/records/lexicon/program-transformation.md): The ability to analyze and rewrite a program by manipulating its structured representation.
- [Safety/Debuggability](https://banes-lab.com/records/lexicon/safety-debuggability.md): The degree to which treating code as manipulable data can obscure what runs and make it harder to debug.
- [String-Based Code Generation](https://banes-lab.com/records/lexicon/string-based-code-generation.md): Building code by concatenating strings, so the result is unchecked, injection-prone, and hard to analyze.
- [Boilerplate Elimination](https://banes-lab.com/records/lexicon/boilerplate-elimination.md): The ability to remove repetitive boilerplate by generating it from a single declaration.
- [Explicit Handwritten Code](https://banes-lab.com/records/lexicon/explicit-handwritten-code.md): Writing code out by hand explicitly rather than generating it, favoring directness and debuggability over reuse.
- [Reflection/AST/Code Generation](https://banes-lab.com/records/lexicon/reflection-ast-code-generation.md): The requirement that a language expose reflection, syntax trees, or code generation for programs to manipulate themselves.
- [Performance/Safety](https://banes-lab.com/records/lexicon/performance-safety.md): The degree to which inspecting and dispatching on types at runtime costs performance and bypasses static safety.
- [Runtime Type Metadata](https://banes-lab.com/records/lexicon/runtime-type-metadata.md): Type information retained at runtime so a program can inspect the shape of its own values.
- [Diagnostics](https://banes-lab.com/records/lexicon/diagnostics.md): The ability to inspect a running system's own structure and state to diagnose it.
- [Self-Describing Systems](https://banes-lab.com/records/lexicon/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/lexicon/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.
- [Compile-Time Inputs](https://banes-lab.com/records/lexicon/compile-time-inputs.md): The requirement that the inputs a computation needs be known at compile time so it can run then.
- [Early Error Detection](https://banes-lab.com/records/lexicon/early-error-detection.md): The ability to catch errors at compile time rather than letting them surface at runtime.
- [Runtime Dynamic Evaluation](https://banes-lab.com/records/lexicon/runtime-dynamic-evaluation.md): Evaluating code or expressions dynamically at runtime, trading compile-time checking for runtime flexibility.
- [Dynamic Optimization/Adaptation](https://banes-lab.com/records/lexicon/dynamic-optimization-adaptation.md): The ability to generate specialized code at runtime to optimize or adapt to observed conditions.
- [Safe Generation Boundary](https://banes-lab.com/records/lexicon/safe-generation-boundary.md): The requirement that runtime code generation be confined to a safe, sandboxed boundary away from untrusted input.
- [Security/Debugging](https://banes-lab.com/records/lexicon/security-debugging.md): The degree to which generating and running code at runtime widens the attack surface and complicates debugging.
- [Domain Expressiveness](https://banes-lab.com/records/lexicon/domain-expressiveness.md): The ability to express domain rules directly in terms a domain expert recognizes.
- [Formal Grammar/Semantics](https://banes-lab.com/records/lexicon/formal-grammar-semantics.md): The requirement that a domain language have a defined grammar and semantics rather than an ad-hoc syntax.
- [General-Purpose Boilerplate](https://banes-lab.com/records/lexicon/general-purpose-boilerplate.md): Expressing domain logic through verbose general-purpose code and its boilerplate instead of a concise domain notation.
- [Tooling/Maintenance](https://banes-lab.com/records/lexicon/tooling-maintenance.md): The degree to which owning a custom language burdens a team with building and maintaining its tooling.
- [Code Generation or Interpreters](https://banes-lab.com/records/lexicon/code-generation-or-interpreters.md): The requirement that a domain language be backed by a generator or interpreter that executes it.
- [Domain Modeling](https://banes-lab.com/records/lexicon/domain-modeling.md): Expressing a problem domain as a first-class language of its own concepts and rules.
- [High-Level Domain Expression](https://banes-lab.com/records/lexicon/high-level-domain-expression.md): The ability to express solutions in high-level domain terms rather than low-level general-purpose code.
- [One-Size General-Purpose Code](https://banes-lab.com/records/lexicon/one-size-general-purpose-code.md): Expressing every domain in a single general-purpose language, rather than in domain-specific notations.
- [Toolchain Complexity](https://banes-lab.com/records/lexicon/toolchain-complexity.md): The degree to which building custom languages adds compilers, parsers, and editors to a project's toolchain.
- [Formal Model](https://banes-lab.com/records/lexicon/formal-model.md): A precise, machine-processable model of a system from which implementations are generated.
- [Generated Implementations](https://banes-lab.com/records/lexicon/generated-implementations.md): Implementation code produced automatically from a model rather than written by hand.
- [Handwritten Divergence](https://banes-lab.com/records/lexicon/handwritten-divergence.md): Hand-editing generated code so it drifts from the model it came from, breaking regeneration.
- [Transformation Rules](https://banes-lab.com/records/lexicon/transformation-rules.md): The requirement that explicit rules define how a model maps to generated implementation code.
- [Syntax Tree Generation](https://banes-lab.com/records/lexicon/syntax-tree-generation.md): A technique for generating code by building and printing a syntax tree instead of concatenating strings.
- [Reflective Contract Bypass](https://banes-lab.com/records/lexicon/reflective-contract-bypass.md): A defect in which reflection is used to reach members that a type's contract or visibility hides.
- [Deferred Static Check](https://banes-lab.com/records/lexicon/deferred-static-check.md): A defect in which a check or generation that could run at compile time is repeated at runtime.
- [Ad-Hoc Mini-Language](https://banes-lab.com/records/lexicon/ad-hoc-mini-language.md): A defect in which rules are written in an informal mini-language that has no grammar and no validator.
- [Ad-Hoc Notebook-to-Production](https://banes-lab.com/records/lexicon/ad-hoc-notebook-to-production.md): Promoting exploratory notebook code straight to production without engineering it into a reliable pipeline.
- [Deploy-and-Forget Models](https://banes-lab.com/records/lexicon/deploy-and-forget-models.md): Deploying a model and never monitoring it, so degradation as the data drifts goes unnoticed.
- [Exact Keyword Search Only](https://banes-lab.com/records/lexicon/exact-keyword-search-only.md): Relying solely on exact keyword matching for retrieval, missing semantically related results.
- [Flat Document-Only Knowledge](https://banes-lab.com/records/lexicon/flat-document-only-knowledge.md): Representing knowledge as unlinked flat documents, losing the relationships a graph would capture.
- [Opaque Black-Box Decisions](https://banes-lab.com/records/lexicon/opaque-black-box-decisions.md): Producing model decisions with no explanation, so their reasoning cannot be inspected or trusted.
- [Opaque Ungoverned Model Use](https://banes-lab.com/records/lexicon/opaque-ungoverned-model-use.md): Using models with no governance or oversight, leaving their behavior and risks unmanaged.
- [Training-Time-Only Model Logic](https://banes-lab.com/records/lexicon/training-time-only-model-logic.md): Building logic that exists only during training, with no counterpart to serve predictions at inference.
- [Unapproved Model Deployment](https://banes-lab.com/records/lexicon/unapproved-model-deployment.md): Deploying a model to production without passing the required review and approval gates.
- [Ungrounded Generation](https://banes-lab.com/records/lexicon/ungrounded-generation.md): Generating output from a model alone without grounding it in retrieved facts, inviting hallucination.
- [Unguarded Model Autonomy](https://banes-lab.com/records/lexicon/unguarded-model-autonomy.md): Letting a model act autonomously with no safety guardrails on what it can do.
- [Untested Model Deployment](https://banes-lab.com/records/lexicon/untested-model-deployment.md): Deploying a model without evaluating it, so its real-world quality is unknown until it fails.
- [Approval Policy](https://banes-lab.com/records/lexicon/approval-policy.md): The declared rules and gates a model must pass before it may be deployed.
- [Document Store](https://banes-lab.com/records/lexicon/document-store.md): The body of documents a retrieval system searches to ground a model's generation.
- [Data Pipeline](https://banes-lab.com/records/lexicon/data-pipeline.md): The stages that ingest, clean, and transform data into a form suitable for training or inference.
- [Data/Model Boundaries](https://banes-lab.com/records/lexicon/data-model-boundaries.md): The lines separating data preparation, model training, and serving so each concern stays isolated.
- [Dataset](https://banes-lab.com/records/lexicon/dataset.md): A curated collection of examples used to train or evaluate a model.
- [Embeddings](https://banes-lab.com/records/lexicon/embeddings.md): Numeric vector representations of data that place semantically similar items near each other.
- [Entities](https://banes-lab.com/records/lexicon/entities.md): The distinct things, such as people, places or concepts, that a knowledge graph represents as nodes.
- [Grounding Strategy](https://banes-lab.com/records/lexicon/grounding-strategy.md): A scheme for anchoring a model's output in retrieved, authoritative sources rather than its parameters alone.
- [Guardrails](https://banes-lab.com/records/lexicon/guardrails.md): Constraints and filters that bound what a model is permitted to output or do at runtime.
- [Input/Output Contract](https://banes-lab.com/records/lexicon/input-output-contract.md): The agreed schema of the inputs a model accepts and the outputs it returns.
- [Model Artifact](https://banes-lab.com/records/lexicon/model-artifact.md): The trained model file, with its learned weights, that is loaded to serve predictions.
- [Model Registry](https://banes-lab.com/records/lexicon/model-registry.md): A catalog that tracks model versions, their metadata, and their deployment status.
- [Rationale/Evidence](https://banes-lab.com/records/lexicon/rationale-evidence.md): The reasons and supporting evidence recorded for a model's decision.
- [Relations](https://banes-lab.com/records/lexicon/relations.md): The typed connections between entities that a knowledge graph represents as edges.
- [Retriever](https://banes-lab.com/records/lexicon/retriever.md): A component that finds and returns the most relevant documents for a query.
- [Schema/Ontology](https://banes-lab.com/records/lexicon/schema-ontology.md): A formal definition of the entity types and relationship types a knowledge graph may contain.
- [Tool Interface](https://banes-lab.com/records/lexicon/tool-interface.md): The defined contract through which an agent invokes external tools and receives their results.
- [Training/Inference Separation](https://banes-lab.com/records/lexicon/training-inference-separation.md): The requirement that model training and prediction serving be distinct, separately-managed phases.
- [Vector Index](https://banes-lab.com/records/lexicon/vector-index.md): A data structure that organizes embedding vectors for fast nearest-neighbor lookup.
- [Retraining Triggers](https://banes-lab.com/records/lexicon/retraining-triggers.md): Signals that automatically initiate model retraining when measured drift crosses a threshold.
- [Model-Integrated Systems](https://banes-lab.com/records/lexicon/model-integrated-systems.md): The ability of a software system to incorporate models as integral parts of its behavior.
- [Audit and Debugging](https://banes-lab.com/records/lexicon/audit-and-debugging.md): The ability to inspect and trace a model's decisions for auditing and debugging.
- [Bounded Tool-Using Agents](https://banes-lab.com/records/lexicon/bounded-tool-using-agents.md): The ability to run agents that use external tools within defined, safe limits.
- [Contextual Generation](https://banes-lab.com/records/lexicon/contextual-generation.md): The ability to generate output informed by retrieved, task-specific context.
- [Controlled Model Deployment](https://banes-lab.com/records/lexicon/controlled-model-deployment.md): The ability to release models through a governed, approved process.
- [Degradation Detection](https://banes-lab.com/records/lexicon/degradation-detection.md): The ability to detect when a model's accuracy declines as data shifts.
- [Governed Autonomy](https://banes-lab.com/records/lexicon/governed-autonomy.md): The ability to let an agent act autonomously within enforced governance limits.
- [Model Selection/Regression Detection](https://banes-lab.com/records/lexicon/model-selection-regression-detection.md): The ability to compare models and catch quality regressions before deployment.
- [Relationship-Aware Retrieval/Reasoning](https://banes-lab.com/records/lexicon/relationship-aware-retrieval-reasoning.md): The ability to retrieve and reason over the relationships between entities, not just isolated facts.
- [Reliable Model Lifecycle](https://banes-lab.com/records/lexicon/reliable-model-lifecycle.md): The ability to manage a model's data, training, deployment and monitoring reliably and repeatably.
- [Safe Model Deployment](https://banes-lab.com/records/lexicon/safe-model-deployment.md): The ability to deploy models with safeguards that bound their behavior.
- [Semantic Search](https://banes-lab.com/records/lexicon/semantic-search.md): The ability to find results by meaning and similarity rather than exact keyword match.
- [Similarity Retrieval](https://banes-lab.com/records/lexicon/similarity-retrieval.md): The ability to retrieve items nearest to a query in an embedding space.
- [Structured, Versioned Prompts](https://banes-lab.com/records/lexicon/structured-versioned-prompts.md): Prompts authored as structured, version-controlled artifacts rather than ad-hoc strings.
- [Knowledge Freshness](https://banes-lab.com/records/lexicon/knowledge-freshness.md): The degree to which a system's knowledge reflects current rather than stale information.
- [Trust](https://banes-lab.com/records/lexicon/trust.md): The degree to which users are willing to rely on a system's outputs.
- [Capability/Utility](https://banes-lab.com/records/lexicon/capability-utility.md): The degree of usefulness a model offers, which strict safety limits can constrain.
- [Curation Cost](https://banes-lab.com/records/lexicon/curation-cost.md): The degree of ongoing effort required to build and maintain a curated knowledge graph.
- [Experiment Velocity](https://banes-lab.com/records/lexicon/experiment-velocity.md): The rate at which model experiments can be run and iterated, which governance can slow.
- [Experimentation Speed](https://banes-lab.com/records/lexicon/experimentation-speed.md): The rate at which new modeling ideas can be tried and evaluated.
- [Explainability/Recall](https://banes-lab.com/records/lexicon/explainability-recall.md): The degree to which retrieval stays explainable and complete, traded against pure similarity ranking.
- [Latency/Cost](https://banes-lab.com/records/lexicon/latency-cost.md): The degree of latency and expense incurred to serve model predictions.
- [Metric Completeness](https://banes-lab.com/records/lexicon/metric-completeness.md): The degree to which evaluation metrics capture every dimension of a model's quality.
- [Model Complexity](https://banes-lab.com/records/lexicon/model-complexity.md): The degree of intricacy in a model, which raises accuracy but lowers explainability.
- [Monitoring Cost](https://banes-lab.com/records/lexicon/monitoring-cost.md): The degree of ongoing expense of continuously monitoring a deployed model.
- [Retrieval Quality/Latency](https://banes-lab.com/records/lexicon/retrieval-quality-latency.md): The degree to which retrieval must trade result quality against speed.
- [Prompt Registry](https://banes-lab.com/records/lexicon/prompt-registry.md): A technique for keeping prompts in one versioned registry instead of as literals across the code.
- [Prompt Versioning](https://banes-lab.com/records/lexicon/prompt-versioning.md): A technique for giving each prompt, dataset and index a version that inference logs record.
- [Evaluation Suite](https://banes-lab.com/records/lexicon/evaluation-suite.md): A technique for scoring model output against a fixed set of cases on every change to the model, prompt or data.
- [Centralized Model Configuration](https://banes-lab.com/records/lexicon/centralized-model-configuration.md): A technique for holding model names, parameters and limits in one configuration read by every call site.
- [Inference Context Record](https://banes-lab.com/records/lexicon/inference-context-record.md): A technique for logging with each model output the model version, prompt version and inputs that produced it.
- [Evidence Citation](https://banes-lab.com/records/lexicon/evidence-citation.md): A technique for attaching to each generated claim the retrieved source that supports it.
- [Claim Validation](https://banes-lab.com/records/lexicon/claim-validation.md): A technique for checking generated claims against their cited sources before they are returned.
- [Abstain or Disclose Uncertainty](https://banes-lab.com/records/lexicon/abstain-or-disclose-uncertainty.md): A technique for having a model decline or state its uncertainty when the evidence does not support an answer.
- [Governance Log](https://banes-lab.com/records/lexicon/governance-log.md): A technique for recording each approval, deployment and retirement of a model with who decided it.
- [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.
- [Structured Log](https://banes-lab.com/records/lexicon/structured-log.md): A technique for writing log entries as typed fields, so they are queried by field instead of by text.
- [Trace Span](https://banes-lab.com/records/lexicon/trace-span.md): A technique for recording the start, end and context of an operation as a span within a request's trace.
- [Alert on Critical Failure](https://banes-lab.com/records/lexicon/alert-on-critical-failure.md): A technique for raising an alert with an owner and a severity when a critical path fails.
- [Cardinality Reduction](https://banes-lab.com/records/lexicon/cardinality-reduction.md): A technique for limiting the distinct label values a metric carries, so its storage and queries stay bounded.
- [Sampling and Aggregation](https://banes-lab.com/records/lexicon/sampling-and-aggregation.md): A technique for keeping a representative share of telemetry or a summary of it instead of every event.
- [Runbook Owner](https://banes-lab.com/records/lexicon/runbook-owner.md): A technique for naming the person or team responsible for each alert and its response steps.
- [Causation Tracing](https://banes-lab.com/records/lexicon/causation-tracing.md): A technique for carrying the id of the event or request that caused each effect, so a chain can be followed back.
- [Usage Instrumentation](https://banes-lab.com/records/lexicon/usage-instrumentation.md): A technique for counting calls to a code path in production, so its use is measured before it is removed.
- [Data Change Audit](https://banes-lab.com/records/lexicon/data-change-audit.md): A technique for recording who changed which data, when, and from what value to what value.
- [Execution Log](https://banes-lab.com/records/lexicon/execution-log.md): A technique for recording each step an automated or manual procedure performed and its result.
- [Define Signal Quality](https://banes-lab.com/records/lexicon/define-signal-quality.md): A technique for stating what makes a log, metric or alert useful before it is emitted.
- [Service Level Objectives](https://banes-lab.com/records/lexicon/service-level-objectives.md): A technique for choosing measured indicators of reliability and setting the targets a service must meet on them.
- [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.
- [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.
- [Encode State Machine](https://banes-lab.com/records/lexicon/encode-state-machine.md): A technique for declaring the states and legal transitions of a lifecycle, so an operation called in the wrong state is refused.
- [Make Order Explicit](https://banes-lab.com/records/lexicon/make-order-explicit.md): A technique for expressing a required call order in types or a state machine instead of in documentation.
- [Scattered Null Guards](https://banes-lab.com/records/lexicon/scattered-null-guards.md): A defect in which every call site repeats a null check before the same operation.
- [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.
- [Constructor-Valid State](https://banes-lab.com/records/lexicon/constructor-valid-state.md): A technique for having a constructor or factory accept only arguments that produce a valid object.
- [Repeated Expensive Setup](https://banes-lab.com/records/lexicon/repeated-expensive-setup.md): A defect in which each new object repeats a costly setup that copying a prepared instance would avoid.
- [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.
- [Cache Contract](https://banes-lab.com/records/lexicon/cache-contract.md): A technique for declaring what a cache entry is keyed by, how long it lives and what invalidates it.
- [Context-Keyed Cache](https://banes-lab.com/records/lexicon/context-keyed-cache.md): A technique for including tenant, identity, version and every input that changes the result in a cache key.
- [Cache Invalidation on Write](https://banes-lab.com/records/lexicon/cache-invalidation-on-write.md): A technique for removing or refreshing cached entries in the same change that writes the data behind them.
- [Batch Fetch](https://banes-lab.com/records/lexicon/batch-fetch.md): A technique for loading the related data for many items in one query or call instead of one per item.
- [Externalize Session State](https://banes-lab.com/records/lexicon/externalize-session-state.md): A technique for moving per-user or per-request state out of instance memory into a shared store.
- [Replace Algorithm](https://banes-lab.com/records/lexicon/replace-algorithm.md): A technique for swapping an algorithm or data structure for one with better complexity for the inputs at hand.
- [Add Index](https://banes-lab.com/records/lexicon/add-index.md): A technique for adding an index on the fields a slow query filters or sorts by.
- [Chunked Processing](https://banes-lab.com/records/lexicon/chunked-processing.md): A technique for processing large data in fixed-size pieces, so memory use stays bounded.
- [Repeated Stable Computation](https://banes-lab.com/records/lexicon/repeated-stable-computation.md): A defect in which a costly computation or query whose result does not change is repeated on every request.
- [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.
- [Fuse Passes](https://banes-lab.com/records/lexicon/fuse-passes.md): A technique for combining several passes over the same data into one.
- [Repeated Full Scan](https://banes-lab.com/records/lexicon/repeated-full-scan.md): A defect in which large data is scanned or materialized several times where one pass would do.
- [Random Access over a Stream](https://banes-lab.com/records/lexicon/random-access-over-a-stream.md): A defect in which code seeks or indexes into a source that can only be read in sequence.
- [Look-Back Buffering](https://banes-lab.com/records/lexicon/look-back-buffering.md): A defect in which a whole stream is buffered so that one stage can look back or ahead.
- [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.
- [Ungoverned Global Registry](https://banes-lab.com/records/lexicon/ungoverned-global-registry.md): A defect in which a global registry is changed from anywhere, with no owner, lifecycle or validation of its entries.
- [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.