Architecture working guide

Make a technical decision people can revisit

Clarify the constraint, compare credible options, and preserve the tradeoffs behind the choice.

What you’ll work toward

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.

01

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.

02

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.

03

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.

04

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 worked example

A boundary can come before a service

Module first
CheckoutBilling module

One deployment.
A boundary the team can test.

Extracted service
CheckoutBilling service

Independent releases.
Two services for the same operators.

Reconsider when independent deployment or ownership becomes a real requirement.

Put it to work

0 of 8

Use 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.
Free template, one-page PDF

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.

Download PDFOpen
Read other perspectives

Architecture resources

Explore in the catalog

Open the original work directly. Our notes explain what each resource contributes and where its advice needs context.

Guide

Twelve-Factor App

Adam Wiggins and contributors

Twelve operational principles for applications, with useful starting points for configuration, releases, and process lifecycle.

12factor.netOur notes
Essay

How I Write Tests

Nelson Elhage

A practical testing approach built around separable modules, reusable fakes, and making verification easier to perform.

blog.nelhage.comOur notes
Book

Site Reliability Engineering

Betsy Beyer, Chris Jones, Jennifer Petoff & Niall Richard Murphy, editors

Google’s free book on error budgets, toil, monitoring, on-call, and operating services. Start with the principles before the large-scale machinery.

Free online bookOur notes
Book

Software Engineering at Google

Titus Winters, Tom Manshreck & Hyrum Wright, curators

A free book about keeping a codebase healthy over time: engineering culture, processes, tools, and the tradeoffs that come with scale.

Free online bookOur notes
Article

Strangler Fig

Martin Fowler

A gradual approach to modernizing legacy systems by replacing behavior in increments, with attention to why large replacement projects go wrong.

Free articleOur notes
Tutorial

The Practical Test Pyramid

Ham Vocke

A detailed testing tutorial connecting fast unit tests, integration boundaries, contract tests, and end-to-end coverage to practical code examples.

Free tutorialOur notes
Reference

Architecture Decision Record

Martin Fowler

A compact explanation of recording one consequential architectural decision, its context, consequences, and later superseding decisions.

Free referenceOur notes
Article

Timeouts, Retries, and Backoff with Jitter

Marc Brooker, Amazon Builders’ Library

Why retries can amplify an outage, how timeout boundaries matter, and how backoff and jitter help keep transient failures from becoming overload.

Free articleOur notes
Course

An Introduction to Distributed Systems

Kyle Kingsbury & Jepsen

Public teaching notes on time, networks, faults, safety, liveness, algorithms, and practical production concerns, with links to optional lab work.

Free course notesOur notes
Manifesto

The Reactive Manifesto

Reactive Manifesto authors & signatories

A concise statement of responsive, resilient, elastic, message-driven systems, with a glossary for discussing these architectural qualities.

Free manifestoOur notes
Collection

Awesome Scalability

Binh Nguyen & contributors

A large reading index of performance, scalability, reliability, and real-world architecture case studies, useful for researching a specific bottleneck.

Public collectionOur notes
Collection

Awesome Billing

Kévin Deldycke & contributors

An engineering-oriented index of pricing, billing, accounting, invoices, payments, tax, fraud, and the systems that connect them.

Public collectionOur notes
Collection

Awesome Falsehood

Kévin Deldycke & contributors

An index of mistaken software assumptions about names, time, addresses, identity, geography, and other messy parts of the real world.

Public collectionOur notes
Collection

Software Engineering Blogs

Kilim Choi & contributors

A directory of company and individual engineering blogs for finding first-hand technical accounts beyond the same handful of frequently shared articles.

Public publisher indexOur notes
BookHistorical

The Mythical Man-Month

Frederick P. Brooks Jr.

Essays on large software projects, coordination costs, conceptual integrity, and why adding people is not a simple cure for a late project.

Commercial book · samples availableOur notes
Book

Building Secure & Reliable Systems

Heather Adkins, Betsy Beyer, Paul Blankinship, Ana Oprea, Piotr Lewandowski & Adam Stubblefield

Google practitioners connect security and reliability across system design, implementation, operation, incident response, and organizational culture.

Free online bookOur notes
Talk

Thinking Like an Architect

Gregor Hohpe

A recorded talk about architecture as a way of thinking: connecting levels, sketching, preserving options, using models, and recognizing tradeoffs.

Video & transcriptOur notes
Esc

Type to search every entry. ↑↓ to move, Enter to open.