I've been brought in to review architectures at every stage of a program's lifecycle. Early, when decisions are still open. Mid-stream, when the design is set but implementation hasn't started. Late, when the system is running and the program is trying to figure out why it costs what it costs, or why it can't clear the compliance review it's been preparing for.
The late ones are the most expensive conversations. Not because the problems are unfixable — most of them can be fixed — but because by the time I'm in the room, the options have already narrowed.
What late review actually looks like
A program has been running for two years. The infrastructure is built. The contracts are signed. The integration dependencies are locked. The engineering team has adapted its practices to the constraints of the current design. The security team has been working toward certification on the existing architecture.
Then something happens. A cost overrun. A performance problem. A security finding the current design can't cleanly resolve. A new requirement the architecture didn't anticipate.
The program brings in an architect.
In the late reviews I've done, the pattern repeats: the root cause traces back to a decision made eighteen to thirty-six months earlier, usually before the engineering started and often before the contract was fully scoped. The decision made sense at the time, or at least wasn't questioned at the time. By the time the consequence surfaces, the context behind it is long gone.
The fix, when there is one, means working backward through constraints that have calcified into facts. Some can be unwound. Others are load-bearing and can't change without disturbing things no one wants to touch. Options that would have been straightforward at design time are now costly, risky, or both.
Why programs skip early review
It isn't ignorance. Most program managers I work with know early decisions are the cheapest to get right. The problem is structural.
Early in a program, the budget is still being set. An architecture engagement feels like a cost before its value is visible — especially when the alternative is letting the technical team proceed. The engineers are ready to build. The timeline is already tight. Four weeks of design review before the first sprint feels like delay.
What it actually is: the cheapest insurance available.
The other factor is that early architecture problems don't look like problems yet. A decision that will drive a significant remediation two years from now looks, today, like a reasonable technical choice made by qualified people. The risk stays invisible until the conditions that expose it arrive.
By then, the budget to fix it has to come from somewhere else.
The geometry of architecture cost
A long-standing rule of thumb in systems engineering holds that the cost of a change grows by roughly an order of magnitude with each phase of the lifecycle. A decision changed during design costs one unit. During development, ten. During testing, a hundred. After deployment, a thousand.
Treat the numbers as illustrative, not precise. The direction is what matters, and it matches what I've seen on the complex programs I've worked. The earlier architectural judgment is applied, the cheaper the outcome — in direct cost, in risk, in schedule, and in the options that stay open for later.
Programs that understand this treat early architecture review as a fixed cost of doing business, not a discretionary engagement.
What good timing looks like
The right time for an architecture review is before the engineering constraints are set. Ideally that means before the contract is fully scoped, because the contract often locks the architecture implicitly — through its requirements, its period of performance, and its deliverable structure.
If that window has passed, the next-best time is before the detailed design is final. Before the integration dependencies lock. Before the certification baseline is established. Before the engineering team builds its practices around constraints that will be expensive to change.
There is usually a next-best time. Late review isn't worthless. But each phase of delay narrows the options and raises the cost of the same underlying judgment call.
The bottom line
The most useful thing I do as an architect isn't the review that catches a problem already embedded in the system. It's the conversation early enough that the problem never has to be caught — because the decision that would have created it gets made differently.
That conversation is shorter, cheaper, and less dramatic than a late-stage remediation. It also never shows up in a post-mortem, because nothing went wrong.
That's the measure of early architecture done right: the absence of a problem you'll never see.
Cybaris Consulting provides architecture-level judgment before the expensive decisions are made. If you're scoping a program or preparing for a modernization cycle, the first conversation is free at cybarisconsulting.com.

