List of architectural metapatterns

Basic metapatterns

Basic metapatterns are both widespread stand-alone architectures and building blocks for more complex systems. They comprise the single-component monolithic architecture and the results of its division along each axis of coordinates (abstractness, subdomain and sharding):

Monolith

Monolith is a single-component system, the simplest possible architecture. It is easy to write but hard to evolve and maintain.

Includes: Reactor, Proactor, Half-Sync/Half-Async.

Shards

Shards are multiple instances of a monolith. They scale but usually require an external component for coordination.

Includes: Instances, Cells (Amazon definition); Sharding, Create on Demand, Pool.

Layers

Layers contain a component per level of abstractness. The layers may vary in technologies and forces and scale individually.

Includes: Multitier Architecture.

Services

Services divide the system by subdomain, often resulting in parts of comparable size to be assigned to dedicated teams. However, a system of services is hard to synchronize or debug.

Includes: Domain Services; Service-Based Architecture, Modular Monolith (Modulith), Microservices, device drivers, actors.

Pipeline

Pipeline is a kind of Services with unidirectional flow. Each service implements a single step of request processing. The system is flexible but may grow out of control.

Includes: Pipes and Filters, Choreographed Event-Driven Architecture, Nanoservices.

Extension metapatterns

These patterns extend services, shards or even a monolith with a layer that provides an aspect or two of the system’s behavior and often glues other components together.

Middleware

A middleware is a layer that implements communication between instances of the system’s components and may also manage the instances. This way each instance is relieved of the need to track other instances it deals with.

Includes: (Message) Broker, Deployment Manager.

Shared Repository

A shared repository stores the system’s data, maintains its integrity through transactions and may support subscriptions to changes in subsets of the data. That lets other system components concentrate on implementing the business logic.

Includes: Shared Database, Blackboard, Data Grid of Space-Based Architecture, shared memory, shared file system.

Proxy

A proxy mediates between the system and its clients, transparently taking care of some generic functionality.

Includes: Firewall, Response Cache, Load Balancer, Reverse Proxy, Adapter.

Orchestrator

An orchestrator implements use cases as sequences of calls to the underlying components, which are usually left unaware of each other’s existence.

Includes: Workflow Owner, Application Layer, Facade, Mediator; API Composer, Process Manager, Saga Execution Component, Integration (Micro-)Service.

Multifunctional components

Several patterns combine functionality of two or more extension layers.

Includes: Message Bus, API Gateway, Event Mediator, Enterprise Service Bus, Service Mesh, Middleware of Space-Based Architecture.

Fragmented metapatterns

There are patterns with no system-wide layers. Some of them incorporate two or three domains at various abstraction levels, so that a service (limited to a subdomain) in one domain acts as a layer for another domain.

Layered Services

Layered Services is an umbrella metapattern which highlights implementation details of Services or Pipeline.

Includes: orchestrated three-layered services, choreographed two-layered services, Command Query Responsibility Segregation (CQRS).

Polyglot Persistence

Polyglot Persistence is about using multiple data stores which differ in roles or technologies. Each of the upper-level components may have access to any data store. Each data store is a shared repository.

Includes: specialized databases, private and shared databases, data file, Content Delivery Network (CDN); read-only replica, Reporting Database, Memory Image, Query Service, search index, historical data, Cache-Aside.

Backends for Frontends

Backends for Frontends has a service (BFF) for each type of the system’s client. The BFF may be a proxy, orchestrator or both. Each BFF communicates with all the components below it. The pattern looks like multiple proxies or orchestrators deployed together.

Includes: Layered Microservice Architecture.

Service-Oriented Architecture

SOA has three or four layers of services, each in its own domain. The upper layer contains orchestrators which are often client-specific, like BFFs. The second layer contains business rules and is divided by the business subdomains. The lower layer(s) are libraries and utilities, grouped by functionality and technologies. Each component may use (orchestrates) all the components below it.

Includes: Segmented Architecture; distributed monolith, enterprise SOA.

Hierarchy

Some domains allow for hierarchical composition where the functionality is spread over a tree of components.

Includes: Orchestrator of Orchestrators, Bus of Buses, Cell-Based (Microservice) Architecture (WSO2 version) (Services of Services).

Implementation metapatterns

Several patterns emerge in the internal structure of components.

Plugins

The Plugins pattern is about separating the main logic from customizable details of the system’s behavior. That allows for the same code to be used for multiple flavors or customers.

Includes: Plug-In Architecture, Add-ons, Strategy, Hooks.

Hexagonal Architecture

Hexagonal Architecture is a specialization of Plugins where every external dependency is isolated behind an adapter and thus is easy to update or replace.

Includes: Ports and Adapters, Onion Architecture, Clean Architecture; Model-View-Controller (MVC).

Microkernel

This is another derivation of Plugins, with a rudimentary core component which mediates between resource consumers (applications) and resource providers. The microkernel is a middleware to the applications and an orchestrator to the providers.

Includes: operating system, software framework, distributed runtime, interpreter, configuration file, saga engine, AUTOSAR Classic Platform.

Mesh

A mesh consists of intercommunicating shards, each of which may host an application. The shards make a fault-tolerant distributed middleware.

Includes: grid; peer-to-peer networks, Leaf-Spine Architecture, actors, Service Mesh, Space-Based Architecture.