arch.backend

Package arch.backend · Version 0.1.0

The default vocabulary for server-side architecture. Provides module kinds for databases (relational, document, key-value, search, columnar, graph, time-series, vector, object storage), caches, message queues and brokers, plus infrastructure, observability, and security building blocks.

It also defines the wire-level interface kinds — http_*, grpc_*, kafka, and friends — with baseline edge styling, so the protocol a module speaks is part of its declaration. Each kind ships a default widget (icon, color, sizing) from [[arch.ui]].

Treat it as a palette — import the kinds you use, e.g. use service, postgres, kafka, redis from arch.backend.

Types

Type	Extends	Description
service	module	A network-addressable backend service — the default building block of a microservice architecture
database	module	A persistent primary data store; nest it inside its single owning service, and choose cache for ephemeral stores
cache	database	An ephemeral cache — a squat database variant that distinguishes short-lived stores from primary ones
db_read	interface	A data-access interface expressing read/query intent against a database or cache, independent of the underlying wire
db_write	interface	A data-access interface expressing write/command intent against a database or cache, independent of the underlying wire
system	module	A logical grouping that hosts a subspace of services and components
frontend	module	A user-facing application such as a web UI, SPA or admin portal
component	module	An in-process building block of a larger service or system
worker	module	A background consumer or job runner with no synchronous inbound surface — it drains queues, reacts to events or runs on a schedule
external_system	module	A third-party or external dependency — a SaaS vendor, a legacy platform, another team’s product
relational	database	Row-oriented, ACID, SQL-first store — the default workhorse for transactional data
postgres	relational	Open-source relational engine with a rich extension ecosystem; the general-purpose default in this family
mysql	relational	Open-source relational engine; choose when the stack already standardizes on the MySQL ecosystem
mariadb	relational	Community-governed MySQL-compatible fork; choose as a drop-in alternative to mysql
sqlite	relational	Embedded in-process relational engine storing data in a single file; choose for local or single-node persistence without a server
mssql	relational	Microsoft’s relational engine; choose in Windows- and .NET-centric stacks
oracle	relational	Commercial relational engine; choose when the organization already runs on Oracle tooling and support
cockroachdb	relational	Distributed SQL engine speaking the PostgreSQL wire protocol; choose for horizontal scale and survival of node or region loss
vitess	relational	Sharding layer that clusters MySQL into a horizontally scalable system; choose to scale an existing MySQL footprint
ydb	relational	Distributed SQL engine combining relational tables with built-in persistent queues (topics); choose in Yandex-ecosystem stacks
document	database	Schemaless document store with secondary indexes; choose for flexible nested shapes over fixed relational schemas
mongodb	document	General-purpose document store with rich query and aggregation over BSON documents
couchdb	document	Document store accessed over HTTP with multi-master replication; choose for offline-first and sync-heavy designs
couchbase	document	Distributed document store with a built-in caching layer and SQL-like querying; choose for low-latency interactive workloads
hyperscale	database	Partitioned wide-column store built for very large write-heavy workloads
cassandra	hyperscale	Ring-topology wide-column store with tunable consistency; the archetype of this family
scylladb	hyperscale	Cassandra-compatible wide-column store with a shard-per-core architecture; choose as a drop-in alternative to cassandra
hbase	hyperscale	Wide-column store over HDFS with strongly consistent row operations; choose in Hadoop-centric stacks
object_storage	database	Blob-bucket store with range reads and lifecycle policies; choose for large immutable objects rather than queryable records
minio	object_storage	S3-compatible object store that deploys as a single binary; choose for self-hosted S3 semantics
ceph	object_storage	Distributed storage cluster exposing object, block and filesystem interfaces; choose for large multi-purpose storage estates
seaweedfs	object_storage	Distributed object store designed for high volumes of small files
garage	object_storage	Lightweight S3-compatible object store aimed at self-hosted, geo-distributed deployments
kv_store	database	Persistent key-value store for single-key lookup; choose over cache when the data is durable rather than an ephemeral hot-data tier
etcd	kv_store	Strongly consistent distributed key-value store built on Raft; choose for cluster coordination and configuration data (as the discovery/config plane, use service_discovery + aspect engine: "etcd")
tarantool	kv_store	In-memory data grid with write-ahead-log persistence (as a pure cache tier, cache + aspect engine: "tarantool" also works)
redis	cache	In-memory data-structure store with rich value types; the default choice for a cache tier (as a broker, use message_broker redis_streams; the pub/sub wire is the redis_pubsub interface)
memcached	cache	Minimal in-memory key-value cache; choose for plain byte-value caching without data structures
keydb	cache	Redis-compatible in-memory store with multithreaded execution; choose as a drop-in alternative to redis
hazelcast	cache	Distributed in-memory data grid for JVM-centric stacks
search_index	database	Inverted-index store for full-text and faceted query; choose when relevance-ranked search is the primary access pattern
elasticsearch	search_index	Distributed search and analytics engine with a JSON query DSL; choose for large-cluster search and aggregation workloads
opensearch	search_index	Community-governed fork of Elasticsearch; choose for a compatible API under a permissive open-source license
solr	search_index	Lucene-based search server with rich faceting; choose in stacks already invested in its ecosystem
meilisearch	search_index	Lightweight typo-tolerant search engine with on-disk indexes; choose for user-facing instant search with minimal setup
typesense	search_index	Lightweight typo-tolerant search engine that holds its index in memory; choose for user-facing instant search when the corpus fits in RAM
columnar	database	Column-oriented analytics engine; choose for OLAP scans and aggregations over row-level transactional access
clickhouse	columnar	Column-oriented OLAP engine for interactive analytics over high-ingest event data
duckdb	columnar	Embedded in-process analytics engine; choose for local OLAP over files without running a server
druid	columnar	Distributed real-time analytics store with streaming ingestion; choose for interactive exploration of event streams
pinot	columnar	Distributed OLAP store with streaming ingestion; choose for high-concurrency user-facing analytics
graph_db	database	Native graph store with traversal as a first-class query primitive; choose when relationship hops dominate the queries
neo4j	graph_db	Native property-graph database queried with Cypher; the general-purpose default in this family
arangodb	graph_db	Multi-model engine combining graph, document and key-value; choose when graph is one of several access patterns
dgraph	graph_db	Distributed native graph database with a GraphQL-flavored query language; choose for horizontally scaled graph workloads
janusgraph	graph_db	Graph layer over pluggable wide-column storage backends; choose to run graph workloads on an existing cassandra or hbase cluster
tigergraph	graph_db	Distributed graph database aimed at deep multi-hop analytical queries
timeseries	database	Append-heavy, time-partitioned store with downsampling and retention built in; choose for high-volume timestamped series
influxdb	timeseries	Purpose-built timeseries engine with retention and downsampling tooling; the general-purpose default in this family
timescaledb	timeseries	Timeseries engine packaged as a PostgreSQL extension; choose to keep series data inside a relational stack
questdb	timeseries	SQL-queried timeseries engine oriented toward high-rate ingestion
m3db	timeseries	Distributed timeseries store designed for horizontal scale; choose when series volume outgrows a single node
vector	database	ANN index over embedding vectors; choose for similarity search in retrieval and recommendation workloads
weaviate	vector	Vector database with hybrid keyword-plus-vector search; choose when lexical and semantic retrieval combine
qdrant	vector	Vector search engine with rich payload filtering; choose when metadata filters gate similarity queries
milvus	vector	Distributed vector database built for horizontal scale; choose for very large vector collections
chroma	vector	Lightweight embedding store; choose for local development and small retrieval workloads
lancedb	vector	Embedded vector database over a columnar on-disk format; choose for in-process vector search without a server
gateway	module	API gateway / edge reverse proxy — terminates external traffic and routes it by application semantics (auth, rate limits, paths)
bpm_system	module	Workflow / BPM orchestrator for long-running stateful processes — retries, signals, timers, human tasks, DAG schedules
camunda	bpm_system	BPMN workflow and decision automation engine with human-task support
zeebe	bpm_system	Horizontally scalable BPMN workflow engine
flowable	bpm_system	BPMN workflow engine also covering case management and decision models
activiti	bpm_system	Embeddable BPMN workflow engine for Java applications
temporal	bpm_system	Durable code-first workflow engine — workflows are ordinary code with persisted state and automatic retries
cadence	bpm_system	Durable code-first workflow engine from Uber; temporal descends from it — choose where cadence is already deployed
conductor	bpm_system	Workflow orchestration engine coordinating microservice tasks over JSON-defined flows
n8n	bpm_system	Low-code visual workflow automation connecting apps and APIs
load_balancer	module	L4/L7 load balancer spreading connections across service replicas — choose gateway when routing is by application semantics
cdn	module	Content delivery network — edge caching and static asset delivery (arch.c4 also ships a cdn infrastructure node — import selectively if you use both)
waf	module	Web application firewall — inspects and blocks malicious requests at the edge
rate_limiter	module	Standalone rate-limiting / throttling tier — use when the limiter is its own deployed component rather than a gateway feature
service_mesh	module	Service mesh — mTLS, retries, traffic shaping and telemetry for service-to-service traffic; one module per control plane, sidecar/eBPF proxies implied
istio	service_mesh	Envoy-based service mesh for traffic management, mTLS and policy
linkerd	service_mesh	Kubernetes service mesh with a lightweight Rust micro-proxy data plane
consul_connect	service_mesh	Service mesh built into Consul, using its service catalog for identity and mTLS
kuma	service_mesh	Envoy-based service mesh running across Kubernetes and VMs
cilium	service_mesh	eBPF-based service mesh with a sidecar-free, in-kernel data plane
service_discovery	module	Dynamic service registry and distributed configuration plane
consul	service_discovery	Service registry with health checking and distributed configuration (as a standalone KV store, use kv_store + aspect engine: "consul")
zookeeper	service_discovery	Distributed coordination service providing registry, configuration and leader election
eureka	service_discovery	REST-based service registry for client-side discovery
nacos	service_discovery	Combined service registry and dynamic configuration platform
feature_flags	module	Runtime feature-flag and experiment evaluation service
unleash	feature_flags	Feature-flag service with strategy-based gradual rollouts
flagsmith	feature_flags	Feature-flag and remote-config service with segment targeting
flipt	feature_flags	Self-hosted feature-flag service with REST and gRPC APIs
growthbook	feature_flags	Combined feature-flag and A/B-experimentation platform
event	interface	A transport-agnostic domain event — declared on the PRODUCER (its published contract); consumers subscribe by referencing it (Shipping > Orders.orderEvents)
kafka	interface	A Kafka topic — distributed-log event streaming between services; choose over event when the transport is known to be Kafka
amqp	interface	An AMQP queue or exchange binding — events and task queues both ride the wire; stamp aspect intent per declaration
nats	interface	A NATS subject — lightweight cloud-native pub/sub with dot-separated subjects; override aspect intent for request-reply RPC
mqtt	interface	An MQTT topic — pub/sub built for IoT and low-bandwidth devices, slash-separated topics
redis_pubsub	interface	A Redis pub/sub channel — ephemeral in-memory fan-out; messages drop when no subscriber listens
message_broker	module	The deployed broker module that hosts event interfaces — attached to them as aspect broker:, never a hop on the call path
kafka_cluster	message_broker	A deployed Kafka cluster — distributed partitioned append-only log, replay-friendly
redpanda	message_broker	A deployed Redpanda cluster — Kafka-API-compatible streaming log
pulsar	message_broker	A deployed Apache Pulsar cluster — distributed streaming log with built-in multi-tenancy
rabbitmq	message_broker	A deployed RabbitMQ broker — classic queue-and-exchange messaging over AMQP
activemq	message_broker	A deployed ActiveMQ broker — classic JMS-style broker that also speaks AMQP
ibm_mq	message_broker	A deployed IBM MQ queue manager — commercial message queueing for enterprise and mainframe integration
nats_server	message_broker	A deployed NATS server or cluster — subject-routed pub/sub with a small operational footprint
mqtt_broker	message_broker	A deployed MQTT broker — generic topic-routed device messaging endpoint; pick a vendor type when the product is known
mosquitto	message_broker	A deployed Eclipse Mosquitto broker — lightweight open-source MQTT broker suited to small and embedded setups
hivemq	message_broker	A deployed HiveMQ broker — commercial MQTT platform built for large device fleets
nsq	message_broker	A deployed NSQ cluster — decentralized realtime messaging with no central coordinator
redis_streams	message_broker	A Redis deployment used as a persistent append-only log via the Streams API (as a cache tier, use cache redis)
queue	module	A point-to-point work queue distributing jobs to competing workers — a place, not a hop: the worker owns the handler interface carrying aspect queue:; pairs with worker
observability	module	A telemetry platform module — a deployed system that collects, stores, visualizes or alerts on metrics, logs and traces
metrics_system	observability	An observability system that scrapes, stores and queries numeric time series
prometheus	metrics_system	Pull-based metrics scrape-and-store engine with a built-in query language (as a generic TSDB, use timeseries + aspect engine: "prometheus")
victoriametrics	metrics_system	Metrics engine focused on high-cardinality ingestion and low resource use
thanos	metrics_system	Sidecar-based long-term-storage and global-query layer over existing prometheus servers
mimir	metrics_system	Long-term metrics store for the prometheus ecosystem in the Grafana stack, fed by remote write; descends from cortex
cortex	metrics_system	Multi-tenant metrics store for the prometheus ecosystem, fed by remote write; choose mimir for new Grafana-stack deployments, cortex where one already runs
graphite	metrics_system	Push-based metrics store organized around dot-separated metric names; choose for StatsD-style pipelines rather than labeled series
logging_system	observability	An observability system that aggregates, indexes and queries application and infrastructure logs
loki	logging_system	Log aggregation store that indexes labels rather than full log content; choose when logs sit alongside metrics in a Grafana stack
graylog	logging_system	Self-contained log management platform with full-text search, streams and alerting built in
logstash	logging_system	Server-side log pipeline that ingests, transforms and forwards events; choose for rich processing in an Elastic stack
fluentd	logging_system	Pluggable log collector and router with a broad plugin ecosystem; choose for vendor-neutral log routing
tracing_system	observability	An observability system that records distributed traces — span trees across services
jaeger	tracing_system	Distributed tracing backend and UI with pluggable storage; choose for a standalone tracing deployment
tempo	tracing_system	Object-storage-backed trace store in the Grafana stack; choose when traces are explored through grafana alongside metrics and logs
zipkin	tracing_system	Distributed tracing system with a simple collector and UI; choose where existing instrumentation already emits zipkin spans
dashboard	observability	An observability front-end that queries and charts data from the telemetry stores
grafana	dashboard	Dashboard and visualization front-end with datasource plugins for many backends; choose for dashboards that span multiple telemetry stores
kibana	dashboard	Visualisation and exploration UI for the Elastic stack; choose when the data already lives in elasticsearch
collector	observability	An observability agent or router that receives, batches and forwards telemetry to the stores
otel_collector	collector	Vendor-neutral telemetry pipeline that receives, processes and exports metrics, logs and traces; the default collector for OpenTelemetry-instrumented systems
fluent_bit	collector	Lightweight telemetry forwarder suited to edge and sidecar deployment; choose over fluentd where footprint matters more than plugin breadth
vector_agent	collector	Log and metrics pipeline with a built-in transform language; choose for programmable routing and reshaping inside the agent
telegraf	collector	Plugin-driven agent that collects host and service metrics and pushes them to a store
alerting	observability	An observability system that evaluates rules over signals and routes notifications
alertmanager	alerting	Alert routing service for the prometheus ecosystem that groups, deduplicates, silences and dispatches notifications
karma	alerting	Dashboard for browsing and managing alertmanager alerts; choose for an aggregated view across alertmanager instances
apm	observability	An observability platform for application performance and error aggregation — exception grouping, latency profiles, release health
sentry	apm	Error tracking and performance monitoring platform centered on exception grouping and release health
signoz	apm	OpenTelemetry-native platform that combines metrics, traces and logs in one self-hosted backend; choose over running separate per-signal stores
skywalking	apm	Application performance monitor with distributed tracing and service topology mapping; choose for agent-based instrumentation across polyglot services
pyroscope	apm	Continuous profiling platform that stores and queries CPU and memory profiles; choose when the signal of interest is code-level resource use
glitchtip	apm	Error tracking platform compatible with sentry SDKs; choose as a leaner self-hosted alternative to sentry
http	interface	Synchronous HTTP request/response — the base type; verb subtypes stamp aspect intent
http_get	http	HTTP GET — safe read of a resource
http_post	http	HTTP POST — submits data or creates a subordinate resource
http_put	http	HTTP PUT — replaces a resource wholesale; choose http_patch for partial updates
http_patch	http	HTTP PATCH — applies a partial update to a resource
http_delete	http	HTTP DELETE — removes a resource
http_head	http	HTTP HEAD — headers-only probe; choose over http_get when only metadata matters
http_options	http	HTTP OPTIONS — capability discovery for a resource
webhook	http	An outbound callback over http — fire-and-forget async; most deliver fact notifications, so override aspect intent when the payload is an instruction
sse	http	Server-sent events — long-lived push stream over http; carries both event push and streamed query responses, so stamp aspect intent per declaration
rest	http	HTTP with resource semantics — parent of the rest_* operation subtypes
rest_list	rest	REST list — reads a collection of resources; choose rest_read for a single one
rest_create	rest	REST create — adds a resource to a collection
rest_read	rest	REST read — fetches a single resource by identity
rest_update	rest	REST update — modifies an existing resource
rest_delete	rest	REST delete — removes a resource
rest_crud	surface	A reusable REST CRUD surface — the five standard resource operations as one importable group
grpc	interface	gRPC over HTTP/2 — the base type; a call is a query or a command depending on the method, so stamp aspect intent per declaration
grpc_unary	grpc	gRPC unary call — single request, single response; the default RPC shape
grpc_server_stream	grpc	gRPC server-streaming call — single request, response stream from the server
grpc_client_stream	grpc	gRPC client-streaming call — request stream from the client, single response
grpc_bidi_stream	grpc	gRPC bidirectional streaming call — request and response streams over one connection
websocket	interface	A WebSocket connection — bidirectional long-lived channel; choose over sse when the client also sends
graphql	interface	GraphQL over HTTP — the base type; operation subtypes stamp aspect intent
graphql_query	graphql	GraphQL query — reads data from the graph
graphql_mutation	graphql	GraphQL mutation — writes changes to the graph
graphql_subscription	graphql	GraphQL subscription — async push stream of graph updates
identity_provider	module	Identity provider — issues tokens, authenticates principals and brokers SSO over OIDC, OAuth2 or SAML
keycloak	identity_provider	Identity provider organized around realms with an admin console, user federation and OIDC/OAuth2/SAML support
zitadel	identity_provider	Multi-tenant identity provider with OIDC, OAuth2 and SAML support
authentik	identity_provider	Identity provider and SSO broker supporting OIDC, SAML and LDAP
authelia	identity_provider	Authentication portal for reverse-proxied applications, adding SSO and multi-factor login
ory	identity_provider	Modular identity suite — separate services for user identity, OAuth2 issuance and permissions
dex	identity_provider	Federated OIDC provider brokering authentication to upstream identity systems through connectors
supertokens	identity_provider	Embeddable authentication service with prebuilt login flows and session management
casdoor	identity_provider	Identity and SSO platform supporting OIDC, OAuth2, SAML and CAS
fusionauth	identity_provider	Identity provider with per-application tenancy and registration flows; choose when each application needs its own auth configuration
secrets_manager	module	Central credential and key store with leasing, rotation and audit
vault	secrets_manager	Secrets manager with dynamic credentials, leasing and encryption-as-a-service
openbao	secrets_manager	Open-source secrets manager forked from Vault under open governance
infisical	secrets_manager	Secrets management platform oriented toward developer workflows and CI/CD secret syncing

---

See also: package.archspace reference · The standard library.