Microservices

CNCF Cloud-Native Definition & Principles

The CNCF’s formal definition of cloud-native computing and core principles for micro-services, containers, and dynamic orchestration.

Production-Ready Micro-services Checklist

A checklist covering operability, reliability, deployability, and observability of micro-services.

Contract-Driven Development with Pact

Consumer-driven contract testing methodology to ensure micro-service compatibility.

Distributed Tracing Best Practices

Techniques for instrumenting and propagating trace context across services so requests can be followed end-to-end, with sampling and span design that aid debugging.

CQRS (Command Query Responsibility Segregation)

An architecture pattern that separates the model that writes data (commands) from the model that reads it (queries), allowing each side to scale and evolve independently.

Event Sourcing

An architecture pattern that stores every change to application state as an immutable sequence of events, making the event log the source of truth instead of current state.

Saga Pattern

A pattern for managing data consistency across microservices using a sequence of local transactions coordinated by events or a central orchestrator, with compensating actions on failure.

Circuit Breaker Pattern

A resilience pattern that stops calls to a failing dependency once errors cross a threshold, preventing cascading failures and giving the dependency time to recover.

Bulkhead Pattern

A resilience pattern that isolates resources into separate pools so a failure or overload in one part of a system cannot consume the resources others depend on.

Backends for Frontends (BFF)

An architecture pattern that gives each frontend client its own tailored backend service, instead of forcing web, mobile, and other clients to share one general-purpose API.

API Gateway Pattern

An architecture pattern that places a single entry point in front of backend services to handle routing, authentication, rate limiting, and other cross-cutting concerns.

Service Mesh Best Practices

Guidance for using a service mesh to manage service-to-service traffic, security, and observability through sidecar proxies, keeping that logic out of application code.

Sidecar Pattern

A design pattern that deploys a helper component alongside the main application in the same unit, adding capabilities like proxying, logging, or config without changing the app.

Domain-Driven Design (DDD)

A software design approach that models complex business domains in code, using a shared language and bounded contexts to align software structure with the business it serves.

Modular Monolith

An architecture that keeps a single deployable application but enforces strong internal module boundaries, capturing many microservices benefits without distributed-system complexity.

gRPC Best Practices

Guidance for building high-performance gRPC services with Protocol Buffers: service design, streaming, deadlines, error codes, and backward-compatible schema evolution.

AsyncAPI Specification

A standard, machine-readable format for describing event-driven and message-based APIs across protocols like Kafka, MQTT, and AMQP, analogous to OpenAPI for REST.

Micro-Frontends

An architecture that splits a web app into independently developed and deployed frontend pieces owned by separate teams, then composes them into one experience.

Patterns39

Database per Service

Each microservice owns and manages its own database, enabling loose coupling and independent deployability

Saga Pattern

Manage data consistency across microservices using a sequence of local transactions with compensating actions

Sidecar Pattern

Deploy auxiliary components alongside primary services for cross-cutting concerns

API Gateway

A single entry point that routes, aggregates, and secures client requests across many backend microservices.

Service Registry

A database of available service instances and their network locations, kept current as instances start, stop, and fail.

Service Discovery

A mechanism for clients to find the current network location of a service without hard-coding addresses.

Ambassador

An out-of-process helper that proxies network calls on behalf of an application, handling connectivity concerns transparently.

Adapter Microservice

A microservice that translates between an application and an external system with an incompatible interface or protocol.

Service Mesh

A dedicated infrastructure layer that manages service-to-service communication via co-located proxies and a central control plane.

API Composition

Implements a query that spans multiple services by invoking each owner service and joining the results in memory.

CQRS (Command Query Responsibility Segregation)

Separates the model that writes data (commands) from the model that reads it (queries) so each can be optimized independently.

Transactional Outbox

Reliably publishes messages by writing them to an outbox table in the same local transaction as the business data change.

Aggregator

A component that invokes multiple services and combines their responses into a single consolidated result for the caller.

Gateway Aggregation

Uses a gateway to combine multiple backend requests into one, so clients make a single call instead of many.

Gateway Offloading

Moves shared cross-cutting functionality such as TLS, auth, and rate limiting out of services and into a gateway.

Gateway Routing

Routes client requests to the correct backend service through a single endpoint using request attributes such as path or host.

Choreography

Coordinates a distributed workflow through services reacting to each other's events, with no central controller.

Orchestration

Coordinates a distributed workflow through a central orchestrator that explicitly invokes each service in sequence.

Externalized Configuration

Stores configuration outside the application artifact so the same build runs unchanged across environments.

Compensating Transaction

Undo the completed steps of a multi-step operation when one step fails, restoring consistency without distributed ACID transactions.

Deployment Stamps

Deploy multiple independent copies of a full application stack to scale, isolate tenants, and contain failures.

Retry

Automatically reattempt a failed operation that is likely transient, using backoff and limits to recover without user impact.

Message Router

Consumes a message and redirects it to a different channel based on conditions, decoupling producers from the decision of where messages should go.

Content-Based Router

Routes each message to a destination channel chosen by inspecting the message's content, so the payload itself determines where it is delivered.

Routing Slip

Attaches a sequence of processing steps to a message so it routes itself through a series of components determined per message at runtime.

Process Manager

A central component that maintains the state of a multi-step message flow and decides the next step, coordinating complex or branching workflows.

Polyglot Persistence

An architecture that uses multiple, purpose-fit data stores within one system, matching each store's strengths to each data access pattern.

Two-Phase Commit (2PC)

A distributed-transaction protocol that coordinates multiple participants to commit or abort atomically through a prepare phase and a commit phase.

Retry with Backoff

Automatically re-attempts a failed operation after progressively longer waits, smoothing over transient faults without overwhelming a struggling dependency.

Exponential Backoff with Jitter

Adds randomness to exponentially growing retry delays so that many clients do not retry in lockstep and overwhelm a recovering service.

Timeout

Bounds how long a caller waits for an operation, freeing resources and surfacing failures fast instead of blocking indefinitely on a slow or hung dependency.

Bulkhead

Isolates resources into independent pools so a failure or overload in one part of a system cannot consume capacity needed by the rest.

Fallback

Provides an alternative response or behavior when a primary operation fails, keeping the system useful instead of returning an error to the user.

Fail Fast

Detects invalid state or unavailable dependencies as early as possible and reports the error immediately, rather than continuing into deeper, costlier failure.

Backpressure

Lets a slow consumer signal upstream producers to slow down, preventing unbounded queues and memory exhaustion when demand exceeds processing capacity.

Distributed Tracing

Tracks a single request as it flows across many services by propagating context, producing an end-to-end timeline that reveals latency and failure sources.

Correlation ID

Assigns a unique identifier to a request and propagates it through every service and log, so related events across a distributed system can be tied together.

Micro Frontend

Decomposes a web frontend into independently developed and deployed pieces owned by separate teams, then composes them into one application at runtime or build time.

Zero Trust Segmentation

Eliminates implicit network trust by authenticating and authorizing every request and dividing the network into fine-grained, individually protected segments.

Anti-Patterns12

Distributed Monolith

Splitting a monolith into microservices that are still tightly coupled and must be deployed together

Shared Database Integration

Multiple services directly sharing the same database tables

Stovepipe System

Independently built, siloed systems that duplicate capabilities and cannot interoperate because each was designed in isolation without shared standards.

Nanoservices

Splitting a system into services so small that coordination, network, and operational overhead vastly exceed the value of each tiny service.

Entity Service

Designing microservices around data entities rather than business capabilities, forcing every workflow to orchestrate chatty calls across CRUD-only services.

N+1 Network Calls

Fetching a list, then making one additional remote call per item to enrich it, so a single logical operation fans out into N+1 dependency calls.

Premature Scaling

Building for massive scale before there is load to justify it, paying the cost and complexity of distributed systems to solve problems the product does not yet have.

Chatty API

An API design that forces clients to make many small round trips to complete one task, harming latency, scalability, and battery life.

Nanoservices (Overly Fine-Grained Services)

Splitting a system into so many trivially small services that coordination, network, and operational overhead dwarf any benefit of separation.

Synchronous Call Chains

Deep chains of blocking request-response calls between services, so latency compounds and one slow or failed service cascades into widespread failure.

Entity Services

Decomposing microservices around data entities (CRUD wrappers per table) rather than business capabilities, creating chatty, anemic, tightly coupled services.

Death Star (Distributed Big Ball of Mud)

A microservice estate where every service calls nearly every other with no clear boundaries, producing a tangled mesh impossible to change or reason about.

Tutorials5

How to install Istio and enable mTLS for service-to-service traffic

Deploy Istio, enable automatic sidecar injection, and turn on strict mutual TLS between services.

How to add a lightweight service mesh with Linkerd

Install Linkerd, mesh a workload, and gain automatic mTLS plus golden-metrics observability with low overhead.

How to Set Up Distributed Tracing with Jaeger

Deploy Jaeger, send OpenTelemetry spans to it, propagate trace context across services, and analyze latency in the UI.

How to Set Up Mutual TLS Between Services

Create a private CA, issue client and server certificates, and require both sides to authenticate with mTLS for service-to-service calls.

How to Build a gRPC Service

Define a service in Protocol Buffers, generate code, implement unary and streaming methods, and call the service from a client.

Blueprints12

Monolith to Microservices Blueprint

Complete migration blueprint for decomposing a monolithic application into microservices architecture

Modular Monolith to Microservices Blueprint

Decompose a modular monolith into independently deployable microservices using the strangler fig pattern and database-per-service.

Django Monolith to Services Blueprint

Extract bounded capabilities from a large Django monolith into separate services with their own datastores and async messaging.

Monolith to Go Service Extraction Blueprint

Extract performance-critical capabilities from a monolith into standalone Go services with gRPC contracts and container-native deployment.

Stateful Monolith to Stateless Services Blueprint

Re-architect a session-bound stateful backend into horizontally scalable stateless services with externalized session and cache state.

Single Database to Database-per-Service Blueprint

Decompose a shared monolithic database into per-service data stores to enable independent microservice deployment.

REST to gRPC for Internal Services Blueprint

Replace JSON-over-HTTP calls between internal microservices with gRPC and Protocol Buffers for lower latency and strongly typed contracts.

Monolithic API to API Gateway Blueprint

Front a monolithic API with an API gateway to centralize auth, rate limiting, routing, and observability before decomposing services.

Synchronous Calls to Event-Driven (Kafka) Blueprint

Replace brittle synchronous service-to-service calls with asynchronous events on Apache Kafka to decouple services and improve resilience.

Enterprise Service Bus to Modern Integration Blueprint

Replace a heavyweight enterprise service bus with lightweight integration: API gateway, event streaming, and decentralized integration services.

Central Orchestration to Choreography (Saga) Blueprint

Replace a central orchestrator coordinating distributed transactions with event-driven choreography using the saga pattern and compensations.

COBOL Mainframe to Java on Cloud Blueprint

Modernize COBOL/CICS mainframe applications to Java microservices on the cloud using domain decomposition and the strangler-fig pattern.

Products13

Go

Statically typed, compiled programming language designed at Google

NestJS

Progressive Node.js framework for enterprise applications

Spring Boot

Java-based framework for production-ready applications

Quarkus

Kubernetes-native Java framework for cloud deployments

Micronaut

Modern JVM-based framework for microservices

Echo

High-performance, minimalist Go web framework

Fiber

Express-inspired web framework built on Fasthttp for Go

Docker

Platform for developing, shipping, and running containerized applications

Jaeger

Distributed tracing platform

Zipkin

Distributed tracing system

Istio

Service mesh for Kubernetes

Linkerd

Ultralight service mesh for Kubernetes

NATS

Cloud native messaging system

Reference Architectures19

Serverless Web Application

Reference architecture for building serverless web applications with API Gateway, Lambda, and DynamoDB

Event-Driven Microservices

Architecture pattern for building loosely-coupled microservices using event sourcing and CQRS

Monolith to Microservices Migration

Step-by-step architecture for decomposing monolithic applications into microservices

Event-Driven Microservices on Kubernetes

A Kubernetes-native reference design for loosely coupled microservices that communicate through Kafka events with service-level autoscaling.

Container Platform with Service Mesh

A Kubernetes container platform with an Istio service mesh providing mTLS, traffic management, and uniform observability across services.

ECS Fargate Microservices Platform

A serverless container microservices platform on AWS ECS Fargate with service discovery, autoscaling, and no servers to manage.

CQRS and Event Sourcing on Cloud

A cloud microservices design separating write and read models with event sourcing for full auditability and independent scaling.

Service Mesh with mTLS on Kubernetes

Istio-based service mesh providing mutual TLS, traffic management, and observability for microservices.

API Gateway with Backends-for-Frontends

An edge API gateway fronting channel-specific BFF services that aggregate microservices for web, mobile, and partner clients.

Federated GraphQL Supergraph

A federated GraphQL architecture where independently owned subgraphs compose into one supergraph behind a managed gateway.

gRPC Service Mesh for Internal APIs

A high-performance internal API platform using gRPC over a service mesh for typed, low-latency service-to-service calls.

CQRS with Event Sourcing

A command-query separated system where state is derived from an append-only event log and read models are projected for queries.

Saga Orchestration for Distributed Transactions

An orchestrated saga design that coordinates multi-service business transactions with compensating actions instead of two-phase commit.

Event Choreography for Microservices

A choreographed event-driven design where services react to each other's domain events without a central orchestrator.

Transactional Outbox for Reliable Events

A transactional outbox design that guarantees events are published exactly when their database changes commit, avoiding dual-write loss.

Micro-Frontends Platform

Independently built and deployed front-end modules composed at runtime into a single web app, each owned by a separate team.

Multi-Tenant SaaS Platform

A single application instance serving many customer tenants with isolated data, per-tenant configuration, and usage-based billing.

E-Commerce Platform on Microservices

A modular online store splitting catalog, cart, checkout, payments, and orders into independent services with event-driven coordination.

Backend-for-Frontend API Aggregation Platform

Per-client backend-for-frontend services and a GraphQL gateway that aggregate microservices into tailored, efficient API responses.

Playbooks14

Microservices Migration Playbook

Complete operational guide for decomposing a monolith into microservices

Service Mesh Adoption Program Playbook

A phased program to roll out a service mesh for mTLS, traffic management, and observability across a Kubernetes microservices estate.

Monolith Decomposition Program Playbook

A phased program for breaking a large backend monolith into independently deployable services using the strangler-fig approach.

Strangler-Fig Modernization Program Playbook

A program for incrementally replacing a legacy system by routing functionality to new services until the legacy is fully strangled.

Domain-Driven Decomposition Program Playbook

A program that uses domain-driven design and event storming to decompose a system into bounded-context services aligned to teams.

Event-Driven Architecture Adoption Program Playbook

A program to introduce event-driven communication, a schema registry, and async workflows into a synchronous backend estate.

Go Microservices Platform Program Playbook

A program to standardize backend services on Go with shared platform libraries, gRPC contracts, and golden-path tooling.

Data Mesh Rollout Program Playbook

Roll out a data mesh operating model with domain-owned data products, a self-serve platform, and federated computational governance.

Service Mesh Adoption Playbook

A program to introduce a service mesh for secure service-to-service communication, traffic control, and observability across microservices.

GraphQL Adoption Program Playbook

A program to adopt GraphQL alongside existing REST APIs, covering schema design, a federated gateway, performance, and governance.

gRPC Migration Program Playbook

A program to migrate internal service-to-service communication from REST/JSON to gRPC for lower latency and strong contracts.

API Gateway Rollout Playbook

A program to roll out a centralized API gateway for authentication, rate limiting, routing, and observability across services.

Event-Driven Architecture Adoption Playbook

A program to adopt event-driven architecture with a streaming backbone, schema governance, and resilient async patterns.

ESB to Modern Integration Playbook

A program to migrate from a centralized enterprise service bus to decentralized, event-driven and API-led integration.

Checklists9

Monolith Decomposition Readiness Checklist

Verify a monolithic application is understood, instrumented, and bounded well enough to begin safe decomposition into services.

Microservice Production-Readiness Checklist

Confirm a new or extracted microservice meets operational, security, and resilience bars before it serves production traffic.

Service Extraction Cutover Checklist

Cutover checks for routing live traffic from a monolith to a newly extracted service without downtime or data loss.

Backward-Compatibility Review Checklist

Review a change to a service, API, or schema to confirm existing consumers and data continue to work without breaking.

Event-Driven Architecture Readiness Checklist

Confirm readiness to adopt event-driven communication between services, covering schemas, delivery semantics, and observability.

REST to gRPC Migration Checklist

Plan a migration of internal service communication from REST to gRPC, covering contracts, compatibility, and rollout.

Database-Per-Service Decoupling Checklist

Separate a shared database into per-service ownership so microservices can deploy and scale independently without hidden coupling.

gRPC Rollout Checklist

Pre-flight items for rolling out gRPC services across a system, covering contracts, compatibility, security, and observability.

Microservices API Contract Testing Checklist

Verification items for establishing consumer-driven contract testing across microservices to prevent integration breakage.

Stacks17

Cloud Native Stack

Kubernetes, Helm, Istio, Prometheus - CNCF ecosystem

Go Microservices Stack

Go, gRPC, Kubernetes, PostgreSQL - High-performance services

Spring Cloud Stack

Spring Boot, Spring Cloud, Kubernetes - Enterprise Java

Go + gRPC Stack

Compiled Go backend stack using gRPC and Protocol Buffers with PostgreSQL for fast, strongly-typed inter-service communication.

Go + Gin + Postgres Stack

Lightweight Go REST backend using the Gin web framework with PostgreSQL and Redis for fast, simple, high-throughput HTTP APIs.

Micronaut JVM Microservices Stack

JVM microservices stack using Micronaut with ahead-of-time compilation and PostgreSQL for low-memory, fast-starting services and serverless functions.

Kubernetes + Istio Service Mesh Stack

Cloud-native platform stack pairing Kubernetes orchestration with the Istio service mesh for traffic management, security, and observability.

Event-Driven Microservices Stack

Asynchronous microservices architecture using Kafka as an event backbone with independently deployable services for loose coupling and scalability.

gRPC Service Mesh Stack

Microservices stack combining gRPC inter-service communication with a service mesh on Kubernetes for typed, observable, secure service-to-service traffic.

Dapr Distributed Application Stack

Polyglot microservices stack using Dapr building blocks for service invocation, state, pub/sub, and bindings, abstracted from underlying infrastructure.

OpenTelemetry + Tempo + Grafana Tracing Stack

Vendor-neutral distributed tracing: OpenTelemetry instruments and collects traces, Tempo stores them cheaply in object storage, and Grafana visualizes them.

Jaeger Distributed Tracing Stack

CNCF distributed tracing stack: OpenTelemetry instrumentation feeds Jaeger, which stores spans in Elasticsearch or Cassandra and visualizes request flows.

Vert.x Reactive Stack

A polyglot, event-driven toolkit on the JVM built around a non-blocking event loop and the reactor pattern for high-concurrency, low-latency services.

Spring WebFlux Reactive

Spring's reactive, non-blocking web stack built on Project Reactor and Netty, for high-concurrency services that need backpressure and efficient resource use.

Ktor + Exposed

A lightweight, coroutine-based Kotlin web framework paired with the Exposed SQL library, for idiomatic, asynchronous Kotlin backends and APIs.

Axum + SQLx (Rust)

A modern async Rust backend built on the Tokio runtime with the Tower middleware ecosystem and compile-time-checked SQL via SQLx.

Jaeger + OpenTelemetry + Prometheus

An open-source observability stack combining OpenTelemetry instrumentation, Jaeger distributed tracing, and Prometheus metrics, visualized in Grafana.

Comparisons6

NGINX vs Envoy

NGINX is a battle-tested web server and reverse proxy; Envoy is a modern, dynamically configurable proxy built for cloud-native service mesh and observability.

Istio vs Linkerd

Istio and Linkerd are the leading Kubernetes service meshes. Istio is feature-rich and powerful; Linkerd is lightweight, simple, and fast with a purpose-built Rust proxy.

REST in Go vs REST in Java

Building REST APIs in Go with its lean standard library versus in Java with mature frameworks like Spring Boot. Different trade-offs in speed, structure, and tooling.

gRPC vs REST

gRPC is a contract-first, binary, HTTP/2 RPC framework; REST is a resource-oriented, text-based HTTP style. Both build service APIs.

GraphQL vs gRPC

GraphQL is a client-driven query language for flexible APIs; gRPC is a high-performance binary RPC framework. Each targets different API problems.

Jaeger vs Zipkin

Both are open-source distributed tracing systems. Jaeger is a CNCF-graduated, cloud-native tracer; Zipkin is an older, lightweight, simple-to-run tracer.

FAQs9

What is a service mesh?

A service mesh is an infrastructure layer that manages communication between microservices, handling traffic routing, load balancing, retries, encrypt...

When should I use Kubernetes?

Kubernetes makes sense when you run many containerized services that need automated scaling, self-healing, rolling updates, and consistent deployment ...

What is a sidecar container?

A sidecar is a secondary container that runs alongside the main application container in the same pod to extend or support it without changing the app...

What does cloud native mean?

Cloud native describes an approach to building and running applications that fully exploits the elasticity, automation, and managed services of the cl...

What is gRPC and when should I use it?

gRPC is a high-performance remote procedure call framework that uses Protocol Buffers for compact binary serialization and HTTP/2 for transport, inclu...

What is an API gateway?

An API gateway is a server that sits in front of one or more backend services and acts as a single entry point for clients. It handles cross-cutting c...

What is a microservice?

A microservice is a small, independently deployable service that owns a single business capability and communicates with other services over the netwo...

Monolith vs microservices: which should I choose?

A monolith packages all functionality into a single deployable unit, which keeps development, testing, and deployment simple and is usually the right ...