BFF (Backend for Frontend)
BFF stands for Backend for Frontend, a pattern in which each client experience (web, mobile, partner API) gets its own dedicated backend that aggregates and tailors data for that client. It avoids a single bloated general-purpose API and lets client teams iterate independently. Each BFF is itself a small service in front of the shared downstream services.
DDD (Domain-Driven Design)
DDD stands for Domain-Driven Design, an approach to software design that puts the business domain model and a shared ubiquitous language at the centre. Its strategic patterns, especially bounded contexts, are the most common technique for deciding microservice boundaries. Its tactical patterns shape each service's internal model.
DLQ (Dead Letter Queue)
DLQ stands for Dead Letter Queue, a destination for messages that cannot be processed after the configured number of retries. It isolates poison messages so they stop blocking a consumer, and preserves them for later inspection or replay. Operating a DLQ with alerting is a baseline reliability practice for event-driven systems.
CQRS (Command Query Responsibility Segregation)
CQRS stands for Command Query Responsibility Segregation, separating the write model (commands) from the read model (queries) so each can be optimised independently. In distributed systems it commonly drives denormalised read models updated by events. It adds operational complexity and is warranted only when read and write needs genuinely diverge.
2PC (Two-Phase Commit)
2PC stands for Two-Phase Commit, a distributed atomic-commit protocol with a prepare phase and a commit phase coordinated by a transaction manager. It guarantees atomicity across resources but blocks on coordinator failure and scales poorly, so it is generally avoided across microservices. Sagas with compensation are the usual alternative.
SLA (Service-Level Agreement)
SLA stands for Service-Level Agreement, a formal, often contractual commitment about a service's expected level of service, such as monthly availability, with consequences for breaching it. It is the external promise made to consumers. It is supported internally by tighter SLOs and measured by SLIs.
SLO (Service-Level Objective)
SLO stands for Service-Level Objective, an internal target for a reliability metric such as availability or latency over a window. SLOs are set tighter than any external SLA to give a safety margin and to drive error budgets. They turn reliability into a measurable engineering goal.
SLI (Service-Level Indicator)
SLI stands for Service-Level Indicator, the actual measured quantity that an SLO is a target for, such as the proportion of successful requests or the p99 latency. It must be carefully defined, including what counts as a request and as success. A good SLI reflects the user's experience of the service.
RPC (Remote Procedure Call)
RPC stands for Remote Procedure Call, a style of inter-service communication that makes a call to a remote service look like a local function call. Modern implementations such as gRPC use HTTP/2 and binary serialization for efficiency. RPC is convenient but can hide the cost and failure modes of the network.
REST (Representational State Transfer)
REST stands for Representational State Transfer, an architectural style for networked APIs built on resources, uniform HTTP methods, and stateless interactions. It is the most common style for public and synchronous microservice APIs. Its constraints favour cacheability, evolvability, and loose coupling.
gRPC
gRPC is a high-performance RPC framework using HTTP/2 and Protocol Buffers. The g is often read as a recursive nod to gRPC itself rather than a fixed expansion. It generates typed stubs from a schema and supports streaming, making it popular for internal, high-throughput service-to-service calls.
API (Application Programming Interface)
API stands for Application Programming Interface, the contract through which one service is invoked by another, defining operations, inputs, outputs, and error semantics. In microservices the API is the only sanctioned way to use another service's capabilities or data. Stable, versioned APIs are what make independent deployment possible.
SAGA
A saga is a sequence of local transactions, each in a different service, that together implement a business transaction spanning services, with compensating transactions to undo completed steps on failure. It replaces distributed ACID transactions with eventual consistency. Sagas are coordinated either by orchestration or by choreography.
ACL (Anti-Corruption Layer)
ACL stands for Anti-Corruption Layer, a DDD pattern in which a translation layer protects a bounded context from the model of an external or legacy system. It maps foreign concepts into the local ubiquitous language so the legacy model does not leak in. It is especially useful during a strangler-fig migration.
OTel (OpenTelemetry)
OTel stands for OpenTelemetry, a vendor-neutral, CNCF-hosted standard and toolkit for generating, collecting, and exporting telemetry: traces, metrics, and logs. It provides language SDKs and a collector so instrumentation is decoupled from the observability backend. It is the dominant standard for instrumenting microservices.
CNCF (Cloud Native Computing Foundation)
CNCF stands for Cloud Native Computing Foundation, the Linux Foundation body that hosts and stewards many of the projects central to microservices, including Kubernetes, Prometheus, Envoy, and OpenTelemetry. Its graduated and incubating tiers signal project maturity. It effectively curates the cloud-native ecosystem.
mTLS (Mutual TLS)
mTLS stands for Mutual Transport Layer Security, an arrangement in which both client and server present and verify certificates so each authenticates the other. In a service mesh it secures and authenticates all service-to-service traffic by default. It is a core mechanism for zero-trust networking between services.
HPA (Horizontal Pod Autoscaler)
HPA stands for Horizontal Pod Autoscaler, the Kubernetes controller that automatically adjusts the number of pod replicas for a workload based on observed metrics such as CPU utilisation or custom metrics. It scales out under load and back in when idle. It is the standard way to scale stateless microservices on Kubernetes.
CI/CD (Continuous Integration / Continuous Delivery)
CI/CD stands for Continuous Integration and Continuous Delivery (or Deployment), the automated pipeline that builds, tests, and ships each change. Independent deployability of microservices depends on each service having its own fast, reliable pipeline. Mature CI/CD is a prerequisite for operating many services safely.
P99 (99th Percentile Latency)
P99 denotes the 99th-percentile latency, the response time below which 99% of requests complete; only the slowest 1% are above it. Tail percentiles like p95 and p99 reveal the worst experiences that averages hide. They are the latencies that matter for SLOs because they shape perceived reliability.
TTL (Time To Live)
TTL stands for Time To Live, a duration after which a cached entry, message, or record is considered expired. In microservices it bounds how stale cached cross-service data may become and helps clean up transient state. Choosing a TTL trades freshness against load on the source of truth.
NFR (Non-Functional Requirement)
NFR stands for Non-Functional Requirement, a quality constraint on a system such as performance, scalability, availability, or security, as opposed to a specific feature. Microservice architectures are largely a response to NFRs like independent scalability and team autonomy. They should be made explicit and measurable.
VM (Virtual Machine)
VM stands for Virtual Machine, a software-emulated computer with its own guest operating system running on a hypervisor. VMs provide strong isolation but are heavier and slower to start than containers. Containers, which share the host kernel, are the more common unit of deployment for microservices.
ESB (Enterprise Service Bus)
ESB stands for Enterprise Service Bus, a centralised integration backbone from the SOA era that performs routing, transformation, and orchestration. Microservices deliberately move logic out of such smart middleware toward smart endpoints and dumb pipes. The ESB is often cited as the anti-pattern microservices react against.
SOA (Service-Oriented Architecture)
SOA stands for Service-Oriented Architecture, an earlier style of building systems from reusable, network-accessible services, often integrated through an ESB. Microservices are frequently described as a fine-grained, decentralised evolution of SOA. They keep the service idea but reject heavyweight shared middleware and shared databases.
YAGNI (You Aren't Gonna Need It)
YAGNI stands for You Aren't Gonna Need It, the principle of not building functionality until it is actually required. In microservices it argues against splitting services or adding caches, queues, and CQRS speculatively. Premature decomposition is a frequent and costly violation of YAGNI.
RTO / RPO (Recovery Time / Recovery Point Objective)
RTO and RPO are disaster-recovery targets: RTO is how quickly service must be restored after an outage, and RPO is how much data loss, measured in time, is acceptable. They drive backup frequency, replication, and failover design for each service's data store. Per-service data ownership means these targets can differ by service.