Standard : Manual Intervention Rate in Pipelines

Description

Manual Intervention Rate in Pipelines measures the proportion of delivery pipelines that require human input, overrides, or remediation before code or infrastructure can progress through build, test, or deployment stages. This includes approvals, failed tests requiring manual reruns, or environment configuration steps.

This metric helps identify sources of operational friction and delivery waste caused by incomplete automation, unclear policies, or fragile processes.

How to Use

What to Measure

  • Count of pipeline runs that required manual action during execution (e.g. approval gates, retries, environment changes).
  • Total number of pipeline runs over the same time period.

Formula

Manual Intervention Rate (%) = (Pipelines with Manual Steps / Total Pipeline Runs) × 100

Segment by:

  • Stage (build, test, deploy)
  • Cause (e.g. approval, misconfig, failed job)
  • Team or service

Instrumentation Tips

  • Use CI/CD tools (e.g. GitHub Actions, Azure DevOps, GitLab) to log manual steps.
  • Tag runs that include manual, approval, or rerun events.
  • Track retries and skipped steps as indicators of process fragility.

Why It Matters

  • Eliminates bottlenecks: Manual steps delay flow and increase queue times.
  • Improves consistency: Automation removes variability and reduces defects caused by human error.
  • Increases velocity: Fully automated pipelines accelerate value delivery.
  • Strengthens confidence: Automated pipelines give engineers the confidence to release frequently and safely.

Best Practices

  • Replace approval gates with automated policy checks (e.g. static analysis, security scans).
  • Use infrastructure as code (IaC) to standardise environment creation.
  • Implement pipeline failure pattern analysis to address repeat causes.
  • Introduce dry-run and preview tools to reduce the perceived risk of automation.

Common Pitfalls

  • Mistaking necessary approvals (e.g. regulated environments) as avoidable waste without understanding context.
  • Over-automation without visibility, leading to opaque failures.
  • Lack of feedback loops from teams about why manual steps persist.
  • Failing to distinguish between pipeline design and actual runtime friction.

Signals of Success

  • Manual steps are reduced or eliminated from standard paths.
  • Approvals are data-driven and automated where possible.
  • Time from commit to deploy shrinks as automation improves.
  • Engineers trust pipelines and do not feel the need to “watch over” releases.
  • [[Lead Time for Change]]
  • [[Pipeline Reliability Score]]
  • [[Build Success Rate]]
  • [[Change Failure Rate]]
  • [[Policy Adherence Score]]