Awesome Microservices

Title: A Detailed Guide to Awesome Microservices: Principles, Platforms, Frameworks, and Practices

Introduction

Microservices have transformed how we design, develop, deploy, and operate modern software systems. The landscape is rich with platforms that enable teams to break monoliths into independently deployable services, frameworks that provide scalable runtimes, toolkits that simplify orchestration and communication, and a growing catalog of standards and best practices. The following post is a detailed tour through the input’s curated collection of microservice architecture resources, organized into meaningful sections. You’ll find platforms, languages and runtimes, service toolkits, architectural patterns, operational capabilities, and pragmatic references for building, deploying, securing, observing, and evolving distributed systems.

Platforms

• 1Backend: This AI-native microservices platform emphasizes AI-enabled workflows and services, offering a foundation for integrating intelligent capabilities into modular components.
• Jolie: An open-source microservice-oriented programming language designed from the ground up for composing and deploying microservices with a focus on service interactions and orchestration.
• OpenWhisk: A serverless, open-source cloud platform that executes functions in response to events at any scale, enabling event-driven microservice architectures without managing servers.
• Pulumi: A cloud-native infrastructure-as-code platform that lets you use familiar programming languages to preview, manage, and deploy cloud resources, avoiding YAML-heavy configurations.
• Triton: An open-source cloud management platform that delivers container-based, service-oriented infrastructure across data centers, facilitating scalable service management.

Frameworks / Runtimes

• Akka: A toolkit and runtime for building highly concurrent, distributed, and resilient message-driven applications on the JVM, ideal for reactive microservices.
• Axon (c): An end-to-end platform for DDD, CQRS, and Event Sourcing on the JVM, enabling clear modeling of domain events and command handling.
• Ballerina: A cloud-native programming language designed for writing networked services and microservices with built-in concurrency and integration capabilities.
• Bun: A fast all-in-one JavaScript runtime that accelerates microservice development and deployment, particularly in Node.js ecosystems.
• Dapr: An open-source runtime that abstracts away cloud-provider differences and language specifics, enabling high-performance microservices across languages.
• Deno: A secure JavaScript/TypeScript runtime with a developer-friendly experience, suited for building microservices with robust security defaults.
• Eclipse MicroProfile: A community-driven effort to optimize Enterprise Java for microservices through standardization and collaboration.
• Erlang/OTP: The classic platform for massively scalable, highly available soft real-time systems, providing robust primitives for concurrent microservices.
• Finagle: An extensible RPC system for the JVM used to construct high-concurrency servers.
• Gleam: A friendly language for building type-safe, scalable systems, offering strong guarantees for service composition.
• GraalVM: A high-performance runtime that enables polyglot execution and significant efficiency improvements for microservices workloads.
• Helidon: A Java library collection for fast, cloud-native microservices built on a Netty-based web core.
• Ice: A comprehensive RPC framework supporting multiple languages, enabling interoperable microservice communication.
• Light-4j: A high-throughput, low-latency microservices platform with a small memory footprint.
• Micronaut: A modern JVM-based, full-stack framework designed for modular, easily testable microservice applications.
• Moleculer: A fast, feature-rich microservices framework for Node.js, Java, Go, and Ruby—supporting distributed architectures.
• Open Liberty: A lightweight framework for building fast, cloud-native Java microservices.
• Pears: A peer-to-peer runtime and deployment architecture for microservices and components.
• SmallRye: A suite of cloud-friendly APIs and implementations, including Eclipse MicroProfile, to accelerate cloud-native development.
• Spin: An open-source framework for building and running fast, secure, and composable cloud microservices with WebAssembly.
• ScaleCube: A reactive microservices toolkit for the JVM offering low latency, high throughput, and resilience.
• Vert.x: A toolkit for building reactive applications on the JVM, emphasizing non-blocking I/O and event-driven design.
• Vert.x Toolbox: A collection of Vert.x components designed to accelerate building reactive microservices.
• Wangle: A framework providing common client/server abstractions to build services in a consistent, modular, and composable way.

Service Toolkits

• Polyglot: A vision of service development and integration across languages and runtimes, enabling teams to choose the best tool for each service.

Polyglot (highlighted circuits)

• GRPC: A high-performance, open-source RPC framework that emphasizes HTTP/2 and multi-language support (C, C++, Java, Go, Node.js, Python, Ruby, Objective-C, PHP, C#), enabling language-agnostic service-to-service communication.

C

• Lwan: A high-performance, scalable web server designed for efficiency and speed in C.
• uSockets: A small, portable library with eventing, networking, and cryptography for asynchronous applications.

C++

• Cap’n Proto RPC: A C++ RPC implementation built on Cap’n Proto, designed for high-speed interprocess communication.
• C++ Micro Services: An OSGi-like dynamic module system and service registry for C++.
• Enduro/X: A service framework based on XATMI for GNU/Linux environments.
• Pistache: A high-performance REST toolkit written in C++ for building microservices.
• Poco: A cross-platform C++ class library focused on networked applications and servers.
• Sogou Workflow: An enterprise-grade programming engine for backend development.
• uWebSockets: A lean, fast, secure web server suitable for demanding applications.

C#

• Awesome Microservices .NET Core: A curated collection of training resources, articles, videos, books, courses, sample projects, and tools for microservices in .NET Core (community resource).

D

• Vibe.d: Async I/O library for D with a focus on non-blocking concurrency.

Erlang VM

• Elixir
• Phoenix: A framework for building HTML5 apps, API backends, and distributed systems atop the Erlang VM.
• Plug: A specification and conveniences for composable modules between web apps, aligning with functional architecture.
• Erlang
• Cowboy: A small, fast, modular HTTP server written in Erlang.
• Mochiweb: An Erlang HTTP server library for lightweight services.

Go

• Chi: A lightweight, idiomatic, and composable router for Go HTTP services.
• Echo: A fast and opinionated HTTP framework for Go—renowned for performance.
• Fiber: Express-inspired framework for Go on top of Fasthttp, emphasizing zero allocations and speed.
• Gin: A fast HTTP web framework with a Martini-like API and substantial performance gains.
• Goa: Design-based HTTP microservices in Go, bridging design and implementation.
• GoFr: An opinionated microservice framework focusing on scalability and robustness.
• Go Chassis: Framework for rapid Go microservice development and cloud integration.
• Go-Micro: A distributed systems development framework for microservices.
• Go-Zero: A web and RPC framework designed for distributed systems.
• Gorilla: A comprehensive web toolkit for Go.
• Iris: A high-performance web framework for Go.
• Lura: Framework to build ultra-fast API Gateways with middleware support.
• RPCX: A distributed RPC service framework inspired by NET/RPC and other RPC ecosystems.

Haskell

• Scotty: A micro web framework inspired by Sinatra, built on WAI and Warp.
• Servant: A type-level web API DSL in Haskell for precise interfaces.
• Yesod: A robust RESTful web framework for Haskell.

Java VM

• Clojure
• Compojure: A concise routing library for Ring/Clojure.
• Duct: Server-side framework for Clojure.
• System: Component-based library ecosystem for composing systems.
• Tesla: A microservice foundation used at Otto.de.
• Java
• ActiveJ: A lightweight, high-performance library for distributed applications and memory-cached solutions.
• Airlift: A framework for building REST services in Java.
• Armeria: Async HTTP/2 RPC/REST client/server library based on Java 8, Netty, Thrift, and gRPC.
• Disruptor: A high-performance inter-thread messaging library.
• Dropwizard: Ops-friendly, high-performance RESTful web services framework.
• Dubbo: Alibaba’s high-performance Java-based RPC framework.
• Conjure: Libraries for REST-ish/RPC servers and clients integrated with Feign/Retrofit-like patterns.
• Jersey: RESTful services in Java; reference JAX-RS implementation.
• Quarkus: Kubernetes-native Java stack, optimized for OpenJDK HotSpot and GraalVM.
• Ratpack: Java library suite for fast, lean HTTP apps with Groovy integration.
• Spring Boot: Makes it easy to create stand-alone, production-grade Spring-based applications.
• Kotlin
• Http4k: A lightweight HTTP toolkit in Kotlin for serving and consuming HTTP services functionally.
• Ktor: Framework for building asynchronous servers and clients in Kotlin.
• Scala
• Finatra: Fast, testable Scala HTTP services built on Finagle.
• http4s: A minimal, idiomatic Scala interface for HTTP.
• Play: A high-velocity web framework for Java and Scala.

Node.js

• ActionHero: A multi-transport API server with cluster support and delayed tasks.
• Express: The classic fast, minimalistic web framework for Node.js.
• Fastify: A fast, low-overhead web framework for Node.js.
• FeathersJS: A REST and real-time API layer for modern apps.
• Hono: A small, ultra-fast web framework for edge runtimes.
• Koa: A next-generation web framework with async/await primitives.
• LoopBack: A framework for creating APIs and connecting to backend data sources.
• NestJS: A scalable server-side framework with built-in microservices support.
• Seneca: A microservices toolkit for Node.js.
• Serverless: Platform for building and deploying serverless apps (AWS Lambda, API Gateway).
• tRPC: End-to-end typesafe APIs.

Perl

• Cro: Libraries for reactive distributed systems in Perl 6.
• Mojolicious: A modern web framework for Perl.

PHP

• API Platform: API-first framework on top of Symfony with JSON-LD, Hydra, and Schema.org support.
• Ecotone: Framework built on DDD, CQRS, and Event Sourcing to support scalable, extensible apps.
• Hyperf: A high-performance PHP coroutine framework, Swoole-based, with a wealth of components.
• Lumen: A micro-framework by Laravel for fast API development.
• Slim: A micro-framework for quickly building simple yet powerful web apps and APIs.
• Spiral: Framework designed for long-running apps, with RoadRunner integration and strong support for REST and gRPC.
• Swoft: A coroutine-based PHP microservices framework for high-performance APIs.
• Symfony: A mature micro-framework based on Symfony components, with extensibility for microservice patterns.

Python

• Aiohttp: HTTP client/server for asyncio, enabling asynchronous microservices.
• Bottle: A tiny, fast WSGI micro-framework.
• Connexion: Swagger/OpenAPI-based framework on top of Flask with automatic endpoint validation and OAuth2 support.
• Falcon: A bare-metal Python web API framework designed for speed.
• FastAPI: A modern, fast (high-performance) framework for building APIs using Python type hints.
• Flask: The classic microframework for Python, lightweight yet extensible.
• Nameko: A Python framework for building scalable microservices.
• Sanic: A Flask-like framework designed for speed in Python 3.5+.
• Tornado: A web framework and asynchronous networking library.
• Twisted: An event-driven network programming engine.
• Web.py: A minimalist web framework for Python.

Ruby

• Grape: An opinionated framework for building REST-like APIs.
• Hanami: A modern Ruby web framework focusing on simplicity and modularity.
• Praxis: Framework for API design and implementation.
• Scorched: A lightweight web framework.
• Sinatra: A DSL for quickly creating web apps in Ruby with minimal effort.

Rust

• Are We Web Yet?: A community-curated resource hub describing Rust’s web development landscape.
• Actix: A powerful, pragmatic web framework for Rust with excellent performance.
• Tarpc: RPC framework for Rust focused on ease of use.
• Tokio: An asynchronous runtime for building reliable, scalable network applications.
• Tower: A library of modular components for building robust networking clients and servers.
• Wtx: A framework for HTTP/2 client-server communication.

Frontend / UI

• Awesome Micro Frontends: A curated list of resources about Micro Frontends, highlighting frontend service composition.
• Electrode: A universal React/Node.js application platform for isomorphic development.
• Micro Frontends: A concept applying microservice thinking to frontend development, enabling independent teams to own UI components.
• MiniApp White Paper: W3C standardization work outlining minimalist micro-frontend app development.

Capabilities

API Gateways / Edge Services Note: Data and control plane components are not categorized here at the moment.

• Ambassador (c): Kubernetes-native API gateway built on Envoy, enabling seamless routing and policy enforcement for microservices.
• APIcast: Gateway built on top of NGINX, part of Red Hat 3scale API Management.
• Bunker Web: Web app hosting and reverse proxy with defaults oriented toward security.
• Caddy: Extensible HTTP/2 server with automatic HTTPS, simplifying secure edge deployments.
• Camel: Routing and mediation engine that can be expressed via Java/Fluent APIs, Spring, Blueprint XML, or a Scala DSL.
• Envoy: Open-source edge and service proxy by Lyft, widely used in mesh and gateway topologies.
• HAProxy: Reliable load balancer for TCP/HTTP traffic at the edge.
• Istio: Platform for connecting, managing, and securing microservices with a strong service mesh model.
• Keepalived: High-availability load balancing facilities for Linux-based infrastructures.
• Kong: API management and gateway, with plugin extensibility.
• KrakenD: Ultra-high-performance API gateway for aggregating multiple microservices.
• Kuma: Platform-agnostic control plane for service mesh and microservices.
• Linkerd: Resilient service mesh for cloud-native apps.
• Neutrino: Extensible software load balancer for flexible traffic management.
• OpenResty: High-performance web app server building on Nginx with Lua.
• Open Service Mesh: Lightweight, extensible service mesh for cloud-native apps.
• Otoroshi: Modern HTTP reverse proxy with lightweight API management.
• Pingora: A routing library by Cloudflare for building fast network services.
• Skipper: HTTP router designed to decouple routing from service logic.
• Spring Cloud Gateway: API gateway atop Spring MVC for user-friendly routing across APIs.
• Tengine: Nginx-based distribution with advanced features.
• Traefik: Modern HTTP reverse proxy and load balancer designed for microservices.
• Traffic Server: High-performance platform for cloud services.
• Tyk: Open-source, fast API gateway and management platform.
• Vulcand: Programmatic load balancer backed by Etcd.
• Zuul: Netflix edge service offering dynamic routing and resilience features.

Configuration & Discovery

• Central Dogma: Version-controlled service configuration repository using Git, ZooKeeper, and HTTP/2, for centralized management of service configurations.
• Consul: Service discovery and configuration management with multi-datacenter support.
• Etcd: Highly available key-value store used for shared configuration and service discovery.
• Eureka: REST-based service locator commonly used in the AWS cloud ecosystem for load balancing and failover.
• Microconfig: Simple approach to microservice configuration management.
• Nacos: Dynamic service discovery, configuration, and service management platform.
• SkyDNS: DNS-based service announcement and discovery built on etcd.
• Spring Cloud Config: Centralized configuration server and client-side support for externalized configuration in distributed systems.
• ZooKeeper: Core coordination service enabling reliable distributed systems.

Workflow Orchestration

• AWS Step Functions (c): Visual workflows to coordinate distributed components and microservices.
• Cadence: Fault-oblivious stateful code platform for workflows.
• Conductor: Netflix fabrication for microservices orchestration engine.
• Inngest: Durable background logic to handle workflows and long-running processes.
• Kestra: Open-source event-driven, language-agnostic orchestration and scheduling platform.
• Temporal: Open-source platform for running mission-critical microservices workflows at scale.
• Zeebe: Camunda’s engine for defining and monitoring business processes across microservices.

Elasticity

• Hazelcast: In-memory data-grid that enables distributed computation and data storage across clusters.
• Helix: Cluster management framework for partitioned, replicated resources.
• Ignite: In-memory computing platform for real-time processing and transactions.
• Libp2p: Protocol suite for building peer-to-peer networked applications.
• Mesos: Abstraction layer for compute resources, enabling flexible fault-tolerant orchestration.
• Nomad: Simple, flexible, and scalable scheduler for data centers.
• Redisson: Distributed Java data structures atop Redis for high availability.
• Serf: Decentralized cluster membership, failure detection, and orchestration.
• Valkey: Redis-based open-source project revived for extended Redis capabilities.
• Zenoh: Protocol blending pub/sub with queryable data and computation for edge/cloud.

Job Schedulers / Workload Automation

• Celery: Async task queue for Python with real-time operation and scheduling support.
• Dkron: Distributed, fault-tolerant job scheduling system.
• Faktory: Language-agnostic, persistent background job server.
• Rundeck (c): Job scheduler and runbook automation, enabling self-service tooling.
• Schedulix: Open-source enterprise scheduler for IT processes.

Logging

• Fluentd: Unified logging data collector enabling centralized collection and routing.
• Graylog: Open-source log management platform.
• Kibana: Visualization and analytics dashboard for Elasticsearch data.
• LogDNA (c): Centralized log management for real-time log analysis.
• Logstash: Event and log management pipeline.
• Loki: Log aggregation system built to work with Grafana.

Messaging

• ØMQ: Brokerless messaging library emphasizing direct, high-performance transport.
• ActiveMQ: Mature open-source messaging server with a broad set of patterns.
• Aeron: Efficient UDP-based message transport for high-performance scenarios.
• Beanstalk: Simple work queue for background processing.
• Bull: Redis-based queue for Node.js with reliability and features.
• Crossbar: Platform implementing the Web Application Messaging Protocol (WAMP) for distributed apps.
• Kafka: Distributed commit-log-based messaging for scalable pipelines.
• Malamute: ZeroMQ-based enterprise messaging broker.
• Mosquitto: MQTT message broker, lightweight and suitable for IoT.
• NATS: High-performance cloud messaging system.
• NSQ: Real-time distributed messaging platform.
• Pulsar: Distributed pub-sub messaging system.
• RabbitMQ: Mature Erlang-based message broker that Just Works.
• Redpanda: Kafka API-compatible streaming platform with modern performance characteristics.
• RocketMQ: High-performance message-oriented middleware from Alibaba.

Monitoring & Debugging

• Beats: Lightweight shippers for Elasticsearch/Logstash data.
• Elastalert: Flexible alerting for Elasticsearch data.
• Ganglia: Scalable monitoring system, especially for clusters.
• Grafana: Rich metrics dashboards for various backends.
• Graphite: Real-time graphing for metrics data.
• IOpipe (c): APM for AWS Lambda.
• Jaeger: Distributed tracing system for end-to-end visibility.
• OpenTelemetry: Portable telemetry framework for observability.
• Prometheus: Time-series database and monitoring system.
• Riemann: Monitoring for distributed systems.
• Sensu: Modern monitoring framework for infrastructure.
• SkyWalking: APM tool focused on microservices, cloud-native, and containerized architectures.
• Zabbix: Enterprise-class monitoring solution.
• Zipkin: Distributed tracing system for microservices.

Reactivity

• Reactor.io: Reactive library for building non-blocking JVM applications based on Reactive Streams.
• Reactive Kafka: Reactive Streams API for Apache Kafka.
• ReactiveX: API for asynchronous programming with observable streams across many languages.
• RSocket: Protocol delivering Reactive Streams semantics for efficient communication.

Resilience

• Awesome Chaos Engineering: Curated chaos engineering resources to test resilience.
• Raft Consensus: Understandable consensus algorithm for fault-tolerant distributed systems.
• Resilience4j: Fault-tolerance library for Java 8+ and functional programming styles.
• Svix: Webhooks service with reliable retry, exponential backoff, and signature verification.

Security

• Cerbos Hub: Fine-grained authorization management for microservices.
• Dex: OpenID Connect provider with pluggable connectors.
• JWT: Standard for representing claims securely across parties.
• Keycloak: Comprehensive auth service with OIDC and OAuth 2.0 support.
• OAuth / OpenID Connect: Core security protocols for authorization and authentication.
• Open Ziti: Zero-trust security and overlay networking open-source software.
• ORY: Open-source identity infrastructure and services.
• OWASP Agent Memory Guard: Runtime defense against AI agent memory poisoning and related threats.
• SCIM: Identity management protocol for provisioning users and groups.
• Vault: Secrets management, storage, and access control for tokens, passwords, and keys.

Serialization

• Avro: Binary serialization framework with rich data structures.
• Bond: Cross-platform data serialization framework, widely used in large-scale services.
• BooPickle: Binary serialization for Scala/Scala.js.
• Cap’n Proto: Fast, zero-copy data interchange and RPC system.
• CBOR: Concise Binary Object Representation.
• cereal: C++11 serialization library.
• Cheshire: Clojure-friendly JSON/JSON-SMILE encoding/decoding.
• Etch: Cross-language framework for building/consuming network services.
• Fastjson: Fast JSON processing library (Java).
• ffjson: Faster JSON serialization for Go.
• FST: Fast Java serialization replacement.
• Jackson: Java JSON processing library with performance enhancements (Afterburner).
• Kryo: Efficient Java serialization/cloning.
• Lite: Zero-copy JSON-like serialization (Lite3).
• MessagePack: Binary JSON-like format for compact data.
• Protostuff: Serialization with forward/backward compatibility and validation.
• SBinary: Binary format description for Scala types.
• Thrift: Cross-language framework for scalable services.
• yyjson: Ultrafast JSON library in C.

Storage

• Alluxio: Virtual distributed storage system for data access.
• Apache Cassandra: Column-oriented, highly available distributed database.
• Aerospike (c): High-performance NoSQL database for speed at scale.
• ArangoDB: Distributed multi-model database (documents, graphs, key-values).
• AtlasDB: Transactional layer atop a key-value store.
• Citus: Distributed PostgreSQL extension for scale-out relational workloads.
• CockroachDB (c): Cloud-native SQL database modeled after Google Spanner.
• Couchbase: Distributed, scalable, high-performance database.
• Crate (c): Scalable SQL with NoSQL capabilities.
• Datomic: Fully transactional, cloud-ready distributed database.
• Druid: Fast columnar distributed store for analytics.
• Elasticsearch: Distributed search engine with powerful indexing and querying.
• Geode: Distributed in-memory data grid.
• Infinispan: High-concurrency key/value datastore for caching.
• InfluxDB: Time-series database for metrics and events.
• OpenTSDB: Scalable time-series database built on HBase.
• Pilosa: Distributed bitmap index for large-scale queries.
• RethinkDB: Real-time capable open-source database.
• Secure Scuttlebutt: Peer-to-peer database for message feeds.
• TiKV: Distributed transactional key-value store.
• Trino: Fast distributed SQL query engine for big data analytics.

Testing

• Goreplay: Tool to capture and replay live HTTP traffic into test environments.
• Keploy: Open-source API testing/mocking by converting real traffic into tests and stubs.
• Mitmproxy: Interactive traffic inspection and modification tool.
• Mountebank: Multi-protocol test doubles over the network.
• Pact: Contract testing framework for HTTP APIs and async messaging systems.
• RestQA: Tool to manage microservices mocking and testing locally with good DX.
• Specmatic: Converts API specs (OpenAPI, AsyncAPI, GraphQL, gRPC) into executable contracts for testing and service virtualization.
• Spring Cloud Contract: TDD-focused contracts for microservice APIs.
• VCR: Record HTTP interactions for deterministic replays in tests (multiple language ports).
• Wilma: Combined HTTP/HTTPS service stubs and transparent proxies.
• WireMock: Flexible HTTP server for stubbing and mocking web services.
• Hoverfly: Lightweight service virtualization and API simulation.

Continuous Integration & Delivery

• Awesome CI/CD DevOps: A curated list of tools for CI/CD and DevOps practices, highlighting a broad ecosystem of automation and deployment tooling.

Web API Modeling & Documentation Async

• AsyncAPI: Specification standard for defining asynchronous APIs, complementing OpenAPI for REST.

GraphQL

• GraphQL: A query language and runtime for APIs that lets clients specify their data needs precisely.

JSON

• JSON:API: A standard for how clients fetch and modify resources, and how servers respond.

REST

• API Blueprint: Lifecycle tools for APIs, including design, documentation, and testing.
• OpenAPI: The OpenAPI Specification (OAS) provides a consistent lifecycle description for RESTful APIs.
• RAML: RESTful API Modeling Language for describing APIs succinctly.
• ReDoc: OpenAPI/Swagger-generated API documentation.
• Scalar: Open-source API platform with first-class OpenAPI/Swagger support.
• Slate: Beautiful static documentation generator for APIs.
• Spring REST Docs: Combines documentation with code snippets generated from tests.
• Swagger: A widely adopted representation of RESTful APIs.

Standards / Recommendations World Wide Web

• W3C Web Arch: Architecture of the World Wide Web, volume one, foundational guidance.
• RFC 3986: URI Generic Syntax.
• RFC 6570: URI Template.
• RFC 7320: URI Design and Ownership.

Self-sovereignty & Decentralisation

• DID: Decentralized identifiers for verifiable digital identity.
• DIDComm: Private communication atop DIDs.
• DIDComm Protocols: Registry of high-trust communication protocols built on DIDComm.
• IDSA: International Data Spaces Association, advancing secure, sovereign data sharing.

HTTP/1.1

• RFC 7230: Message syntax and routing.
• RFC 7231: Semantics and content.
• RFC 7232: Conditional requests.
• RFC 7233: Range requests.
• RFC 7234: Caching.
• RFC 7235: Authentication.
• RFC 7807: Problem Details for HTTP APIs.

HTTP/2

• RFC 7540: Protocol version 2.

QUIC

• QUIC-WG: IETF working group for the next transport protocol.
• QUIC-Transport: A UDP-based secure, multiplexed transport.

RPC

• JSON-RPC 2.0: Stateless RPC protocol.
• OpenRPC: Language-agnostic interface description for JSON-RPC 2.0.

Messaging

• AMQP: Advanced Message Queuing Protocol.
• MQTT: MQ Telemetry Transport for lightweight messaging.
• STOMP: Simple Text Oriented Messaging Protocol.

Security

• GNAP: Grant Negotiation and Authorization Protocol for delegating authorization.
• OIDC: OpenID Connect 1.0 on top of OAuth 2.0 for identity and profile information.
• PASETO: Platform-Agnostic SEcurity TOkens (alternative to JOSE standards).
• TLS RFCs: Standards for TLS 1.2 and its extensions (RFCs 5246, 6066, 6347).
• OAuth 2.0: Authorization framework standard.
• OpenID Connect: Identity layer on top of OAuth 2.0 with REST-style interoperability.
• Open Ziti: Zero-trust networking and overlay security open source.
• ORY: Identity infrastructure focused on authentication and authorization.
• OWASP Agent Memory Guard: Runtime defense against memory poisoning and prompt injection in AI agents.
• SCIM: System for Cross-domain Identity Management.
• Vault: Secrets management and access control for tokens and credentials.

Serialization

• Avro, Bond, BooPickle, Cap’n Proto, CBOR, cereal, Cheshire, Etch, Fastjson, ffjson, FST, Jackson, Jackson Afterburner, Kryo, Lite3, MessagePack, Protostuff, SBinary, Thrift, yyjson.

Storage

• Alluxio, Cassandra, Aerospike, ArangoDB, AtlasDB, Citus, CockroachDB, Couchbase, Crate, Datomic, Druid, Elasticsearch, Geode, Infinispan, InfluxDB, OpenTSDB, Pilosa, RethinkDB, Secure Scuttlebutt, TiKV, Trino.

Testing

• Goreplay, Keploy, Mitmproxy, Mountebank, Pact, RestQA, Specmatic, Spring Cloud Contract, VCR, Wilma, WireMock, Hoverfly.

Enterprise & Verticals

• Commercetools: Headless commerce platform enabling flexible storefront experiences.
• Equinox: Infosys Equinox is a commerce and marketing platform focused on personalization across channels.
• Flamingo: Framework for building modern, flexible e-commerce applications.
• Medusa: Headless open-source commerce platform for custom storefronts.

Theory

• Articles & Papers cover a wide range of topics, including autonomy and hyperconnectivity, scalability patterns, Conway’s Law, canary releases, CAP, serverless formal foundations, microservice design and trade-offs, reactive systems, testing strategies, and more.
• Foundational writings such as Martin Fowler’s Microservice Architecture and subsequent trade-off analyses guide practical decision-making.
• Notable papers explore resource-oriented computing, consistency models, and the broader implications of distributed architectures.

Articles & Papers

• Autonomy, Hyperconnectivity, and Residual Causality: A philosophical introduction to adaptive systems and complexity science.
• Awesome Scalability: A curated reading list for scalable, reliable, and performant large-scale systems with case studies.
• AKF Scale Cube: A model describing how to split applications and services for scalable growth.
• CALM: Consistency as logical monotonicity, exploring data consistency models.
• Canary Release: A risk-mitigating approach to rolling out changes incrementally.
• CAP Theorem: Limits of distributed systems across consistency, availability, and partition tolerance.
• Formal Foundations of Serverless Computing: Analyzing the operational semantics of serverless models.
• Microservice Architecture: The design philosophy of independently deployable services.
• Microservices Design & Deployment: A seven-part guide to designing and deploying microservices.
• Microservices – Please, don’t: Cautions and antipatterns in microservice adoption.
• Microservices Trade-Offs: A practical look at costs and benefits of microservice architectures.
• Reactive Manifesto / Reactive Streams: Standards and philosophies around non-blocking, back-pressured, responsive systems.
• ROCAS, SECO, and other ecosystem studies: Modeling adaptive systems and software ecosystems.

Sites & Organizations

• Cloud Native Computing Foundation (CNCF): A hub for cloud-native projects and community collaboration around container orchestration and microservices.
• CNCF Landscape: An interactive map of cloud-native technologies and ecosystems.
• Martin Fowler Microservices Guide: Articles, videos, books, and podcasts on microservices patterns and practices.
• Microservices Patterns: Consistent patterns and best practices for distributed architectures.
• Microservice Antipatterns and Pitfalls: Common mistakes and how to avoid them.
• Additional community resources: Community-maintained lists that help teams design, implement, and evolve microservices.

License

• CC0: The collection is released into the public domain under Creative Commons Zero, inviting broad reuse and adaptation.

Contributing

• The contributor guidelines urge readers to read the contributions policy before adding suggestions, and encourage opening issues or submitting pull requests to propose enhancements. The community thanks participants for sharing knowledge and improving the resource.

Conclusion

What emerges from this expansive input is a panoramic map of the microservices landscape. It is a tapestry woven from platforms that host and run services, runtimes and frameworks that empower developers in various languages, and a broad set of capabilities that modern teams rely on to build scalable, resilient, observable, and secure distributed systems. The list emphasizes polyglot engineering, observable operations, and design discipline—encouraging teams to select the right tool for the right job while adhering to well-established patterns, standards, and best practices. Whether you are architecting an API gateway, selecting a storage backend, orchestrating long-running workflows, or building robust monitoring and security postures, this curated universe offers valuable references, concrete tools, and thoughtful guidance to advance your microservices journey.

Images used

• The Awesome badge at the top of the post provides a recognizable visual anchor for readers new to the concept of curated microservice resources. If you wish to add more visual context, you can incorporate logos and diagrams from the listed frameworks and platforms, ensuring licensing compatibility before reuse.