Dev / QA Team Load — Management View

How much work your team actually absorbs vs. how much it's being pointed for. Everything is expressed in units management can act on: stories, hours, dollars, headcount. The underlying math uses Weinberg's context-switching decay and a coverage-gap escape tax; you don't need to see it to read the summary.

Sprint: 2 weeks (80h / person)
Context-switch penalty: c = 0.5 (Rubinstein/Meyer/Evans 2001; Weinberg 1992)
Escape-tax factor: 0.4 (per point of coverage gap)
Escape defect rate: 0.30 / story × (1 − cov) (author's estimate — see Sources)
Team & Sprint
7
4
9
10
Effort per Story
5
2
3
The gap between these two is the hidden load QA absorbs invisibly. Includes E2E authoring, exploratory testing, regression re-runs, defect verification.
Quality & Focus
25%
Context-switch penalty: fixed at c = 0.5. This is a property of human cognition, not a team knob — Rubinstein/Meyer/Evans (2001) measured ~40% throughput loss when switching between two tasks, and Weinberg (1992, p. 284) documented harsher decay for more concurrent projects. Both fit eff(n) = 1 / (1 + 0.5·(n−1)).
Cost & Risk
$180k
Typical US range: $140k–$250k (salary × ~1.3 for benefits/overhead). Adjust to your market.
$140k
Typical US range: $110k–$180k (~75% of dev, industry ratio).
$8k
Wide range: $2k routine bug → $50k+ major outage. Gartner (2014) cited $5,600/min downtime; Atlassian ITSM reports $300k+ for enterprise outages. Placeholder — set to what your incidents actually cost.

Management Summary

What would fix this?

Each button applies the intervention to the current model and shows the ROI. Click a button to see the numbers change everywhere; click Reset defaults to return.

Value Stream — where the work flows

Left to right: work enters as stories, flows through Dev, queues waiting for QA, gets verified, deploys. Queue triangle grows when QA can't keep up — its dollar figure is real money sitting idle every sprint.

Hours of work per person per sprint

Productivity vs concurrent workstreams

Effective output per person as they juggle more parallel work (Weinberg 1992). The role markers show where each of your team members currently sits.

Load per person — as stories per sprint scale

Vertical dashed markers show each role's knee (Reinertsen 2009): the story-count where they cross 100% and the non-linear penalty kicks in. Commit fewer than the earlier of the two knees per sprint or QA drowns.

Sources & assumptions

Where every number comes from — expand for full audit trail

Cited (peer-reviewed or industry standard)

  • Context-switch penalty c = 0.5, form eff(n) = 1/(1 + c·(n−1)). Rubinstein, Meyer & Evans (2001), J. Experimental Psychology: HPP 27(4) — measured ~40% throughput loss on 2-way task switching. Weinberg (1992), Quality Software Management, Vol. 1, p. 284, table of simultaneous-project time loss.
  • Knee concept — Donald Reinertsen (2009), Principles of Product Development Flow. The workload where the effective-load curve steepens sharply.
  • Value Stream Map layout — Mike Rother & John Shook (1998), Learning to See; adopted for DevOps in Jez Humble & David Farley (2010), Continuous Delivery.
  • Escape-tax factor 0.4 — informed by Capers Jones' defect-removal-efficiency data (multiple editions of Applied Software Measurement). The specific 0.4 is calibrated so 25% coverage produces a defensible ~30% workload inflation; not directly cited.

Author's estimates (adjust if your data disagrees)

  • Escape defect rate 0.30 × (1 − coverage) defects per story per sprint. No citation. This is a Fermi estimate. If your team measures actual escape defects, plug in your real value by adjusting BASE_DEFECT_RATE in the source.
  • "Raise coverage to 60%" scenario cost — 6 months of one dev's fully-loaded cost. Order-of-magnitude; real cost depends on codebase size, test infrastructure maturity, and how much refactoring is needed to make the code testable.
  • Shift-left scenario — assumes +2 dev pts/story and −3 QA actual pts/story. Directionally correct if devs take over E2E authoring; magnitude depends on how much of QA's actual effort was E2E vs. exploratory.

Cost defaults (you can and should adjust)

  • Dev cost $180k/yr — US mid-market senior dev, salary $130–150k × ~1.3 for benefits/overhead. Ranges $140k–$250k in practice; higher in tech hubs, lower in secondary markets or offshore.
  • QA cost $140k/yr — ~75% of dev, industry norm. Ranges $110k–$180k.
  • Incident cost $8k — placeholder for "typical bug reaches production." Gartner (2014) cited $5,600/min average downtime cost; Atlassian ITSM reports enterprise averages of $300k+. Use your own postmortem data if available.

Uncertainty bands on KPIs

  • Hidden pointing gap: ±30% — driven by QA cost uncertainty alone (the pointing gap itself is directly from your sliders).
  • Overload waste: ±50% — QA cost + context-switching model uncertainty compounded.
  • Escape defect count: ±50% — driven by the BASE_DEFECT_RATE guess.
  • Escape defect $: ±75% — defect count × incident cost, both wide.

The model's structural argument (context switching is non-linear; hidden QA pointing gaps compound; low coverage escapes downstream) is defensible against the cited sources. The specific dollar totals are Fermi estimates, not audits. Present to management with the ranges attached.