NOTE: This is Part I of a two-part discussion on metrics within my causal architectural framework.
Architecture metrics are often built backwards.
We usually begin with data already in hand or available observables such as
- Defect counts
- Schedule variance
- Test completion
- Interface counts
- Change requests
- Productivity measures
- Dashboard status
Then we ask what conclusions can be drawn from those values. The resulting metrics may be useful, but the reasoning starts with what is convenient or available to count rather than with the architectural condition that needs to be understood.
A causal approach reverses that order.
That approach begins with an architectural question
What causal relation must be observed or preserved in order to understand this condition?
Only then do we consider what distinctions, events, localities, or changes might make that relation measurable.
The general pattern is
![]()
This does not produce one universal measure of architectural quality. It produces a family of diagnostics, each constructed to answer a different question
- How the architecture was created
- How it is encountered
- What it imposes on the future
- Which possibilities remain open
The metrics discussed here are therefore examples, not a complete list.
In Part I, we examine four kinds of architectural condition
- Encountered complexity
- Total Technical Debt
- Verification burden
- Option entropy
Together, they describe different aspects of what an architecture imposes on present agents and future action. They do not collapse naturally into a single score, nor should they. Each retains a different causal meaning, locality, and timescale.
From Counting Artifacts to Measuring Causal Conditions
Most engineering metrics refer to something observable, either directly or via proxy. This is necessary if we want to make a measure, but it is not sufficient.
A metric becomes architecturally meaningful only when the observed quantity remains connected to the causal condition it is intended to diagnose.
A count of interfaces, for example, may say little by itself. Ten interfaces may be easy to understand and change. Three may connect organizations, suppliers, regulatory regimes, and incompatible technical assumptions. The count is precise, but the causal burden is not preserved.
The same problem appears when completion is used as a proxy for confidence. A verification activity may be marked complete even though the evidence it produced is too narrow for a later architectural change. A trade study may be complete even though the option set was prematurely or inappropriately constrained. A model may be detailed even though the distinctions needed by a downstream decision were lost.
The metric measures something precisely without measuring the architectural condition that actually matters.
The purpose of a causal metric is not merely to represent a state. It is to preserve some relationship among prior decisions, present architectural structure, agents acting within localities, obligations carried into the future, and the remaining frontier of plausible action.
This is consistent with the broader engineering understanding that architecture and technical debt are shaped by consequential design decisions rather than by isolated code or component properties alone [KNO12, Sof22]. It also reflects a central lesson of systems engineering, which is that
Verification, validation, technical planning, and decision management are lifecycle concerns whose effects propagate beyond the activity in which they first appear [Nat16].
The causal framework makes that propagation the primary object of measurement.
Encountered Complexity: Burden On An Acting Agent
The first example is encountered complexity as discussed in an earlier post. We will recap that discussion here.
A conventional complexity metric often treats complexity as a property of the system itself. It may count connections, dependencies, states, branches, components, requirements, or paths. These measures can reveal important structural properties, but they do not fully describe the complexity that a person, team, tool, or organization must actually confront when acting.
This is why I say that encountered complexity is local.
An agent does not encounter the entire architecture at once. The agent encounters a portion of it from a particular role, at a particular time, with particular expertise, tools, representations, access, and decision memory.
We can express the idea schematically as
![]()
where
is the architecture,
is the locality in which action occurs,
is the acting agent, and
is time.
The notation is not intended to imply that encountered complexity can always be calculated as a clean scalar. In fact, it may be a vector or a tensor. Its purpose, however, is to preserve the dependencies that make the quantity meaningful.
The same architectural region can be encountered very differently by different agents. An experienced engineer may recognize patterns, remember prior decisions, know which interfaces are fragile, and understand which apparent alternatives are not actually viable. A new engineer may encounter the same structure as a dense collection of unexplained exceptions.
The architecture has not changed in each case but the encountered complexity has.
This means that expertise does not merely increase the speed at which work is performed. It can suppress effective complexity through pattern recognition, selective attention, trusted relationships, decision memory, causal history, and tool fluency. When that expertise is removed, complexity that had been cognitively absorbed by the organization can become visible again.
A causal metric for encountered complexity should therefore consider
What architectural distinctions must this agent preserve and coordinate in order to act successfully within this locality?
Possible observations might include
- The number of causally relevant decisions that must be recovered
- The number of organizational or architectural boundaries that must be crossed
- The depth of dependency chains that must be understood
- The number of unresolved assumptions encountered
- The effort required to distinguish genuine options from apparent ones
- The amount of tacit expertise required to avoid failure
- The rate at which the relevant causal context is changing.
The last item is important.
A high but stable encountered complexity may be manageable. A rapidly increasing encountered complexity may overwhelm the same team because its cognitive architecture cannot adapt quickly enough.
The diagnostic object is therefore not only
but also
![]()
and, when useful
![]()
A static value describes burden. A rate describes whether that burden is becoming easier or harder to carry.
Total Technical Debt: Burden On Future Action
As discussed in the previous post and recapped here, Total Technical Debt (TTD) asks a different causal question
What additional burden has the existing architecture imposed on future action?
The technical debt metaphor was introduced to explain why apparently useful short-term decisions can increase the cost of later change. The concept subsequently expanded from code-level concerns to architectural and system-level conditions [Cun92,KNO12,Sof22]. Work on hidden debt in machine-learning systems further demonstrated that consequential burdens may reside in data dependencies, configuration, glue code, undeclared consumers, and system interactions rather than in visibly poor source code alone [SHG+15].
TTD extends the causal boundary further.
TTD may arise from
- Deliberate shortcuts
- Incomplete decisions
- Lost rationale
- Inadequate verification infrastructure
- Brittle interfaces
- Obsolete assumptions
- Organizational changes
- Supplier dependencies
- Regulatory change
- Mission drift
- Business architecture misalignment
- Adaptations that solve one locality’s problem by exporting burden elsewhere
The relevant condition is not whether something was done badly but whether prior architectural history has made future action more constrained, expensive, uncertain, or difficult to verify.
That burden also changes on different timescales. A useful conceptual decomposition is
![]()
Rapidly changing TTD may result from emergency patches, compressed schedules, sudden integration failures, urgent requirement changes, or abrupt operational shocks. Slowly changing TTD may result from aging assumptions, gradual expertise loss, deteriorating business alignment, obsolete infrastructure, regulatory drift, or the accumulation of small cross-layer mismatches.
This distinction is especially important because an architecture can accumulate debt even while remaining internally unchanged
![]()
If the environment or context moves while the architecture does not, the burden of future adaptation can still rise. A technically coherent system may therefore become strategically wrong.
As with encountered complexity, the current value,
, is not enough. We also care about
![]()
and
![]()
Two systems with similar estimated TTD may be in fundamentally different conditions if one is stable and understood while the other is rapidly accumulating debt across several architectural layers.
TTD also illustrates why causal metrics must be localized.
Debt can be moved rather than paid. A software team may reduce implementation effort by increasing verification burden. A subsystem may simplify its design by exporting variability to manufacturing. A governance decision may protect the current schedule while constraining future integration. A local metric may improve while the total burden merely changes owner, layer, or lifecycle phase.
Thus,
. A causal TTD metric must therefore retain information about where the burden was created, where it is now encountered, and which future actions it constrains.
Verification Burden: Obligations Created By Decisions
Encountered complexity concerns the burden on an acting agent. TTD concerns the burden imposed on future action.
Verification burden concerns the evidence obligations created by architectural decisions.
Every important decision changes not only what must be built, but what must later be demonstrated.
- A new interface may require compatibility evidence
- A safety partition may require independence evidence
- A performance claim may create instrumentation and test-environment requirements
- A reused component may reduce implementation effort while creating qualification, provenance, and applicability questions
- A design change may require regression evidence across layers that were not directly modified.
Systems engineering treats verification and validation as lifecycle processes, not merely final test activities. NASA’s systems engineering guidance, for example, places verification, validation, technical planning, configuration management, and decision analysis within an integrated lifecycle framework [Nat16]. That lifecycle framing is important because evidence obligations begin when decisions are made, even if their cost is paid much later.
A causal metric for verification burden should then ask
What evidence must be created, preserved, connected, and interpreted because this architectural decision exists?
Let
represent an architectural decision and let
represent the set of evidence obligations that follow from it. We might describe verification burden schematically as
![]()
where
represents the cardinality of the set.
Again, this is not a proposed universal formula. It identifies causal dimensions that a useful metric might preserve. Verification burden may include
- The number and diversity of claims requiring evidence
- The number of layers across which traceability must be maintained
- The difficulty of creating a representative environment
- The cost of reproducing or refreshing evidence
- The regression reach of future changes
- Dependence on scarce facilities or expertise
- The number of assumptions that must remain valid
- Certification or qualification consequences
- The degree to which prior evidence remains reusable.
Evidence is not always durable.
- A test result may remain historically true but become insufficient for a new decision
- A simulation may no longer represent the operating environment
- A qualification may not transfer to a changed supplier, material, interface, or mission profile
A verification artifact can therefore persist while its usability for decision-making value decays.
Verification burden is not simply the amount of testing left to perform. It includes the architecture required to keep evidence meaningful. This produces several possible dynamic measures
![]()
where
denotes the change in verification burden caused by decision
.
This can reveal tradeoffs that implementation metrics conceal. A decision may reduce development effort while sharply increasing future evidence obligations
![]()
Calling the decision “cheaper” would then depend on which locality and timescale are being observed.
Verification burden also couples to CCC and TTD
![]()
The purpose of measuring verification burden is not to reward the production of more artifacts. It is to diagnose whether the architecture has created evidence obligations that the organization can actually sustain.
Option Entropy: The Condition of the Future Frontier
The fourth metric concerns future possibility.
Architecture is not only a description of what has been decided. It also shapes what remains possible.
At any point in the causal present, there may be several plausible future paths.
- Some are genuinely distinct
- Some differ only superficially
- Some remain technically feasible but have lost organizational, financial, regulatory, or temporal viability
- Some appear open because no formal decision has closed them, even though accumulated commitments have made them practically inaccessible
The relevant causal question is
What plausible architectural futures remain, and how is the frontier changing?
Information theory provides the familiar entropy expression
![]()
originally developed to characterize uncertainty in communication [Sha48]. We can use this architecturally but must be cautious in how we interpret the expression. Architectural options are not symbols emitted by a stationary source, and assigning probabilities to them may be difficult or misleading.
Still, entropy offers a useful conceptual language for describing the diversity and distribution of remaining futures.
A schematic option-entropy measure might be
![]()
where
is the current frontier of plausible architectural futures.
The metric is useful only if the frontier has been constructed meaningfully. Counting nominal alternatives is not enough. A causal option metric should consider
- Whether the alternatives are genuinely distinct
- Whether they remain feasible under current constraints
- Whether their enabling assumptions still hold
- Whether required evidence can still be produced
- Whether the organization retains the capability to pursue them
- Whether prior decisions have already placed them outside the reachable future
- Whether multiple alternatives are merely coarse representations of the same underlying path
This is where option entropy differs from a simple option count.
Five nominal options may contain less real future diversity than two well-supported, causally distinct alternatives.
Engineering design research has long emphasized that flexibility has value under uncertainty because designs that preserve the ability to adapt can respond to futures that cannot be predicted precisely [dNS11]. Herbert Simon likewise described design as a search for satisfactory arrangements within bounded conditions rather than as a simple discovery of a uniquely optimal state [Sim96]. A causal option metric extends these ideas by asking how architectural decisions reshape the reachable frontier itself.
The rate of frontier contraction matters,
, but the sign of that derivative is neither good nor bad.
A declining option entropy may indicate disciplined convergence. The same decline may also indicate premature collapse.
An option can disappear because evidence ruled it out, because a deliberate decision selected another path, because time expired, because an upstream assumption was silently frozen, or because increasing TTD made the option unaffordable.
The numerical direction is the same. The causal meaning is not. This is why the metric must preserve the reason that the frontier changed.
A useful diagnostic should distinguish between evidence-driven pruning, commitment-driven convergence, constraint-driven loss, debt-driven foreclosure, and representation-driven collapse.
Option entropy also interacts with verification burden. In some contexts, maintaining more options can increase the evidence needed to compare them
![]()
Conversely, premature convergence may initially reduce verification activity while sharply increasing the burden of proving or correcting a poorly chosen commitment later.
No single direction is always preferred.
The important architectural question is
Is the future closing at the right rate, for reasons the organization understands, while preserving the options that remain causally valuable?
The Metrics Form a Diagnostic Family, Not a Score
The four metrics can now be written schematically as a diagnostic vector
![]()
This notation does not mean that the components should be normalized, weighted, and summed.
Indeed, a composite score such as
![]()
would usually destroy much of the meaning the causal approach was intended to preserve.
A high value in one component cannot be interpreted without context.
- High CCC may reflect unnecessary burden, or an inherently difficult but well-managed locality
- High TTD may be stable and understood, or small TTD may be accelerating rapidly
- High verification burden may indicate poor design, or the necessary consequence of a high-assurance mission
- High option entropy may preserve resilience, or reflect failure to converge.
The components also depend on different arguments
![]()
where
is time,
is locality or layer,
is the agent, and
is resolution.
Not every metric depends equally on every argument, but the notation reminds us that architectural quantities are rarely global and context-free.
More importantly, relationships among metrics can reveal conditions that no component shows alone.
For example
![]()
might indicate that a team has made its immediate work easier by exporting burden into the future.
Likewise
![]()
might indicate disciplined convergence toward a high-assurance solution, or premature commitment to a path with escalating evidence obligations.
The metric values do not settle the interpretation. They identify a causal condition that must be investigated.
A Generative Method for Causal Metrics
The point of these examples is not to establish a final list of architectural measures. The point is to demonstrate a method.
For any architectural concern, we can ask
- What causal condition are we trying to understand?
- Which events, decisions, agents, layers, or future states participate in that condition?
- What distinctions must be preserved for the metric to remain meaningful?
- Where is the condition localized?
- At what resolution does it become visible?
- How does it change with time?
- What other burdens or possibilities does it interact with?
- What apparent improvement might merely represent relocation, compression, or delayed consequence?
This produces an open family of possible metrics.
Other causal questions might lead to measures of
- Representation fidelity
- Cross-layer transmission fidelity
- Decision-memory recoverability
- Governance latency
- Overlap persistence across resolution
- Architectural roughness
- Join burden
- Convergence rate
- Invariant survival
- Movement of debt and complexity among localities.
Those metrics will be considered in Part II.
The important conclusion here is that a causal approach to architecture offers many causally distinct things to measure.
We do not need to begin with a score and search for meaning afterward. We can begin with the architectural question, identify the causal relation that gives it meaning, and then construct a metric that preserves that relation as far as the available evidence allows.
The resulting metrics will not reduce the architecture to one number.
They will give us multiple, disciplined ways to ask what the architecture is doing to the people who act within it and to the futures that remain possible.
References
[Cun92] Ward Cunningham. The WyCash portfolio management system. In Addendum to the Proceedings on Object-Oriented Programming Systems, Languages, and Applications, pages 29–30. ACM, 1992.
[dNS11] Richard de Neufville and Stefan Scholtes. Flexibility in Engineering Design. MIT Press, Cambridge, Massachusetts, 2011.
[KNO12] Philippe Kruchten, Robert L. Nord, and Ipek Ozkaya. Technical debt: From metaphor to theory and practice. IEEE Software, 29(6):18–21, 2012.
[Nat16] National Aeronautics and Space Administration. Nasa Systems Engineering Handbook. Technical Report NASA/SP-2016-6105 Rev2, NASA, Washington, DC, 2016.
[Sha48] Claude E. Shannon. A mathematical theory of communication. Bell System Technical Journal, 27(3):379–423, 1948.
[SHG+15] D. Sculley, Gary Holt, Daniel Golovin, Eugene Davydov, Todd Phillips, Dietmar Ebner, Vinay Chaudhary, Michael Young, Jean-François Crespo, and Dan Dennison. Hidden technical debt in machine learning systems. In Advances in Neural Information Processing Systems, volume 28, pages 2503–2511, 2015.
[Sim96] Herbert A. Simon. The Sciences of the Artificial. MIT Press, Cambridge, Massachusetts, 3 edition, 1996.
[Sof22] Software Engineering Institute. 10 years of research in technical debt and an agenda for the future. https://www.sei.cmu.edu/blog/ 10-years-of-research-in-technical-debt-and-an-agenda-for-the-future/, 2022. Carnegie Mellon University.
Leave a Reply