# Architecture principles whose type is pattern

> 69 records

This index as JSON: https://banes-lab.com/json/api/facets/architecture/type/pattern

## Entries

- [Anti-Corruption Layer](https://banes-lab.com/records/architecture/anti-corruption-layer.md): A design pattern that translates an external system's model into the local domain's terms at the boundary.
- [Aggregate](https://banes-lab.com/records/architecture/aggregate.md): A design pattern that groups entities under one root, which is the only entry point and keeps the group's invariants.
- [Value Object](https://banes-lab.com/records/architecture/value-object.md): A design pattern that models a domain value as an immutable, self-validating object compared by its attributes.
- [Entity](https://banes-lab.com/records/architecture/entity.md): A design pattern that models a domain object by a stable identity, which stays the same while its attributes change.
- [Domain Service](https://banes-lab.com/records/architecture/domain-service.md): A design pattern that places a domain rule spanning several entities in a stateless service named in the domain's language.
- [Centralized Configuration](https://banes-lab.com/records/architecture/centralized-configuration.md): A design pattern that keeps every service's configuration in one versioned store the services read from.
- [Centralized Authentication](https://banes-lab.com/records/architecture/centralized-authentication.md): A design pattern that verifies identity once, at a shared identity provider, and passes the result to each service.
- [Centralized Logging](https://banes-lab.com/records/architecture/centralized-logging.md): A design pattern that ships structured logs from every instance to one aggregated store.
- [Publish/Subscribe Pattern](https://banes-lab.com/records/architecture/publish-subscribe-pattern.md): A design pattern in which publishers send messages to a topic and every subscriber to that topic receives them.
- [Event Sourcing](https://banes-lab.com/records/architecture/event-sourcing.md): A design pattern that stores state as the sequence of events that produced it and rebuilds current state by replaying them.
- [CQRS](https://banes-lab.com/records/architecture/command-query-responsibility-segregation.md): A design pattern that separates the model that handles commands from the model that answers queries.
- [Domain Events](https://banes-lab.com/records/architecture/domain-events.md): A design pattern that records each significant change in the domain as an event named in the domain's language.
- [Integration Events](https://banes-lab.com/records/architecture/integration-events.md): A design pattern that publishes a versioned public event, mapped from an internal domain event, for consumers outside the service.
- [Saga Pattern](https://banes-lab.com/records/architecture/saga-pattern.md): A design pattern that runs a cross-service transaction as a sequence of local steps, each paired with a compensating step.
- [Outbox Pattern](https://banes-lab.com/records/architecture/outbox-pattern.md): A design pattern that writes an outgoing message in the same local transaction as the state change, and a relay publishes it afterwards.
- [Append-Only Log](https://banes-lab.com/records/architecture/append-only-log.md): A design pattern that records history as immutable entries added at the end of the log.
- [Dead-Letter Queue](https://banes-lab.com/records/architecture/dead-letter-queue.md): A design pattern that moves a message which keeps failing into a separate queue, where it can be inspected and reprocessed.
- [Idempotent Consumer](https://banes-lab.com/records/architecture/idempotent-consumer.md): A design pattern in which a consumer records each message it has processed, so a redelivered message has no second effect.
- [Competing Consumers](https://banes-lab.com/records/architecture/competing-consumers.md): A design pattern in which several consumers read from one queue, and each message goes to only one of them.
- [Error Boundaries](https://banes-lab.com/records/architecture/error-boundaries.md): A design pattern that catches failures at a component boundary, so a failing part renders or returns an error while the rest keeps running.
- [Fallback Pattern](https://banes-lab.com/records/architecture/fallback-pattern.md): A design pattern that routes a failed call to an alternate provider or response declared in advance.
- [Retry Pattern](https://banes-lab.com/records/architecture/retry-pattern.md): A design pattern that repeats an idempotent call after a transient failure, a bounded number of times with backoff.
- [Timeout Pattern](https://banes-lab.com/records/architecture/timeout-pattern.md): A design pattern that gives every external call a time budget and fails the call when the budget runs out.
- [Circuit Breaker Pattern](https://banes-lab.com/records/architecture/circuit-breaker-pattern.md): A design pattern that stops calling a dependency after repeated failures and probes it again after a wait.
- [Bulkhead Pattern](https://banes-lab.com/records/architecture/bulkhead-pattern.md): A design pattern that gives each workload its own pool of threads or connections, so one workload cannot exhaust the others.
- [Manifest-Based Design](https://banes-lab.com/records/architecture/manifest-based-design.md): A design pattern that loads modules or plugins from a validated manifest listing each entry, version and dependency.
- [Domain-Specific Language (DSL)](https://banes-lab.com/records/architecture/domain-specific-language.md): A design pattern that expresses a domain's rules or workflows in a small language with a defined grammar and a validator.
- [Retrieval-Augmented Generation (RAG)](https://banes-lab.com/records/architecture/retrieval-augmented-generation.md): A design pattern that retrieves relevant documents for a question and passes them to the model, so the answer can cite its sources.
- [Knowledge Graphs](https://banes-lab.com/records/architecture/knowledge-graphs.md): A design pattern that stores knowledge as typed entities and named relations, validated against a schema, so queries can traverse them.
- [Agentic Architecture](https://banes-lab.com/records/architecture/agentic-architecture.md): A design pattern in which the model chooses actions from a scoped set of tools, within a step limit and under review.
- [Strategy Pattern](https://banes-lab.com/records/architecture/strategy-pattern.md): A design pattern that puts each interchangeable algorithm behind one interface, so the caller selects behavior by passing an object.
- [Template Method Pattern](https://banes-lab.com/records/architecture/template-method-pattern.md): A design pattern that fixes the steps of an algorithm in a base class and lets subclasses supply the steps that vary.
- [Observer Pattern](https://banes-lab.com/records/architecture/observer-pattern.md): A design pattern in which a subject publishes events to subscribers it does not know by name.
- [Mediator Pattern](https://banes-lab.com/records/architecture/mediator-pattern.md): A design pattern that routes the interactions between a set of objects through one coordinating object.
- [Command Pattern](https://banes-lab.com/records/architecture/command-pattern.md): A design pattern that wraps a request in an object, so it can be queued, deferred or undone.
- [State Pattern](https://banes-lab.com/records/architecture/state-pattern.md): A design pattern that gives each state of an object its own class, so behavior and legal transitions change with the state.
- [Chain of Responsibility Pattern](https://banes-lab.com/records/architecture/chain-of-responsibility-pattern.md): A design pattern that passes a request along an ordered list of handlers until one of them handles it.
- [Iterator Pattern](https://banes-lab.com/records/architecture/iterator-pattern.md): A design pattern that lets callers traverse a collection without seeing how it is stored.
- [Visitor Pattern](https://banes-lab.com/records/architecture/visitor-pattern.md): A design pattern that places each operation over a type hierarchy in its own visitor, so an operation is added without editing the element types.
- [Memento Pattern](https://banes-lab.com/records/architecture/memento-pattern.md): A design pattern in which an object captures its own state in an opaque snapshot it can later restore.
- [Null Object Pattern](https://banes-lab.com/records/architecture/null-object-pattern.md): A design pattern that represents absence with an object implementing the expected interface as a no-op.
- [Factory Pattern](https://banes-lab.com/records/architecture/factory-pattern.md): A design pattern that moves the construction of an object and its defaults into one function or object.
- [Factory Method Pattern](https://banes-lab.com/records/architecture/factory-method-pattern.md): A design pattern in which a base class calls an overridable method to create the objects its workflow uses.
- [Abstract Factory Pattern](https://banes-lab.com/records/architecture/abstract-factory-pattern.md): A design pattern that creates a whole family of related objects through one interface, so the members always match.
- [Builder Pattern](https://banes-lab.com/records/architecture/builder-pattern.md): A design pattern that assembles a complex object step by step through named calls and validates it when it is built.
- [Prototype Pattern](https://banes-lab.com/records/architecture/prototype-pattern.md): A design pattern that creates new objects by cloning a prepared template and applying overrides.
- [Singleton Pattern](https://banes-lab.com/records/architecture/singleton-pattern.md): A design pattern that restricts a class to one instance, reached through a global access point.
- [Adapter Pattern](https://banes-lab.com/records/architecture/adapter-pattern.md): A design pattern that wraps a component with an incompatible interface so it implements the interface its callers expect.
- [Facade Pattern](https://banes-lab.com/records/architecture/facade-pattern.md): A design pattern that gives a subsystem one simple entry point, so callers do not depend on its parts.
- [Proxy Pattern](https://banes-lab.com/records/architecture/proxy-pattern.md): A design pattern that places a stand-in with the same interface in front of an object, to control, defer or cache access to it.
- [Bridge Pattern](https://banes-lab.com/records/architecture/bridge-pattern.md): A design pattern that separates two independent axes of variation into two hierarchies joined by composition.
- [Decorator Pattern](https://banes-lab.com/records/architecture/decorator-pattern.md): A design pattern that adds behavior to an object by wrapping it in another object with the same interface.
- [Composite Pattern](https://banes-lab.com/records/architecture/composite-pattern.md): A design pattern that gives leaves and groups one interface, so a tree is traversed without checking which kind each node is.
- [Flyweight Pattern](https://banes-lab.com/records/architecture/flyweight-pattern.md): A design pattern that shares one copy of immutable intrinsic state among many objects, each keeping only its own extrinsic state.
- [Sharding](https://banes-lab.com/records/architecture/sharding.md): A design pattern that splits a dataset across separate stores by a shard key, and routes each request to the shard that holds its key.
- [Caching](https://banes-lab.com/records/architecture/caching.md): A design pattern that stores the result of an expensive read or computation under a key derived from every input it depends on, and serves it again while that key matches.
- [Pipeline Architecture](https://banes-lab.com/records/architecture/pipeline-architecture.md): A design pattern that splits processing into ordered stages, each with a declared input and output contract.
- [Sequential Access](https://banes-lab.com/records/architecture/sequential-access.md): A design pattern that reads a source in its stored order through a cursor or scan, instead of looking records up one by one.
- [Fan-out/Fan-in](https://banes-lab.com/records/architecture/fan-out-fan-in.md): A design pattern that splits work into independent parts processed in parallel, then merges their results.
- [Dependency Injection](https://banes-lab.com/records/architecture/dependency-injection.md): A design pattern that passes an object its dependencies from outside, usually through its constructor.
- [Registry Pattern](https://banes-lab.com/records/architecture/registry-pattern.md): A design pattern that replaces a conditional over kinds with a keyed table that each kind registers itself into.
- [Service Locator Pattern](https://banes-lab.com/records/architecture/service-locator-pattern.md): A design pattern in which code fetches its dependencies from a global registry at the point of use.
- [Blue-Green Deployment](https://banes-lab.com/records/architecture/blue-green-deployment.md): A design pattern that deploys a release to an idle copy of production, verifies it, and switches traffic to it at once.
- [Canary Deployment](https://banes-lab.com/records/architecture/canary-deployment.md): A design pattern that sends a small share of traffic to a new release and widens the share only while its error and latency stay within limits.
- [Canonical Data Model](https://banes-lab.com/records/architecture/canonical-data-model.md): A design pattern in which integrated systems exchange data through one shared model, with a mapping per system.
- [Sideways Overflow](https://banes-lab.com/records/architecture/sideways-overflow.md): A design pattern that resolves a naming collision with the filename's variant slot and resolves breadth with a sibling subject folder.
- [Unit of Work Pattern](https://banes-lab.com/records/architecture/unit-of-work-pattern.md): A design pattern that collects the changes of one use case and commits them together in a single transaction.
- [Optimistic Locking](https://banes-lab.com/records/architecture/optimistic-locking.md): A design pattern that checks a record's version when it is written and rejects the write if another writer changed it first, comparing only the writer's own span where a surface is fenced per writer.
- [Pessimistic Locking](https://banes-lab.com/records/architecture/pessimistic-locking.md): A design pattern that locks a record before reading it for update, so other writers wait until the transaction ends.