A solution architecture diagram can look complete while leaving the most important questions unanswered. The boxes have names, the arrows connect, and the platform choices seem reasonable. Yet nobody can explain what a customer sees when a dependency times out, whether a repeated request creates a duplicate transaction, or who has the authority to restore service.
An effective architecture review follows a real business journey through the proposed system. It connects design choices to observable behaviour and ends with decisions that a delivery team can act on. This article walks through a fictional order-processing service to show how that review works, what evidence to request and how to avoid turning a useful discussion into a diagram inspection.
Design goals: what decision must the review support?
“Review the architecture” is too broad to guide a meeting. A more useful brief is: “Decide whether this design is ready for a limited production release, and identify the conditions that must be satisfied first.” The scope now has a boundary and a consequence. Reviewers know which questions affect the release and which belong in later improvement work.
Agree who owns that decision. The architect can explain alternatives, security specialists can assess access boundaries, and operations can describe recovery constraints. The product or service owner still needs to accept the business consequences. A review records those responsibilities instead of allowing a room full of technical specialists to imply collective approval.
For our example, a customer submits an order, a payment provider authorises payment, a warehouse reserves stock, and an email service sends confirmation. The release decision concerns a small customer cohort. It does not include a new international payment flow or the replacement of every warehouse integration.
Architecture and data flow: follow one order
Draw the journey in the order events actually happen. Include authentication, application processing, persistence, external requests and asynchronous work. An arrow should explain what crosses a boundary: a command to reserve stock, an event reporting a completed payment, or a query asking for current order status.
Ask the team to describe the response returned to the customer. Does “accepted” mean only that a request reached the application, or that an order has been durably recorded? Does “confirmed” mean stock has been reserved? These words create promises. If the interface uses them inconsistently, a technically healthy service can still mislead its users.
Then trace the journey from the operator’s perspective. Which identifier joins the browser request, the order record and the warehouse task? Where does an engineer see work that has been accepted but not completed? A distributed trace helps reconstruct activity, but the business record must also explain what happened to the order.
Failure handling: inspect uncertain outcomes
The interesting case is often a partial success. Imagine that the payment provider authorises a payment but its response never reaches the application. Retrying blindly could create an additional authorisation; assuming failure could cause an order to be abandoned after money has been reserved. The design needs a way to reconcile an uncertain outcome.
Microsoft’s failure mode analysis guidance recommends examining failures in the context of critical flows and distinguishing read failures from write failures. That distinction is useful here: failing to read an order status and failing to learn whether a payment write succeeded require different responses. The questions below apply that principle to our fictional service.
| Situation | Design question | Useful evidence |
|---|---|---|
| The customer submits twice | How is one business order distinguished from two valid orders? | A repeated-request test and the resulting records |
| Payment succeeds but the response is lost | How is the uncertain result reconciled? | A provider lookup or reconciliation demonstration |
| Stock cannot be reserved | Who cancels or compensates earlier work? | A visible exception state and an owned recovery procedure |
| The worker stops after acceptance | How is pending work recovered without duplication? | A restart test with recorded business outcomes |
Do not solve every failure with “add retries”. A retry policy needs an owner, a limit and a reason to believe repetition is acceptable. An idempotency key can help associate repeated attempts with one intended operation, but its scope, storage, expiry and behaviour under concurrency still need to be specified.
Components and evidence: verify the claims
“The platform supports failover” is a capability statement. “We restored the order service within the agreed target using this runbook and verified these records” is evidence about a particular implementation. Both matter, but they answer different questions. The review should make that difference visible.
A useful evidence pack is selective. Include the request flow, the assumptions behind capacity and recovery objectives, results from a small number of representative failure tests, and unresolved decisions. Avoid attaching hundreds of screenshots that nobody can connect to a release condition. Every item should answer a question that influences the decision.
For example, a recovery test might restore a backup successfully while missing transactions accepted after the backup was created. A technical restore has succeeded; the business recovery outcome may still be unacceptable. Check the restored records and the reconciliation process, rather than relying on a green completion status.
Trade-offs: where should complexity live?
Architecture choices distribute complexity. Synchronous fulfilment can make the customer interaction easy to describe, but it couples response time and availability to multiple dependencies. Asynchronous fulfilment can protect acceptance during downstream disruption, but it introduces intermediate states, monitoring and recovery work. Neither choice is automatically better.
Compare alternatives against the same requirements. If an order must be acknowledged quickly while a warehouse sometimes takes minutes to respond, a pending state may be appropriate. If the business cannot tolerate accepting an order before stock is reserved, the interface and availability expectations need to reflect that constraint.
Record why the selected option fits today, what it gives up, and what change would trigger another review. A short decision record might say that a single-region design is acceptable for the initial cohort under a tested recovery plan, while expansion to a different service commitment requires revisiting that decision. This is more useful than treating a temporary choice as a universal standard.
Operational guidance: close with owned conditions
The output should be understandable to someone who missed the meeting. State whether the design can proceed, which conditions remain, who owns each condition and what evidence closes it. “Improve observability” is not a release condition. “Expose accepted orders older than the agreed processing window, with an alert routed to the named support team” can be one.
For the example service, the team might proceed only after demonstrating duplicate-submission handling, documenting the payment reconciliation route and rehearsing recovery of a stopped worker. A separate improvement could address a less critical reporting dependency after the pilot. Keeping those categories distinct protects both delivery pace and the integrity of the release decision.
Before your next review, choose one valuable user journey and ask three people to explain it: its designer, its operator and its business owner. Differences between their accounts are productive starting points. Resolve those differences in the design, then test the parts that matter. The goal is a system whose behaviour can be explained and supported when the diagram stops being enough.
Technical reference
Microsoft Azure Well-Architected Framework: failure mode analysis supports the flow-based failure review approach. The order service, proposed review questions and release conditions in this article are illustrative engineering examples.

