zero gravitySOLUTIONS
← All insightsARCHITECTURE / REVIEW FIELD GUIDE

Software architecture reviews: what to learn before a rewrite.

QUICK ANSWER

Start an architecture review with one delayed change or recurring incident. Trace it through code, data, deployment, and ownership. Compare targeted repair, boundary extraction, and replacement against the same evidence before committing to a rewrite.

Inside this article 7 sections

“Every change takes too long” is a reason to investigate a system. It is not yet a reason to replace it. The delay could come from tightly coupled code, unreliable tests, unclear ownership, a shared deployment bottleneck, or a product decision that remains unresolved until implementation starts. A rewrite helps only some of those problems.

A focused architecture review begins with one concrete example. Choose a feature that recently moved slowly or an incident that repeatedly returns. Follow its path through the system and the team. The aim is to turn a broad complaint into a small number of explanations that can be tested.

Trace one change across four kinds of waiting

For an illustrative review, imagine adding account-level spending limits. The change touches a web interface, an API, a billing module, and a nightly reconciliation job. Record when work began, where it paused, who needed to make a decision, and which parts had to be retested together. Use actual change records when reviewing a real system; recollection alone tends to flatten several different delays into “the architecture.”

Separate implementation time from waiting for information, validation, and release. If a two-hour code change waits four days for a shared test environment, replacing the framework may barely affect the delivery time. If every change requires understanding unrelated billing behavior, a domain boundary may be the more important issue.

REVIEW LENS / FOLLOW THE CHANGE
UNDERSTANDWhat must be learned?

Rules, ownership, hidden dependencies

IMPLEMENTWhat must change together?

Code, contracts, data, configuration

VALIDATEWhat proves it works?

Tests, environments, acceptance

RELEASEWhat delays safe delivery?

Coordination, rollout, recovery

An original review worksheet. The diagram identifies questions; it does not assign invented performance scores.

Keep competing explanations alive

Turn each suspected problem into a claim with observable consequences. “The billing module is too coupled” might predict that a small spending-limit change requires edits in several unrelated areas. “The test suite is unreliable” might predict repeated reruns without code changes. “Nobody owns the decision” might predict long gaps before an acceptance rule is agreed.

Collect evidence that could disprove the favorite explanation. Inspect a change that went quickly as well as one that went badly. If both crossed the same module boundaries, coupling alone may not explain the difference. This prevents an architecture review from becoming a search for reasons to adopt a technology already preferred by the reviewer.

Use an operational review framework to broaden the questions around reliability, security, cost, and maintainability, but connect findings to the workload. A checklist item is not automatically the highest-priority business risk. A missing restore test may deserve attention before a fashionable migration even if the current application is delivering features successfully.

Compare repair, extraction, and replacement on one page

Targeted repair changes the current system: clarify a module boundary, add a characterization test, improve a deployment path, or remove a repeated manual step. Boundary extraction moves a specific responsibility behind a controlled interface. Replacement builds a new implementation for a larger scope. Compare them against the same problem, rather than comparing a realistic repair estimate with an idealized rewrite.

Include the cost of running old and new paths together. Data migration, parity testing, operational support, and rollback often occupy the space omitted from a rewrite presentation. Define who owns data during transition and how conflicts are resolved. Two implementations that can both update the same business record need more than a routing switch.

Evidence required before choosing an intervention
OptionEvidence that supports itQuestion that can stop it
Repair in placeA small, identifiable cause explains much of the delay.Can the repaired boundary be tested and maintained?
Extract a responsibilityA separable capability has distinct change or scaling needs.Can data ownership and failure handling be made explicit?
Replace a larger scopeConstraints cannot be addressed economically through smaller changes.Can the business fund coexistence, migration, and uncertainty?

Compare interventions against the observed constraint before estimating a replacement. This map gives each option a different proof obligation for the spending-limit example.

Match the intervention to the evidence
Repair the current module
Show that a focused change removes the repeated defect or waiting point while preserving the existing operating path.
Extract one capability
Demonstrate a useful ownership boundary, an explicit state contract, and a release that can be operated independently.
Replace a wider system
Establish why narrower changes cannot meet the constraint, then prove data transition and continuity on a representative slice.
Each option needs evidence proportional to the behavior it changes. Architectural novelty is not itself a reason to choose the largest intervention.

Design a slice that can teach you something

If extraction looks promising, choose a boundary that can be routed and observed independently. An incremental migration can move traffic to a new implementation while the rest of the product continues to operate. The first slice should test the difficult assumption—such as data synchronization or rollback—not merely deliver the easiest isolated screen.

Define success and a stopping condition before starting. For example, require that a spending-limit decision can be tested without bringing up unrelated modules, while preserving existing billing behavior. If the slice reveals that data ownership cannot be separated safely within the agreed effort, capture that evidence and reconsider the plan. A failed experiment can still prevent an expensive commitment.

Turn the spending-limit example into a decision record

A useful decision record makes the competing options visible without pretending the investigation is already complete. For the hypothetical spending-limit feature, start with the observed difficulty: a small policy change requires testing billing calculations and a reconciliation job together. Then name what remains unknown. Are those parts coupled because they share a valid business invariant, because they duplicate logic, or because the test environment cannot isolate them?

Compare three interventions. The first extracts the policy calculation into a well-defined module inside the existing application and adds tests around its inputs and outputs. The second introduces a separately deployed policy service. The third replaces the wider billing implementation. Each option should explain how it preserves the same spending-limit behavior, handles data changes, and supports recovery after a failed release.

For the module option, a useful experiment is to make the next policy change without editing the reconciliation job. For the service option, test the failure introduced by a network boundary: what happens when the policy service cannot respond, and can the product still enforce the limit correctly? For replacement, identify the historical billing behaviors and migration cases that must be understood before any implementation estimate becomes credible.

The record may provisionally favor the module because it tests the separation hypothesis with fewer new operating responsibilities. That is a design judgment for this scenario, not a general rule against services. Write down what would change the decision: independently owned policy releases, a measured scaling constraint, or evidence that the module cannot preserve the required boundary.

Finish with a bounded next action, its owner, and the evidence expected at review. Avoid a milestone such as “improve architecture,” which can absorb unlimited work. A clearer milestone is “demonstrate an isolated policy change with regression tests and a reversible release.” The team can then decide whether the result justifies further investment. This is how an architecture review becomes a sequence of decisions the business can evaluate rather than a large recommendation whose benefits remain distant.

Define the review boundary before buying a migration plan

A buyer can make an architecture review much more effective by naming one painful change and one important operating constraint. For example, use the most recent account-limit change and the requirement that existing customers continue working during deployment. Supply the relevant code path, release history, and a person who can explain the business rule. A broad repository scan can support the review, but it should not replace investigation of that representative path.

Request findings linked to inspectable evidence, a comparison of repair and replacement options, and a proposed first experiment. Each recommendation should explain who can act on it and what would show that it helped. Separate observed coupling from suspected coupling. A diagram of dependencies is useful only when the receiving team can connect its lines to a real change, failure, or operating responsibility.

Choose a focused review when the reason for a rewrite remains uncertain. Architecture design becomes the next step when the evidence supports a specific boundary change. Implementation follows when that change has an acceptance condition and an owner. We can support that progression through separately scoped work, preserving the option to stop after the review and use its findings with your existing team.

Ask for findings you can act on

The review deliverable should connect each finding to evidence, business impact, a recommended action, an owner, and an uncertainty. Separate immediate repairs from hypotheses that need more investigation. Include a decision record for options not selected so the next team does not have to repeat the same discussion without context.

A useful review can end with “keep the architecture and fix the release process.” It can also justify a substantial migration. What makes it valuable is the quality of the reasoning and the practicality of the next step. Explore our software development consulting and architecture design services if you need an independent view of those choices.

A review may favor clearer boundaries inside the current application. Consider the decision framework in A modular monolith decision record for a small SaaS team.

FROM INSIGHT TO ACTIONSoftware development consulting

Commission the review before committing to replacement.

We can trace the constraints in your current system and deliver prioritized findings, comparable options, and a first experiment your engineers can evaluate.

Explore technical consultingDiscuss your challenge

Start with your goals.
We’ll work through the next step together.