ARCHITECTURE DEBT VISIBILITY RATIO (ADVR)

GMI-IT-060IT OperationsResearch-Forward

Definition

Architecture Debt Visibility Ratio (ADVR) measures the share of architecture-level technical debt identified by independent review that is actually present in the team's engineering backlog.

The Measurement Gap

A digital products company tracks technical debt in their engineering backlog. The team uses a code quality platform that scans repositories and surfaces code-level debt: outdated dependencies, complexity hot spots, low test coverage, code smells. The platform's quarterly debt report shows the debt being paid down steadily. Engineering leadership cites the debt program as a maturity strength.

Then a senior architect conducts an independent review of the platform's architecture as part of a quarterly architecture review. The review surfaces concerns the code quality platform did not flag: the customer service and billing systems have implicit coupling through a shared message queue with no contract definition, three different services maintain their own copy of customer state with no reconciliation strategy, the payment processing module has accumulated five different ways to invoke the same downstream API across different code paths, and the search infrastructure is dependent on a deprecated third-party library that the team plans to remove but has no migration plan for. The review's debt list has 14 items. The team's backlog has 4 of them.

The 10 missing items are architecture-level: wrong service boundaries, missing abstractions, implicit dependencies, accumulated workarounds. None of them are detectable by a tool that scans code files in isolation. Each one is detectable by a human who reads across the system and asks structural questions. The debt program has been paying down measurable code debt while invisible architecture debt has been accumulating.

The legacy debt metrics report a healthy program.

Code debt score: declining quarterly.

Backlog debt items: tracked and prioritized.

Debt paydown velocity: meeting quarterly targets.

Test coverage: trending up.

Static analysis findings: declining.

Code complexity hot spots: addressed quarterly.

Dependency freshness: in target range.

None of these report on architecture-level debt. The metrics measure what the code quality platform can scan, which is code-level. Architecture-level debt (wrong boundaries, missing abstractions, implicit coupling) is invisible to file-scanning tools and is also invisible to the backlog because nobody added it.

These metrics were designed when architecture review was a regular practice and the architect's findings made their way into the backlog as a matter of course. With cloud-native development at pace, architecture review has become less regular in many organizations, and the link from architect to backlog has weakened. The code-level debt is measured because tools measure it; the architecture-level debt is unmeasured because the discipline that would surface it has been deprioritized.

There is no metric that tells you the ratio of architecture-level technical debt to code-level technical debt, which means teams pay down measurable code debt while unmeasurable architecture debt compounds.

Formula

Architecture Debt Visibility Ratio (ADVR) measures the share of architecture-level technical debt identified by independent review that is actually present in the team's engineering backlog.

In plain language: have an independent architecture reviewer identify architecture-level debt items. Check the team's backlog for those items. ADVR is the percentage of independently-identified items that are also in the backlog. A high value means the team's backlog captures most of the architecture debt. A low value means the backlog is missing significant architecture debt that no one is planning to address.

The formula:

ADVR = Arch_debt_in_backlog / Arch_debt_identified × 100

Where:

  • Arch_debt_in_backlog = the count of architecture-level debt items present in the engineering backlog
  • Arch_debt_identified = the count of architecture-level debt items identified by independent architecture review

Units are a percentage from 0 to 100. 100% means all identified architecture debt is tracked in the backlog.

A worked example. The digital products company runs ADVR after the independent architecture review:

  • Independent review identified 14 architecture-level debt items
  • Backlog contains 4 of those 14 items as tracked debt
  • 10 items identified by review are not in the backlog

ADVR = 4 / 14 = 28.6%

Per the catalog guidance (above 60% captures most, below 30% majority invisible) this ADVR of 28.6% is below the action threshold. The team needs to add the 10 missing items to the backlog, schedule quarterly architecture reviews, and treat architecture debt as a distinct category in backlog grooming.

Three edge cases need explicit treatment. First, define what counts as "architecture-level" debt before the review starts: typical examples include wrong service boundaries, missing abstractions, implicit coupling, accumulated workarounds for foundational decisions, deprecated dependencies that affect multiple services, and inconsistent patterns for the same problem. Items that are code-level (specific function complexity, single-file refactoring) should not count toward ADVR. Second, use multiple independent reviewers and count items identified by 2+ reviewers; single-reviewer findings produce noisier ADVR. Third, review frequency: semi-annual is realistic for most organizations, quarterly is preferred but requires sustained architect time.

Cross-references. Downstream of ADVR is

Effort Estimation Anchoring Bias Index (EEABI): projects whose effort estimates are systematically low often have hidden architecture debt that surfaces during execution and inflates the actual effort.

Proposed formula, pending validation pilots.

At a Glance

Category
AI-Era IT Operations
← Arbitrage Concentration Risk (ACR)Authentication Friction Accuracy (AFA) →

Assess Your Organization

The AI-GPS Assessment evaluates your AI governance maturity and recommends KPIs like this one for your implementation roadmap.

Take the Free AI-GPS Assessment