Microservices Fundamentals
Microservices are an architectural style in which independently deployable services implement distinct business capabilities and communicate over a network. They can let teams change parts of a system separately, but they add distributed-systems failure, data, and operational work.
itDistributed systems, messaging, and integration | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic — Microservices Fundamentals
A microservice is a deployable program that handles one focused business capability and talks to other programs over a network. That description sounds tidy because it leaves out the wires, the timeouts, and the part where the network develops opinions. The point is not to create a charming village of tiny applications. The point is to make one capability changeable without moving every other capability at the same time.
Before this arrangement, one application could keep its rules, database access, and calls in one deployment. A service boundary trades that local convenience for a contract between owners. An order service can own order lifecycle rules. A catalog service can own product information. Split by business capability and the boundary has a job; split by technical layer and each ordinary change becomes a small committee meeting with packets.
The surprise is that a remote call is not a function call wearing a hat. It has latency, partial failure, retries, and the unpleasant possibility that the other side completed the work just before the reply vanished. An idempotent operation can tolerate a retry without repeating its effect. That is why timeouts, bounded retries, load shedding, and fallback behavior belong in the design rather than in a box labeled “later, probably.”
Data also refuses to remain politely local to a diagram. A service that owns its data model cannot rely on a shared database as its hidden integration contract. When a business process crosses services, a saga uses local transactions and compensating actions instead of one shared transaction. When a read needs several services, API composition or a materialized view provides an application-level answer. Eventual consistency is therefore a user-visible behavior, not an invisible plumbing detail.
A fleet of services needs automated delivery, routing, identity, secrets, health checks, logs, metrics, traces, and clear on-call ownership. A gateway or service mesh can help with traffic and telemetry; neither can choose a good boundary or authorize a business action on your behalf. The practical test is pleasantly unromantic: extract a service only when independent delivery, scaling, fault isolation, or ownership gives a measurable benefit. Keep a monolith when it keeps change and operations clearer.
Read the intro for the architecture and tradeoffs, the slides for the relationship map, and the cheatsheet when choosing a communication or data pattern. The Field Notes tab names the operational costs that diagrams tend to misplace. The exercise then lets one request cross a real local boundary, carry trace context, and fail in a way that is visible instead of theatrical.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://microservices.io/patterns/microservices.html
Supports
- Microservice architecture, service collaboration, communication, data ownership, deployment, and observability patterns
- https://learn.microsoft.com/en-us/azure/architecture/guide/architecture-styles/microservices
Supports
- Microservice benefits, challenges, data, communication, and operational considerations
- https://microservices.io/patterns/data/database-per-service.html
Supports
- Database ownership, sagas, API composition, and CQRS
- https://istio.io/latest/about/service-mesh/
Supports
- Service-mesh traffic, security, and observability capabilities
- https://microservices.io/post/microservices/2022/04/23/ten-years-of-microservices.html
Supports
- 2012 deployability and scalability presentation in the history timeline
- https://martinfowler.com/articles/microservices.html
Supports
- 2011 and 2012 naming history, 2014 articulation, and core microservice characteristics
- https://martinfowler.com/articles/distributed-objects-microservices.html
Supports
- 2014 guidance on treating remote calls differently from in-process objects
- https://kubernetes.io/blog/2015/07/21/kubernetes-1-0-release/
Supports
- Kubernetes 1.0 release in the platform timeline
- https://istio.io/latest/blog/2017/0.1-announcement/
Supports
- Istio 0.1 announcement in the platform timeline
- https://opentelemetry.io/blog/2019/05/21/announcing-otel/
Supports
- OpenTelemetry project announcement in the observability timeline
- https://www.cncf.io/announcements/2020/05/12/cloud-native-computing-foundation-announces-graduation-of-kubernetes/
Supports
- Kubernetes CNCF graduation in the platform timeline
- https://www.infoq.com/articles/lessons-learned-monolith-microservices/
Supports
- Practitioner lessons on incremental monolith migration and test-first extraction
- https://developer.konghq.com/gateway/
Supports
- Kong Gateway placement in the API gateway landscape
- https://aws.amazon.com/api-gateway/
Supports
- Amazon API Gateway placement in the API gateway landscape
- https://cloud.google.com/apigee
Supports
- Apigee placement in the API management landscape
- https://azure.microsoft.com/en-us/products/api-management/
Supports
- Azure API Management placement in the API management landscape
- https://linkerd.io/
Supports
- Linkerd placement in the service mesh landscape
- https://dapr.io/
Supports
- Dapr placement in the distributed application runtime landscape
- https://temporal.io/
Supports
- Temporal placement in the workflow orchestration landscape
- https://docs.python.org/3/library/http.server.html
Supports
- Local HTTP server used by the safe practice exercise
- https://docs.python.org/3/library/urllib.request.html
Supports
- Timeout-bound local dependency request used by the safe practice exercise
