Microservices Architecture as Code

All courses / Architecture as Code / Module 2 / Chapter 8

Learning objectives

After the lesson the participant can:

• Explain how bounded contexts, contracts and golden paths keep a federated estate coherent.
• Design the repository layout of a service so that architecture, infrastructure and evidence travel together.
• Describe how an executable catalogue reveals coupling hotspots.
• Compare the saga and event sourcing patterns for data across service boundaries.

Key concepts

Bounded context mapped to a repository

Each microservice is treated as a bounded context with a defined purpose, data contract and operational envelope. Its architecture definition is stored beside the application code and IaC modules, so that diagrams, manifests and compliance evidence travel together.

Contract-first integration

API specifications and event schemas are declared as code, for example with OpenAPI or AsyncAPI, and registered in an architecture catalogue. Automated linting checks backwards compatibility and alerts owners when downstream consumers would break.

Golden paths

Shared Terraform modules, Helm charts and service mesh policies that encode approved defaults for security, observability and networking. Pipelines verify that services consume the authorised modules, and deviations are reviewed through architecture decision records.

Coupling telemetry

An executable catalogue indexes every API specification, event schema and data contract, derives dependency graphs after each merge, and flags hotspots where a service has many synchronous consumers or repeatedly changes its schema.

Saga

A pattern that breaks a long-running business transaction into a sequence of local transactions, each publishing an event or message that triggers the next step. If a step fails, compensating transactions reverse the completed steps.

Interactive exercises

Do them here and get feedback at once. Choose a card and then where it belongs, or drag it.

Teaching plan

Discussion

1. The chapter warns against accidental monoliths. What signs in your own estate suggest that services share data they should consume through documented interfaces?
2. When a policy gate fails repeatedly, the chapter lets an architecture council review whether the guardrail or the service boundary needs to change. How would you decide which?
3. What would it take for teams to experience golden paths as help and not as constraint?

Written exercise

Self-test

Choose an answer to see whether it is right, or open the answer below each question.

1. In the saga pattern as the chapter describes it, what happens if one step fails?

   1. The whole transaction is retried from the first step
   2. A distributed lock holds all services until an operator intervenes
   3. The failed step is skipped and reported at the end
   4. Compensating transactions reverse the steps already completed
   Show the answer

   D. Compensating transactions reverse the steps already completed
   A saga is a sequence of local transactions, each triggering the next through an event or message; if any step fails, compensating transactions reverse the completed steps.

2. What should a pipeline verify about golden paths, according to the chapter?

   1. That each team has written and versioned its own modules for security, observability and networking
   2. That each service consumes the authorised modules and deviations go through decision records
   3. That golden paths are optional for services with fewer than three consumers
   4. That every service uses the same programming language and framework
   Show the answer

   B. That each service consumes the authorised modules and deviations go through decision records
   The chapter says pipelines should verify that each service consumes the authorised modules and that deviations are reviewed through architecture decision records.

3. Which hotspot does the chapter say the executable catalogue should flag?

   1. A service with many synchronous consumers or a repeatedly changing schema
   2. A service whose repository has more than one maintainer
   3. A service that publishes events instead of exposing an API
   4. A service that is deployed to production more often than the average for the estate
   Show the answer

   A. A service with many synchronous consumers or a repeatedly changing schema
   Coupling telemetry derives dependency graphs and flags hotspots where a service has many synchronous consumers or repeatedly changes its schema.