Process Depth or Metric Breadth? How to Choose Without Losing Clarity

You're looking at a dashboard that tells you everything about nothing. Or a deep-dive report that tells you everything about one thing—and nothing about the rest. That's the process depth versus metric breadth dilemma, and it hits every automation team somewhere between month six and year two.

I've sat through enough quarterly reviews where the operations lead presents thirty metrics and the exec says, 'So what do we fix first?' And I've also been in the room where a team spent three months optimizing a single workflow only to discover the bottleneck had moved upstream. The problem isn't depth or breadth alone—it's losing sight of what operational clarity actually means: can your team, in under ten minutes, point to the one metric that matters most right now? If not, you've already made a choice by default. This article lays out the decision frame, compares the options, and gives you a way to pick without trashing the clarity you already have.

Who Has to Choose—and by When?

It Happens Between Sprints

The decision doesn't land on your desk with a memo. It arrives as a slack thread—three ops leads, one automation architect, and a program manager who just returned from a vendor demo. Someone wants to track every step of the CI/CD pipeline. Someone else argues for a single DORA metric.

A mentor explained that however polished the dashboard looks, the pitfall is skipping the failure rehearsal that would have caught the silent assumption on day one.

When the same sentence length repeats for a whole chapter, readers feel the template even if every claim is true, so break the rhythm on purpose.

Both have charts. Neither is wrong yet.

When the same sentence length repeats for a whole chapter, readers feel the template even if every claim is true, so break the rhythm on purpose.

It adds up fast.

That conversation is the decision point. Automation maturity doesn't announce itself; it surfaces in the gap between "we should measure more" and "we already measure too much." I have watched teams stall for two quarters because no one realized they were already past the fork.

The People Who Actually Own This Call

The ops lead owns the cost of sprawl—too many dashboards, too many alerts that behave like noise. The automation architect owns the integrity of the pipeline; she can't afford a metric that hides a flaky deploy behind a green check. The program manager owns the narrative that gets reported upward. Three roles, three different thresholds for "enough." The catch is that none of them alone can kill a bad metric. It takes a coalition. The odd part is—most teams skip forming that coalition until the review cycle, when the damage is already baked into the slide deck.

• Operations lead: breathes the cost of monitoring fatigue
• Automation architect: sees where breadth masks depth gaps
• Program manager: translates metrics into budget decisions

Why Waiting Until Next Quarter Is Too Late

The typical review cycle is twelve weeks. That's enough time for a bad breadth decision to normalize itself as "how we've always measured." Once the dashboard is green and the exec deck uses the same chart two quarters in a row, replacing that metric feels like admitting failure. I have seen teams burn three months collecting deployment frequency across sixty services—only to discover they had no idea whether any of those deployments actually worked. The time pressure is real: the decision must happen within the first two weeks of a new automation initiative, before the instrumentation becomes invisible infrastructure.

A mentor explained that however polished the dashboard looks, the pitfall is skipping the failure rehearsal that would have caught the silent assumption on day one.

“A metric that lands in week one and survives until week eight is almost never removed. It just becomes furniture.”

— Ops lead, after migrating 200 microservices to a unified pipeline

The trick is to declare your depth-versus-breadth stance before the first sensor is plugged in. Not after. Most teams reverse this order—wrong order, and it hurts.

Three Ways to Govern Your Metrics (and One That's a Trap)

Approach 1: Process decomposition—deep, narrow, high-resolution

You pick one end-to-end workflow—say, invoice-to-cash—and you instrument every seam. Handoffs between systems. RPA execution time per field. Number of human touches after the robot finishes. This is surgery, not an X-ray. The depth tells you exactly where the automation fails: the SAP connector slows at 2:15 PM every Tuesday because of a batch job collision. Fix that one thing and the entire process speeds up by 17%. The catch is visibility. You can't see the other six processes in the portfolio. If someone asks "How is our RPA doing overall?" you have no answer. That sounds fine until the board asks that exact question in a steering committee—and you pivot to a different approach entirely.

It adds up fast.

Most teams skip this: they decompose processes but set the depth too shallow. Three metrics per step, not fifteen. The result? You see the surface—robot ran or failed—but miss the accumulating latency in document queues. I have seen a team celebrate 94% execution success while a single handoff waited four hours for a third-party API that nobody had instrumented. Deep means uncomfortably deep. Wrong order? You lose a day per week on rework.

Approach 2: Balanced scorecard—medium depth, medium breadth

You pick a handful of dimensions—reliability, speed, cost, compliance—and pull one or two metrics per dimension across your automation portfolio. This is the Goldilocks zone for teams with fifteen to fifty automations running. You can say "Our average cycle time dropped 11% last month across all POs, but exception handling cost us four hours per robot." That's useful. But it's not precise. You won't know which robot is the culprit until you drill down—and the drill-down is manual. The trade-off bites when a single process degrades slowly. The balanced view shows green in all, so nobody digs. Three months later, that one robot has been running in a degraded state, costing 40 hours of cumulative manual rework. Nobody noticed because the averages looked fine.

What usually breaks first is the definition of "medium." Teams load twelve dimensions because each stakeholder wants their pet metric. Suddenly the scorecard is a dashboard with thirty tiles and nobody looks at it. We fixed this by hard-coding a rule: max four dimensions, max two metrics per dimension. You can always monitor more—but you can't report more. The discipline is the point.

Watershed crews keep phenology notes beside the camera-trap cards because absence is a process signal, not a missing checkbox on a template form.

Approach 3: Outcome-based metrics—broad, shallow, directional

This is for when you operate at scale—hundreds of automations—or when the automation function is still proving it belongs. You track outputs, not process mechanics. Hours saved. Transactions completed. Error rates post-automation. Staff redirected.

That's the catch.

That's three metrics covering everything. Broad as a barn door, shallow as a puddle. The odd part is—this often works better than deep instrumentation for the first eighteen months. Directional data is enough to say "yes, fund more automation" or "no, something is rotting." The pitfall is obvious: when something goes wrong, you have no map to find it. I have watched teams spend three weeks chasing a 0.3% error rate spike because they could only see it existed, not where it lived. That hurts.

Nebari jin moss stalls.

The rhetorical question here is simple: do you need to steer or to diagnose? If you're steering, breadth wins. If you're diagnosing, depth wins. Confusing the two is how companies spend six figures on a tooling stack that nobody actually uses to fix anything.

The trap: trying to track everything because 'we might need it later'

Metric hoarding. I have walked into rooms where the automation team tracks 147 metrics across 22 automations. Nobody can explain why ninety of those metrics exist. The origin story is always the same: "During implementation, the vendor suggested we capture this—just in case." That "just in case" becomes a permanent tax. Every sprint, someone updates 147 fields. The dashboards are unreadable. The team can't distinguish a signal from a noise because they have never pruned. The real cost is invisible: every hour spent logging a metric you never look at is an hour not spent improving a process that actually matters.

Odd bit about processing: the dull step fails first.

A mentor explained that however polished the dashboard looks, the pitfall is skipping the failure rehearsal that would have caught the silent assumption on day one.

Claim desks that separate intake verbs from appeal verbs stop copy-paste denials from looking like thoughtful casework under audit lights.

If you can't name the decision a metric supports within five seconds, you don't need that metric.

— rule we wrote on a whiteboard after a particularly painful quarterly review, context: the team had been tracking 'average queue depth per hour' for six months and nobody could say what the target should be

Hoarding looks harmless. It's not. It inflates operational overhead, obscures real patterns, and—worst of all—conditions the team to treat data collection as a compliance chore rather than a diagnostic tool.

Kill the silent step.

Claim desks that separate intake verbs from appeal verbs stop copy-paste denials from looking like thoughtful casework under audit lights.

You don't need a metric for every risk.

Heddle selvedge weft drifts.

Vendor reps rarely volunteer the maintenance interval; however boring it sounds, the calibration log is what keeps tolerance from drifting into customer returns.

You need a metric for every decision. Everything else is noise dressed up as diligence.

Five Criteria That Separate Useful from Noise

Decision latency — how fast can you act on the metric?

I once watched a team track over two hundred process metrics across four dashboards. Beautiful charts, endless green lights. Then a customer-facing pipeline broke at 9 AM — and nobody knew until the noon standup saw the anomaly buried in a weekly trend report. That nine AM break cost them roughly 400 transaction retries and a pissed-off client. The metric was technically correct. It was also useless.

Decision latency is the time between an event happening and a human (or automation) acting on its signal. If that gap exceeds your tolerance for damage — say, thirty minutes for a production deployment pipeline — your metric is noise. Full stop. I rank this criterion first because speed dictates everything else. A perfect, deeply granular cycle-time breakdown helps nobody if it lands two sprints late.

Pause here first.

The catch: low latency often tempts teams to measure trivial things — memory utilization spikes, retry counts — because those update fast. A dashboard that refreshes every ten seconds but shows useless hourly averages is still expensive garbage. Pair speed with proximity to actual outcomes.

Actionability — does the metric tell you what to change?

Most metrics fail here. They report the wound but don't gesture toward the knife. Consider “deployment failure rate is 12% this quarter.” Okay — and what do you do with that? Fire the deployment team? Revert every PR? Move to a different cloud?

'12% failure rate' is a headline, not a signal. A useful metric says 'the deploy validation suite missed the schema change again — add it to pre-commit hooks.'

— senior delivery lead, after reconstructing three broken releases

Actionable metrics expose which knob to turn. They name a specific input you can change today: “code review cycle time increased to 14 hours because the integration test environment was down for repairs.” Now you have an action — unblock the test environment — not an ambiguous angst target. I’ve seen teams treat “cycle time is up” as a general motivational slogan. It never works.

Kitchen teams that taste before they timer-chase report fewer spoiled jars, even when the recipe card looks identical to last season’s printout.

If you can't build a one-step action from the metric within thirty seconds of reading it, demote it. Put it in a secondary view. Save the headline slot for numbers that point a finger.

Learning feedback — does it help your team get better over time?

Actionability looks at now. Learning feedback asks whether the metric accelerates decisions six months from now. A deployment frequency graph that has stayed flat for four quarters might look boring — but the team realized they’d exhausted their infrastructure threading model, so they switched to a queue-based deploy strategy. The metric didn’t change; the understanding did. That’s learning feedback.

Weak learning signals hide in aggregated ratios. Strong ones surface failure modes: “This is the third time a flaky end-to-end test has masked a real regression in the billing module.” That pattern persists across velocity, error budget burn, or rework percentage. The tricky bit—most teams stop at the trend line and never ask “why does this trend exist?”. That hurts because you keep fixing the roof while the foundation cracks.

It adds up fast.

A quick heuristic: after reviewing the metric, can each team member write down one durable insight about their system? If only the manager can, your feedback loop is centralized — and fragile.

Alignment cost — how much effort to keep everyone on the same page?

This one surprises people. They pick a rich metric set — ten dimensions of lead time, eight categories of defect origin — and then spend three hours every Monday debating definitions. “Does 'deploy' mean pushed to production or available to users?” “Wait, is rework counted per ticket or per commit?” That alignment cost devours the very time you hoped to save. The metric exists to reduce friction; instead, it becomes friction.

Sparse, unambiguous metrics with single sources of truth beat elaborate taxonomies that require a glossary. If you have to explain the metric’s meaning to a new hire for longer than forty-five seconds, you have an alignment problem. Trim it. Or accept that your dashboard is actually a training manual disguised as a control panel.

However confident the first pass looks, the pitfall is usually an undocumented handoff that only appears when someone else repeats your shortcut without context.

That said — don’t strip context entirely. A perfectly flat “cycle time = 3 days” sounds clean until someone asks “is that good or bad?”. Great metrics carry a lightweight expectation, a relative target. “Cycle time = 3 days (target is under 5 for this quarter).” No debate needed.

Reality check: name the processing owner or stop.

Cut the extra loop.

Varroa nectar drifts sideways.

Trade-off: the fifth criterion nobody sees coming

I lied slightly. The fifth criterion isn’t a criterion — it’s a constraint: metric interaction cost. Every new metric adds implicit cross-referencing. “Throughput is up — does that explain why latency spiked?” The more metrics you carry, the harder it becomes to trace causal webs. What usually breaks first is the ability to answer “why did this number move last week but not this week?”. You accumulate breadth until your team can’t tell signal from coincidence.

Start with three. No, really — three. Deployment frequency, mean time to recover, change failure rate. That triad survives most shifts. Add breadth only when you can articulate what decision the new metric enables and what trade-off it introduces. A team using fewer metrics but acting faster always outpaces a team drowning in dashboards. I’ve seen it happen three times now. Each time, the metric-rich team looked impressive in slide decks. The lean team shipped.

Depth vs. Breadth: A Side-by-Side Comparison You Can Actually Use

The Framework: Three Approaches Mapped Against Five Filters

Let me show you what this looks like when you stop theorizing and start sorting. I have sat through too many meetings where someone waves a balanced scorecard template and calls it strategy. It's not. Below is a side-by-side that maps the three governing styles—process decomposition, balanced scorecard, and outcome-based—against the five criteria we just established. Read it as a lens, not a rulebook.

However confident the first pass looks, the pitfall is usually an undocumented handoff that only appears when someone else repeats your shortcut without context.

The table is honest in a way most frameworks are not. Process decomposition wins on action and diagnosis—you can point to a specific handoff that failed—but it chokes on alignment. Teams using it often optimize a single step while the whole pipeline stalls. Balanced scorecard, meanwhile, is the darling of boardrooms because it communicates beautifully. The catch is it communicates the wrong thing: a green KPI that hides three broken sub-processes.

When Each Approach Wins—and When It Falls Apart

Process decomposition owns the factory floor. I worked with a logistics team that tracked every conveyor-belt cycle to the millisecond. They could tell you exactly why a package missed a sort. That same system, however, produced a spreadsheet so thick the VP of operations stopped reading it. Too much depth kills clarity.

A mentor explained that however polished the dashboard looks, the pitfall is skipping the failure rehearsal that would have caught the silent assumption on day one.

Heddle selvedge weft drifts.

Balanced scorecard shines in quarterly reviews—executives love four boxes with arrows—but the moment you ask "why is customer satisfaction yellow?" the answer is always a shrug. Outcome-based metrics win when the goal is unambiguous: reduce churn by 15%. But that metric is mute on how .

A mentor explained that however polished the dashboard looks, the pitfall is skipping the failure rehearsal that would have caught the silent assumption on day one.

You hit the number or you don't. Wrong order. What usually breaks first is diagnosis.

Vendor reps rarely volunteer the maintenance interval; however boring it sounds, the calibration log is what keeps tolerance from drifting into customer returns.

'We switched to outcome-based metrics and finally got buy-in. Then we spent three months guessing why the number wasn't moving.'

— Engineering director, mid-market SaaS, after a retrospective

The pitfall is that each approach has a natural lifespan. Process decomposition works during a stability push. Balanced scorecard survives a reorg. Outcome-based metrics thrive when the strategy is dead simple. The moment complexity creeps in—new product line, regulatory shift, cross-team dependency—the seams blow out. One team I observed tried to bolt outcome metrics onto a process-decomposition dashboard. It looked like a car with two steering wheels.

The One Combination That Often Works (and Why It's Hard to Maintain)

Most teams I have watched finally land on a hybrid: three to five outcome-based top-line metrics, each supported by a single process-decomposition drill-down for the one area that keeps failing. Two layers. That's it. The top layer is for the board and the weekly stand-up. The bottom layer is for the engineer who needs to know whether the lag is in auth or database. This stack gives you breadth where it matters—strategic alignment—and depth where it hurts most. The odd part is how rarely teams maintain it. They start with strict discipline: outcome A is tracked via process B. Then someone adds a second drill-down. Then a third. Six months later the top layer is buried under twenty sub-metrics and the whole thing collapses into noise. The hybrid is powerful, but it demands a gatekeeper who says no. Most organizations don't have that person. They have a dashboard that tries to be everything—and ends up being ignored.

Kill the silent step.

So before you move to the next section—how to make your choice stick—ask yourself: can you name the single process you would drill into right now? If the answer is no, you're not ready for depth. If the answer is everything, you're not ready for breadth. Pick one seam. Fix it. Then decide if the rest deserves the same treatment.

Once You Pick, Here's How to Make It Stick

Start with one function—don't roll out to the whole org at once

Pick the team that already trusts you. Not the biggest department, not the one with the loudest complaints. I have watched three different automation leads try to blanket an entire company with new metrics on a Monday morning. By Wednesday, two of those initiatives were dead—buried under cross-team confusion and the inevitable "but our process is different" protests. Start with one function: order-to-cash, maybe, or a single DevOps pipeline. Let them live with the chosen depth-or-breadth frame for six weeks before you even mention a wider rollout. The constraint hurts at first. That's the point. A narrow pilot forces you to learn what breaks before the rumor mill does.

What usually breaks first is the data pipeline—not the metric logic. You'll discover logging gaps, inconsistent timestamps, or a critical handoff nobody documented. Fix those in one function, not twelve. Wrong order? Trying to retrofit breadth across a mess of silence.

However confident the first pass looks, the pitfall is usually an undocumented handoff that only appears when someone else repeats your shortcut without context.

Pick a primary frame and stick with it for at least three months

The temptation to recalibrate after two weeks is almost magnetic. Someone sees a dip in cycle time and whispers "maybe we should also track code churn." No. You chose depth or breadth for a reason—commit to the frame until you have three months of trend data. Three months is the minimum to separate signal from a bad Tuesday. I have seen teams pivot twice in a quarter and end up with a dashboard nobody trusts: ten metrics, no baseline, every number contradicted by the last. A single lens, held steady, begins to show patterns. That's worth more than five "improved" dashboards that die on arrival.

The catch: three months feels like an eternity when your VP asks "why isn't automation saving us money yet?" Hold the line. Explain that premature switching guarantees confusion. One rhetorical question for your own sanity—can you name what changed because of a metric in under two weeks? Probably not. Patience is the mechanism, not a virtue.

Assign ownership: someone owns depth, someone owns breadth

If you picked depth—someone needs to own that single process end-to-end. Not "monitor it." Own it. That person wakes up asking what the five-step cycle time tells them about Tuesday's failure. If you picked breadth—different person. That one owns the surface area: coverage gaps, adoption rates, the health of all twenty pipelines at a glance. Split ownership because no single human can do both well. I have tried. The result is a dashboard that shows everything and explains nothing.

Not always true here.

Field note: claims plans crack at handoff.

Vendor reps rarely volunteer the maintenance interval; however boring it sounds, the calibration log is what keeps tolerance from drifting into customer returns.

'We kept adding metrics until the ops lead said "I have no idea what I'm supposed to fix first." That was the moment we split the role.'

— senior automation architect, after a year of overcorrection

These two owners meet weekly for exactly thirty minutes. Their job: check whether the depth owner's findings contradict the breadth owner's coverage. If a deep process shows improvement but the breadth scan reveals five new downstream failures, you have a handoff problem—not a metric problem. That disagreement is your next real constraint.

Set a review cadence—and a rule for when to pivot

Monthly reviews. Not weekly—that's noise. Not quarterly—that's too slow for automation where one deployment reshapes the landscape. The monthly review asks three questions: (1) Did this metric help us decide anything? (2) Is the data still clean?

So start there now.

(3) Do we trust it more or less than last month? The rule for pivoting: you change the frame only after two consecutive reviews show the metric is flat and the owners agree it no longer shapes a decision. Not before.

Operators we shadowed described three distinct failure modes — mis-threaded tension, skipped press tests, and unlabeled batches — each preventable when someone owns the checklist before the rush starts.

Flat but useful stays.

Watershed crews keep phenology notes beside the camera-trap cards because absence is a process signal, not a missing checkbox on a template form.

Active but confusing stays. Only dead-and-irrelevant gets swapped.

Most teams skip the "useful versus active" distinction. That's where the trap hides. A metric that moves every week but yields no action is just theater. Kill it. Replace it with something that pinches when it breaks. The review cadence protects you from the slow drift back to metric sprawl—depth becomes too narrow, breadth becomes too shallow. A thirty-minute monthly check keeps the frame tight without needing to redesign everything from scratch. That's how you make it stick: not by perfecting the first choice, but by refusing to abandon it until you have proof it earned the right to change.

What Goes Wrong When You Choose Wrong (or Don't Choose at All)

Metric fatigue and dashboard blindness

I walked into a control room once—twenty-three screens, each showing a different automation metric. The operations lead pointed at a green bar and said, 'That one’s fine.' He had no idea what it measured. That's dashboard blindness: you collect so many numbers that none of them actually inform a decision. The team spent three hours every Monday updating a master spreadsheet. Nobody read it. The catch is—this feels productive. You're building something. But breadth without filtering creates noise, and noise breeds indifference. Soon, even the good metrics get ignored.

Recovery is brutal but simple: kill 60% of your dashboards tomorrow. Not archive them. Delete. I have seen teams protest this, then realize they only needed five metrics to run the line. The rest was decoration.

False precision from over-modeled processes

The opposite trap is depth so deep it becomes fiction. A manufacturer in Ohio modeled every sub-step of their assembly robot—cycle time, grip force, ambient humidity correction. The model predicted 99.7% uptime. The actual line stopped twice a week. Why? The model assumed perfect parts feeding, which never happened. That's false precision: your metric says 2.1 seconds per cycle, but the real bottleneck is the human waiting for parts ten feet away. Wrong order.

Over-modeling gives you confidence, not accuracy. You optimize the sub-process you can measure, ignore the one you can't, and the system degrades. Recovery means going back to the floor.

When throughput doubles without a matching documentation habit, however skilled the crew, the pitfall is invisible rework spent on heroics instead of repeatable steps.

Watch the workflow for an hour. What breaks first?

Varroa nectar drifts sideways.

That's your real metric. Ditch the rest.

'We measured packing speed to the millisecond. The warehouse still shipped late. We forgot to measure whether the boxes had labels.'

— Engineering lead, midwest logistics firm

Silo blindness and the cost of switching

Depth and breadth share one common failure: they let you optimize a seam while the whole garment rips. I saw a company double down on picking accuracy—99.98%—while order consolidation times tripled. The warehouse team hit their number. The customer still got the wrong mix of boxes. Silo blindness happens when your metric belongs to one department and nobody owns the handoff. The picking team had no incentive to care about consolidation. That hurts.

Switching from one approach to the other mid-stream costs real money. Retraining, dashboard rebuilds, lost history. But here is the thing—you rarely need to start over. Most teams recover by keeping their existing system and adding one cross-functional metric at the seam where processes touch. A single 'order complete to customer wait' number trumps twelve detailed sub-metrics every time. Choose that first, then decide if you need more depth or more breadth. Not yet? Good. You have time. Make the wrong call and you lose a day. Make no call and you lose the month.

Frequently Unasked Questions About Metric Depth vs. Breadth

How many metrics is too many?

Seven. I have seen teams slap thirty KPIs on a dashboard and call it 'automation governance.' Then nobody looks at it. The real limit is cognitive—your team can hold roughly seven metric relationships in working memory before each one becomes noise. Past twelve, you're not measuring anymore; you're decorating. The catch: this assumes you're actually reading them weekly. If you check quarterly, three or four is the ceiling. What usually breaks first is attention, not storage. A client once tracked twenty-two metrics and could not tell me which two predicted their biggest failure—that hurts.

When should you switch from depth to breadth (or vice versa)?

When the repeatable breaks. Depth is for stable processes where you understand cause and effect—five layers deep into one order-to-cash cycle. You stay there until the error rate plateaus below 2% for three months. Then you add breadth: a second metric family from procurement or service desk.

According to field notes from working teams, the boring baseline check prevents more failures than a brand-new framework introduced mid-sprint under pressure.

The trigger to switch back is simpler: any single metric goes red and you can't explain why. That means your depth is too shallow, or your breadth has diluted the signal.

It adds up fast.

I usually tell teams: dig until the root cause stops moving, then look sideways. Wrong order? You get a wide, pretty surface with nothing underneath—looks like progress, collapses on Monday.

Breadth without depth is a mirror. Depth without breadth is a tunnel. You need both, just not at the same time.

— operations lead, after killing their 40-metric dashboard

How do you avoid analysis paralysis during the choice?

Stop choosing. Pick one process, one metric family, and commit for six weeks—not six months. Paralysis comes when teams debate 'optimal' instead of 'good enough.' The tactic I use: set three criteria from section five of this post (lag correlation, human effort to collect, decision gap) and if a metric passes all three, it's in. If it passes two, conditional approval—but only one conditional per round.

According to field notes from working teams, the boring baseline check prevents more failures than a brand-new framework introduced mid-sprint under pressure.

Most teams skip this: they treat the choice as permanent. It's not. You can swap breadth for depth in a Tuesday morning standup. The odd part is—once you de-risk the decision, nobody hesitates.

What's the single best indicator that your choice is working?

Someone outside the automation team quotes a metric unprompted. Not the dashboard owner, not the manager who demanded the report—someone in procurement or support who says 'our cycle time dropped last week because that reject rate finally moved.' That is the signal. Not uptime percentages, not count of automated steps. If the metric changes how a non-expert acts, your depth-or-breadth choice is alive. If it gets mentioned only in the monthly slide deck, it's decoration. Returns spike when a metric connects to a real pre-mortem. A trivial test: after the next incident, ask three people what changed first. If they name the same metric, you chose right. If they shrug, you chose wide but shallow—revisit.