A decision record with a named owner, operational consequences, and clear reasons to reconsider it.
A technology choice is rarely good or bad independently of the system around it. The right discussion connects customer needs, team capability, operating burden, cost, and the consequences of being wrong. Start there before comparing features.
Write the constraint before the solution
Describe the observed problem and what would count as improvement. “The checkout service cannot recover from a provider timeout without duplicate work” is more actionable than “we need event-driven architecture.” Record scale, failure tolerance, delivery constraints, and what the team can operate. Distinguish measured conditions from predictions.
Include the option of improving the current design. A rewrite or service extraction should compete with a smaller change that addresses the same constraint. If the new option solves a different problem, make that explicit rather than giving it credit for benefits the current business does not need.
Compare the whole operating model
For each credible option, explain data ownership, interfaces, deployment, failure behavior, observability, access control, and recovery. A service boundary adds an operational relationship: callers need to handle latency and failure, teams need to version contracts, and somebody needs to be available when it stops working.
Evaluate the ordinary path and the bad day. What happens when a dependency is slow, a message is delivered twice, a deployment is partial, or the person who understands the system is unavailable? A prototype can answer a narrow technical question, but it does not establish that the full operating model is affordable or maintainable.
Discuss the disadvantages first
State why your preferred option could be wrong. This lets reviewers correct a mistaken priority before spending their time on implementation details. Ask stakeholders whether the proposed cost, delay, and failure modes are acceptable. Invite alternatives that meet the same constraints rather than defending a particular tool as an identity.
Keep a decision owner and a time boundary for review. Consensus may be valuable, but unresolved ownership can make a review endless. Record material disagreement in the decision itself. Future engineers should be able to see which risks were understood and consciously accepted rather than assuming the original team overlooked them.
Plan the transition and the exit
A final-state diagram is only part of the decision. Explain how you reach it safely, how mixed versions behave, how you verify progress, and when temporary compatibility paths will be removed. Migration work includes data correction, operational training, and changes to downstream consumers, not just the new service.
Define the evidence that would make you reconsider. It might be a new load profile, a change in ownership, an operating cost that exceeds the agreed boundary, or a product requirement the original design excluded. A decision record should preserve context without making yesterday’s assumptions permanent.
A boundary can come before a service
One deployment.
A boundary the team can test.
Independent releases.
Two services for the same operators.
Reconsider when independent deployment or ownership becomes a real requirement.
Put it to work
0 of 8Use these prompts to check your next step. Your marks stay on this device.
Watch for these failure modes
- Choosing a topology to compensate for unclear code ownership.
- Presenting only a final-state diagram.
- Treating the absence of objections as proof that tradeoffs were understood.

Architecture decision record
Record a significant technical decision so the team can revisit it later.
11 prompts: Decision and owner, Observed constraint, Assumptions, and 8 more.
Architecture resources
Open the original work directly. Our notes explain what each resource contributes and where its advice needs context.
Accentuate the negative: making the non-perfect decision. Technical decision making
How to build agreement around a technical proposal by explaining its disadvantages and assumptions early.
Microservices – Please, don’t
A cautionary account of the costs hidden behind promises of cleaner code and easier scaling through microservices.
Twelve-Factor App
Twelve operational principles for applications, with useful starting points for configuration, releases, and process lifecycle.
How I Write Tests
A practical testing approach built around separable modules, reusable fakes, and making verification easier to perform.
Site Reliability Engineering
Google’s free book on error budgets, toil, monitoring, on-call, and operating services. Start with the principles before the large-scale machinery.
Software Engineering at Google
A free book about keeping a codebase healthy over time: engineering culture, processes, tools, and the tradeoffs that come with scale.
Strangler Fig
A gradual approach to modernizing legacy systems by replacing behavior in increments, with attention to why large replacement projects go wrong.
The Practical Test Pyramid
A detailed testing tutorial connecting fast unit tests, integration boundaries, contract tests, and end-to-end coverage to practical code examples.
Architecture Decision Record
A compact explanation of recording one consequential architectural decision, its context, consequences, and later superseding decisions.
Timeouts, Retries, and Backoff with Jitter
Why retries can amplify an outage, how timeout boundaries matter, and how backoff and jitter help keep transient failures from becoming overload.
An Introduction to Distributed Systems
Public teaching notes on time, networks, faults, safety, liveness, algorithms, and practical production concerns, with links to optional lab work.
The Death of Microservice Madness in 2018
A detailed discussion of why microservices appeal, where their operational costs appear, and what to ask before splitting a system.
The Reactive Manifesto
A concise statement of responsive, resilient, elastic, message-driven systems, with a glossary for discussing these architectural qualities.
Awesome Scalability
A large reading index of performance, scalability, reliability, and real-world architecture case studies, useful for researching a specific bottleneck.
Awesome Billing
An engineering-oriented index of pricing, billing, accounting, invoices, payments, tax, fraud, and the systems that connect them.
Awesome Falsehood
An index of mistaken software assumptions about names, time, addresses, identity, geography, and other messy parts of the real world.
Software Engineering Blogs
A directory of company and individual engineering blogs for finding first-hand technical accounts beyond the same handful of frequently shared articles.
The Mythical Man-Month
Essays on large software projects, coordination costs, conceptual integrity, and why adding people is not a simple cure for a late project.
Building Secure & Reliable Systems
Google practitioners connect security and reliability across system design, implementation, operation, incident response, and organizational culture.
Thinking Like an Architect
A recorded talk about architecture as a way of thinking: connecting levels, sketching, preserving options, using models, and recognizing tradeoffs.
Best Practices for Designing a Pragmatic RESTful API
A concrete API design checklist covering the developer experience, resource design, documentation, versioning, and operational details.