liveBook · Manning

Microservice architecture

Also called microservice-based architecture

Microservice architecture is a software architectural style that structures an application as independently deployable services, typically organized around focused capabilities and communicating through defined interfaces.

How 18 Manning books explain it

Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform

An architectural style that structures an application as a collection of small, independently deployable services with distinct boundaries.

How it is used
Uses microservices to manage application complexity and support independently evolving parts.
How deep it goes
Builds from a local service to cloud deployment, teaching the minimum tooling needed rather than mastering each tool.
Examples
Builds a video-streaming application with streaming, storage, upload, and gateway services.
What you can do after
Builds a microservices application from scratch, packages services with Docker, and deploys them to Kubernetes.

Read how Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform explains microservice architecture →

Microservices Patterns, Second Edition

An architectural style that structures an application as a collection of independently deployable services aligned with business capabilities.

How it is used
Enables fast software delivery for large, complex applications developed by large organizations.
How deep it goes
Defines service coupling and deployability, then examines delivery benefits, distributed-system drawbacks, and migration decisions.
Examples
Illustrates customer, order, and delivery services and a food-delivery migration that produced an excessively fine-grained architecture.
What you can do after
Evaluate whether microservices fit an application and whether an existing monolith warrants incremental migration.

Read how Microservices Patterns, Second Edition explains microservice architecture →

Spring Microservices in Action

A software architecture style in which an application is composed of independently deployable services organized around business capabilities.

How it is used
Frames independent service delivery as an alternative to coordinating changes across a monolithic application.
How deep it goes
Develops service-boundary guidance and operational concerns, with a simple Spring Boot demonstration that stops short of a production design.
Examples
Uses a software asset management re-platforming scenario and a Spring Boot Hello World endpoint.
What you can do after
Apply it via Spring Boot and Spring Cloud to build and deploy a service while evaluating operational design decisions.

Read how Spring Microservices in Action explains microservice architecture →

Fast by Default

A microservice is an independently deployable service that encapsulates a focused capability and communicates with other services over defined interfaces.

How it is used
Frames backend performance decisions around service communication, computation placement, load behavior, and organizational capacity.
How deep it goes
Develops a case-based comparison of monoliths, microservices, and serverless systems through scaling, cost, and ownership trade-offs.
Examples
Uses Prime Video’s AWS consolidation and Netflix’s migration from a monolith to over 1,000 microservices.
What you can do after
Evaluate/understand whether workload boundaries, scaling needs, team ownership, and operational capacity justify distributed services.

Read how Fast by Default explains microservice architecture →

Acing the Frontend Interview

A microservice is an independently deployable service that implements a focused business or technical capability within a distributed application.

How it is used
Frames microservices as an interview-relevant distributed architecture for large SaaS platforms and high-scale systems.
How deep it goes
Defines service boundaries and trade-offs, but stops short of detailed orchestration, communication, or data-management implementation.
Examples
Uses architectural comparison tables and identifies large SaaS platforms and high-scale distributed systems as use cases.
What you can do after
Evaluate microservices against monolithic and layered architectures using deployment, scaling, autonomy, and operational-complexity trade-offs.

Read how Acing the Frontend Interview explains microservice architecture →

Google Anthos in Action

A microservices architecture structures an application as independently deployable services that communicate over a network.

How it is used
Uses independently deployable services to modernize applications, accelerate delivery, and support scalable distributed operations.
How deep it goes
Explains modularity, deployment benefits, operational drawbacks, service-mesh capabilities, and incremental migration, but not service implementation code.
Examples
Uses Anthos deployments, containerized Linux or Windows applications, Migrate for Anthos, VM migration, mutual TLS, and service-level objectives.
What you can do after
Operate/configure microservice applications with automated deployment, service-mesh security, dependency management, and performance observability.

Read how Google Anthos in Action explains microservice architecture →

gRPC Microservices in Go

Microservice architecture is an architectural style that structures an application as loosely coupled, independently deployable, and independently scalable services.

How it is used
Frames when to decompose an application into independently deployable business capabilities rather than retain a monolith.
How deep it goes
Defines service characteristics and selection criteria, then sketches communication and consistency challenges without detailing their implementation here.
Examples
Uses product, cart, checkout, payment, and shipping services, including checkout calls through generated gRPC stubs.
What you can do after
Evaluate/understand it: assess whether business boundaries and scaling or release problems justify decomposition, then identify interservice calls needing fault tolerance.

Read how gRPC Microservices in Go explains microservice architecture →

Cloud Observability in Action

A microservices application is an application composed of independently deployable services that communicate over interfaces.

How it is used
Frames independently deployable services as components of cloud-native applications and as units for following distributed requests.
How deep it goes
Defines service independence and interfaces, then follows concrete request paths without detailing service implementation internals.
Examples
Uses Sock Shop, an e-commerce checkout workflow, and a frontend-to-service-A-to-service-B request graph.
What you can do after
Operate/configure a demonstrative microservices application on Kubernetes and inspect its logs, metrics, and distributed traces.

Read how Cloud Observability in Action explains microservice architecture →

Think Like a CTO

A microservices architecture structures a system as independently deployable services that are narrowly scoped and communicate through defined interfaces.

How it is used
Frames an enterprise architecture decision around independently changing components and the risks of a tightly coupled monolith.
How deep it goes
Defines service scope, communication, and independence, then offers a monolith checklist rather than implementation instructions.
Examples
Illustrates risk through a tightly coupled library upgrade and incremental migration through refactoring parts of a legacy system.
What you can do after
Evaluate/understand it by checking monolith characteristics and identifying legacy areas that could be extracted without a complete rewrite.

Read how Think Like a CTO explains microservice architecture →

AI Agents in Action, Second Edition

A microservices architecture is a software architecture in which an application is composed of independently deployable services with focused responsibilities.

How it is used
Deploys focused agent capabilities as services that applications or other agents consume through APIs, MCP, or A2A.
How deep it goes
Defines service boundaries and container deployment, but defers Kubernetes and other cloud-environment deployment details.
Examples
Uses a browser frontend consuming multiple containerized agents as API tools or MCP servers.
What you can do after
Apply it via Docker by packaging focused agents for independent use, replacement, scaling, and versioning.

Read how AI Agents in Action, Second Edition explains microservice architecture →

Go in Practice, Second Edition

A microservice architecture is an application architecture composed of independently deployable services that communicate over a network.

How it is used
Deploys cloud applications as independently scalable and failure-resilient services with focused responsibilities.
How deep it goes
Defines service boundaries and communication trade-offs, then demonstrates Kafka-based message consumption without detailing deployment mechanics.
Examples
Uses a media transcoding workflow and a Go Kafka consumer that reads media batches for processing or delegation.
What you can do after
Build it from scratch by separating focused Go services, routing work through queues, and selecting communication methods for performance.

Read how Go in Practice, Second Edition explains microservice architecture →

Software Security for Developers

A software architecture that decomposes an application into independently deployable services organized around business capabilities.

How it is used
Organizes applications around independently deployable business capabilities and frames the security of their call chains.
How deep it goes
Defines service boundaries and illustrates call-graph complexity, then focuses on communication security rather than deployment mechanics.
Examples
Uses an online product page with book-details, pricing, ratings, search, and delivery-estimation services.
What you can do after
Evaluate service boundaries and identify authentication and communication risks across a service-to-service call graph.

Read how Software Security for Developers explains microservice architecture →

Kubernetes for Developers

Microservices is an architectural pattern that structures an application as multiple independently maintained services.

How it is used
Structures applications as cooperating services when separate scaling, teams, languages, or dependency environments provide practical value.
How deep it goes
Explains service boundaries, HTTP communication, benefits, and operational drawbacks without prescribing a universal architecture choice.
Examples
Uses frontends communicating with internal services, separate services serving paths, and containers hosting different languages and dependencies.
What you can do after
Evaluate whether separate services justify their scaling and team benefits despite added debugging, testing, and request-tracing complexity.

Read how Kubernetes for Developers explains microservice architecture →

Kubernetes in Action, Second Edition

A microservice architecture structures an application as multiple independently deployable services that collaborate through defined interfaces.

How it is used
Frames Kubernetes as a way to automate the management of independently developed and deployed application services.
How deep it goes
Explains team boundaries, release cycles, dependencies, communication, and management challenges, but stops short of detailed service design.
Examples
Uses the Kiada application, Docker execution, Kubernetes deployment, and a monolith-versus-microservices comparison.
What you can do after
Evaluate when separate services improve team ownership and scaling while recognizing their environment, communication, and management costs.

Read how Kubernetes in Action, Second Edition explains microservice architecture →

Kafka for Architects

Microservices architecture is an architectural style composed of independently deployable services organized around separate capabilities.

How it is used
Organizes independently deployable services around separate capabilities and uses Kafka for decoupled event communication.
How deep it goes
Explains service roles, Kafka integration, frameworks, and trade-offs, but stops short of low-level client implementation.
Examples
Uses customer profiles, billing events, clickstream analytics, fraud scoring, IoT telemetry, and operational alerting.
What you can do after
Builds Kafka-integrated producer and consumer services with Spring-Kafka, Micronaut-Kafka, or lower-level clients.

Read how Kafka for Architects explains microservice architecture →

Python Concurrency with asyncio

Microservice architecture is a system design style that structures an application as a set of independently deployable services communicating over defined interfaces.

How it is used
Uses independently deployable services to separate application responsibilities, scale uneven workloads, and support team ownership.
How deep it goes
Explains principles, tradeoffs, scaling, team independence, asynchronous calls, and resilience patterns, then applies them to e-commerce services.
Examples
Uses e-commerce product, user, order, and backend-for-frontend services to demonstrate decomposition, scaling, communication, and failure handling.
What you can do after
Apply the architecture to an e-commerce system using independent services, asynchronous calls, retries, and a circuit breaker.

Read how Python Concurrency with asyncio explains microservice architecture →

BDD in Action, Second Edition

Microservice architecture is an application architecture in which independently deployable services implement separate business capabilities and communicate through defined interfaces.

How it is used
Deploys microservice boundaries as the basis for API-level acceptance tests and service-interaction scenarios.
How deep it goes
Traces a multi-service registration flow through endpoints, databases, tokens, events, and a message broker.
Examples
Uses Frequent Flyer registration, email confirmation, authentication, account lookup, and an executable acceptance scenario.
What you can do after
Apply it via RESTAssured and JSONPath to automate acceptance scenarios through APIs rather than the user interface.

Read how BDD in Action, Second Edition explains microservice architecture →

Authorization in Action

Microservices is an architectural pattern in which an application is composed of independently deployable services that communicate over a network.

How it is used
Uses independently deployed services and networked APIs to support organizational and technical integration.
How deep it goes
Explains service decomposition and compares gateway, service-mesh, and per-service proxy enforcement, without detailing deployment implementation.
Examples
Uses ACME’s decomposed collaboration, HR, and Finance systems and a cross-service project-report request.
What you can do after
Evaluate where authorization enforcement should sit across gateways, service meshes, and critical service APIs.

Read how Authorization in Action explains microservice architecture →

Also covered in

What to know first

Related concepts

Questions about microservice architecture

What is microservice architecture?

Microservice architecture is a software architectural style that structures an application as independently deployable services, typically organized around focused capabilities and communicating through defined interfaces.

Which Manning books explain microservice architecture?

Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform, Microservices Patterns, Second Edition, Spring Microservices in Action, Fast by Default, Acing the Frontend Interview, Google Anthos in Action, gRPC Microservices in Go, Cloud Observability in Action and 10 more.

What should I know before learning microservice architecture?

Manning books that teach microservice architecture usually introduce monolithic architecture, contract, gRPC and REST first.

What is the difference between microservice architecture and monolithic architecture?

Microservice architecture is a software architectural style that structures an application as independently deployable services, typically organized around focused capabilities and communicating through defined interfaces. Monolithic architecture is a software architectural style in which an application's major functionality is organized and deployed as a single unit.

What is microservice architecture a kind of?

Microservice architecture is a kind of distributed system. A distributed system is a computing system whose components run across multiple networked processes or machines and coordinate through communication.

What is microservice architecture also called?

Microservice architecture is also called microservice-based architecture.

These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.