# The lex records whose category is codebase-system-architecture-styles

This index as JSON: https://banes-lab.com/json/api/facets/lex/category/codebase-system-architecture-styles

## Entries

- [Central Database Bottleneck](https://banes-lab.com/records/lex/central-database-bottleneck.md): Funneling all state through one shared database that becomes the system's scaling bottleneck.
- [Framework-Centric Core](https://banes-lab.com/records/lex/framework-centric-core.md): Building the core around a specific framework, so the framework's concerns permeate the domain.
- [Infrastructure-Centric Design](https://banes-lab.com/records/lex/infrastructure-centric-design.md): Designing the core around infrastructure details, so business logic depends on technical specifics.
- [Layer Leakage](https://banes-lab.com/records/lex/layer-leakage.md): Letting an inner layer depend on an outer one, violating the direction of the dependency rule.
- [Layer Skipping](https://banes-lab.com/records/lex/layer-skipping.md): Bypassing intermediate layers to call a distant layer directly, undermining the layering.
- [Monolithic Transform Function](https://banes-lab.com/records/lex/monolithic-transform-function.md): Doing all processing in one large transform instead of a series of composable filter stages.
- [Package by Technical Layer Only](https://banes-lab.com/records/lex/package-by-technical-layer-only.md): Organizing code by technical layer alone, scattering each feature across many packages.
- [Shared Monolithic Application](https://banes-lab.com/records/lex/shared-monolithic-application.md): Building one large shared application instead of composing independently-governed services.
- [Unbounded Big Ball of Mud](https://banes-lab.com/records/lex/unbounded-big-ball-of-mud.md): Letting a system grow without structure into a tangled mass with no clear boundaries.
- [Contract-Governed Service Reuse](https://banes-lab.com/records/lex/contract-governed-service-reuse.md): The ability to reuse services across an enterprise through well-defined contracts.
- [Database-Bottleneck Removal](https://banes-lab.com/records/lex/database-bottleneck-removal.md): The ability to eliminate the shared-database bottleneck by holding state in distributed memory.
- [Decentralized Ownership](https://banes-lab.com/records/lex/decentralized-ownership.md): The ability for separate teams to own, deploy and evolve their services independently.
- [External System Isolation](https://banes-lab.com/records/lex/external-system-isolation.md): The ability to isolate the core from external systems behind adapter boundaries.
- [Framework Independence](https://banes-lab.com/records/lex/framework-independence.md): The ability to keep business rules independent of any particular framework.
- [Independent Stage Testing](https://banes-lab.com/records/lex/independent-stage-testing.md): The ability to test each filter stage in isolation from the rest of the pipeline.
- [Infrastructure Independence](https://banes-lab.com/records/lex/infrastructure-independence.md): The ability to keep the core independent of the infrastructure it runs on.
- [Locality of Change](https://banes-lab.com/records/lex/locality-of-change.md): The ability to make a feature's changes in one place because its code is grouped together.
- [Reorderable Stages](https://banes-lab.com/records/lex/reorderable-stages.md): The ability to reorder or recombine independent processing stages.
- [Structured Code Organization](https://banes-lab.com/records/lex/structured-code-organization.md): The ability to organize code predictably by assigning each responsibility to a layer.
- [Transactional Simplicity](https://banes-lab.com/records/lex/transactional-simplicity.md): The ability to use straightforward local transactions when all state lives in one process.
- [Adapters](https://banes-lab.com/records/lex/adapters.md): Components that translate between a core's ports and the specific external technologies behind them.
- [Boundaries](https://banes-lab.com/records/lex/boundaries.md): The requirement that clear boundaries separate the concentric layers of the system.
- [Component Boundaries](https://banes-lab.com/records/lex/component-boundaries.md): The requirement that each component expose a well-defined boundary and interface.
- [Dependency Rule](https://banes-lab.com/records/lex/dependency-rule.md): The requirement that source-code dependencies point only inward, toward higher-level policy.
- [Domain Core](https://banes-lab.com/records/lex/domain-core.md): The requirement that pure domain logic occupy the core, isolated from external concerns.
- [Layer Separation](https://banes-lab.com/records/lex/layer-separation.md): The requirement that responsibilities be divided into distinct, ordered layers.
- [Ports](https://banes-lab.com/records/lex/ports.md): The requirement that the core define abstract interface points through which all external interaction passes.
- [Replicated In-Memory State](https://banes-lab.com/records/lex/replicated-in-memory-state.md): The requirement that application state be kept in replicated in-memory grids rather than a central store.
- [Unified Deployment Boundary](https://banes-lab.com/records/lex/unified-deployment-boundary.md): The requirement that the whole application build and deploy as one unit.
- [Uniform Stage Interface](https://banes-lab.com/records/lex/uniform-stage-interface.md): The requirement that every stage share one interface so stages can be composed freely.
- [Use Cases](https://banes-lab.com/records/lex/use-cases.md): The requirement that application operations be captured as explicit use cases in their own layer.
- [Anemic Layers](https://banes-lab.com/records/lex/anemic-layers.md): The degree to which strict layering produces thin pass-through layers that add indirection without logic.
- [End-to-End Traceability](https://banes-lab.com/records/lex/end-to-end-traceability.md): The degree to which decomposing flow into independent filters makes tracing a request end to end harder.
- [Feature Cohesion](https://banes-lab.com/records/lex/feature-cohesion.md): The degree to which all code serving one feature is grouped together rather than scattered by layer.
- [Independent Scaling](https://banes-lab.com/records/lex/independent-scaling.md): The degree to which a single deployable unit prevents scaling parts of the system independently.
- [Initial Complexity](https://banes-lab.com/records/lex/initial-complexity.md): The degree of upfront structural complexity introduced by defining ports and adapters.
- [Integration Overhead](https://banes-lab.com/records/lex/integration-overhead.md): The degree of effort required to wire independently-developed components together.
- [Operational Simplicity](https://banes-lab.com/records/lex/operational-simplicity.md): The degree to which a single deployable unit keeps building, deploying, and operating simple.
- [Shared Technical Concerns](https://banes-lab.com/records/lex/shared-technical-concerns.md): The degree to which grouping by feature complicates sharing cross-cutting technical code.