Test Estimation Techniques: WBS, Three Point PERT and Monte Carlo
Test estimation turns “how long will testing take?” into a number you can defend. We break a real release into a work breakdown structure, estimate each task with three point PERT, add up the uncertainty, check it with a 100,000-run Monte Carlo simulation, and compare it with quick rules of thumb. Every figure below was calculated, not guessed.
- Test estimation works best bottom-up: split the work with a WBS, then estimate each task with optimistic, most likely and pessimistic values.
- Our eight-task release came to 114.5 hours by PERT, with a 95 percent range of about 98 to 131 hours.
- Adding up only the most likely values gave 106 hours, and the simulation finished within that just 4.1 percent of the time.
- Rules of thumb (25 or 40 percent of development effort) gave 100 and 160 hours: useful for a sanity check, not a plan.
Every test lead is asked the same question at the start of a release: how long will testing take? A single number pulled from experience is easy to give and hard to defend when things slip. Test estimation techniques replace that guess with a structured calculation that shows where the time goes and how uncertain it is.
We use one worked example throughout: a release with 400 hours of development effort, about 120 test cases, and a team that has done similar work before. The calculations ran in Python 3.13.6 with the standard library; you can reproduce them in any spreadsheet.
What is test estimation?
Test estimation is the process of predicting the effort, time and cost needed to complete testing activities: planning, test design, environment setup, execution, defect retesting, regression and reporting. A good estimate gives a range, not just a number, and lists the assumptions behind it so that when the scope changes, everyone can see why the estimate must change too. It is a key input to the test plan.
What drives a test estimate
- Scope and complexity: number of features, integrations, platforms and browsers.
- Risk: high-risk areas need deeper testing, as described in risk-based testing.
- Team experience with the product and the tools.
- Environment and data: availability of test environments and realistic test data.
- Expected defect rate: every bug found means investigation, reporting and retesting.
- Automation: existing automated suites shrink regression time; building new ones adds time up front.
Step 1: break the work down (WBS)
A work breakdown structure splits testing into tasks small enough to estimate with confidence, ideally between half a day and a few days each. Following the phases of the software testing life cycle keeps anything from being forgotten. Our release has eight tasks:
- Review requirements
- Write test cases
- Prepare test data
- Set up the test environment
- Execute tests (cycle 1)
- Log and retest defects
- Regression run
- Test report
Tasks people often forget: environment setup, test data, defect retesting and the regression run after fixes. Leaving them out is the single biggest cause of underestimates.
Step 2: estimate each task with three point PERT
For each task, ask for three numbers in hours: optimistic (O, everything goes right), most likely (M) and pessimistic (P, realistic bad case, not a disaster). The PERT formula weights the most likely value four times:
PERT estimate E = (O + 4M + P) / 6
standard deviation SD = (P - O) / 6
| Task | O | M | P | PERT | SD |
|---|---|---|---|---|---|
| Review requirements | 4 | 6 | 10 | 6.3 | 1.00 |
| Write test cases | 16 | 24 | 40 | 25.3 | 4.00 |
| Prepare test data | 6 | 8 | 16 | 9.0 | 1.67 |
| Set up environment | 4 | 8 | 24 | 10.0 | 3.33 |
| Execute tests (cycle 1) | 20 | 28 | 44 | 29.3 | 4.00 |
| Log and retest defects | 10 | 16 | 32 | 17.7 | 3.67 |
| Regression run | 8 | 12 | 20 | 12.7 | 2.00 |
| Test report | 3 | 4 | 6 | 4.2 | 0.50 |
Notice the shape of the numbers: pessimistic values sit much further from the most likely than optimistic ones. Environment setup could go from 8 hours to 24 if a dependency is late, but it can hardly go below 4. That skew is normal in real work, and it is why the PERT estimate for every task came out slightly above its most likely value.
Step 3: add up the estimate and its range
total PERT 114.5 SD 8.0 range 95pct 98.4 to 130.6
sum of most likely 106 sum optimistic 71 sum pessimistic 192
PERT estimates add up directly: 114.5 hours. Uncertainties do not; you add the variances (SD squared) and take the square root, which gave a total SD of 8.0 hours. Plus or minus two SD covers roughly 95 percent of outcomes, so the honest statement is “about 115 hours, very likely between 98 and 131”. Do not report the full 71 to 192 range: every task going best-case or worst-case at once is extremely unlikely.
Step 4: check it with a Monte Carlo simulation
import random
random.seed(3)
sims = sorted(sum(random.triangular(o, p, m) for _, o, m, p in tasks)
for _ in range(100000))
# monte carlo P50 122.7 P80 131.6 P90 136.3
A Monte Carlo simulation draws a random duration for every task, within its O to P range and peaking at M, adds them up, and repeats 100,000 times. Sorting the totals gives percentiles: half of the simulated releases finished within 122.7 hours, 80 percent within 131.6, and 90 percent within 136.3.
Why is the simulated median about 8 hours higher than the PERT total? We used a triangular distribution, whose average is (O + M + P) / 3. It gives the long pessimistic tail more weight than PERT’s formula, and its average here was 123.0 hours, matching the simulation. Neither model is “right”; they bracket the answer. Many teams quote the P80 value as a commitment, because it leaves room for the bad surprises that always appear.
The most likely trap
chance of finishing within the sum of most likely values: 4.1 pct
This is the most important number in the article. If you ask each person for their most likely value and simply add them up, you get 106 hours, and in our simulation the work finished within 106 hours only 4.1 percent of the time. Each “most likely” value is reasonable on its own, but delays add up across tasks while there is little room to finish early. Plans built on summed most likely values are almost guaranteed to slip.
Tip: when someone gives you a single number, ask “what could make this twice as long?” Their answer is your pessimistic value.
Quick estimation techniques
Percentage of development effort. Many organisations use a ratio from past projects: testing at 25 percent of 400 development hours is 100 hours, and at 40 percent it is 160. The ratio depends heavily on the product and team, so use your own history, never a number from the internet.
Test case based estimate. Multiply the number of test cases by the average time per case: 120 cases at 0.5 hours each is 60 hours for one execution cycle. It is simple and useful for execution, but leaves out design, setup, defects and reporting. Good test cases are covered in our guide to writing test cases.
Function point or test point analysis sizes the system by counting inputs, outputs and data stores, then converts size into hours with a productivity factor. It is thorough but needs trained estimators and historical data; we did not calculate one here.
Comparing the results
| Technique | Hours | Note |
|---|---|---|
| Sum of most likely | 106 | Met only 4.1 percent of the time in simulation |
| Three point PERT | 114.5 (98 to 131) | Best single planning number |
| Monte Carlo P50 / P80 | 122.7 / 131.6 | Good for commitments |
| 25 percent of development | 100 | Sanity check only |
| 40 percent of development | 160 | Sanity check only |
| Test cases x time per case | 60 | Execution only |
The bottom-up techniques agree with each other at roughly 115 to 132 hours. The rules of thumb disagree wildly, which is exactly why they should be used to spot an estimate that is far off, not to make one.
Wideband Delphi: estimating as a group
For tasks where one person’s view is not enough, Wideband Delphi collects anonymous estimates from several experts, shares the spread, lets people explain their assumptions, and repeats until the numbers converge. It counteracts the loudest-voice effect, and the discussion often reveals missing tasks. Planning poker in agile teams is a lightweight version of the same idea.
Test estimation in agile teams
In Scrum, testing is usually part of each story’s estimate rather than a separate phase, so story points include test design, automation and exploratory testing. The same principles still apply: break stories into tasks, think about the pessimistic case, and track actual effort against estimates every sprint. Over a few sprints, velocity becomes your most reliable estimation data. Keep a separate allowance for activities that span stories, such as full regression and exploratory sessions.
Common estimation mistakes
- Estimating only execution and forgetting setup, data, retesting and regression.
- Adding most likely values and treating the total as a commitment.
- No buffer for defects: the number of retest cycles depends on code quality, so state the assumption explicitly.
- Not recording actuals, so the next estimate is no better than this one.
- Letting the deadline set the estimate. If time is fixed, reduce scope using risk, and say what will not be tested.
Final thoughts
Good test estimation is not about predicting the future exactly. It is about making uncertainty visible. Break the work into a WBS, collect three numbers per task, add them with PERT, check the total with a quick simulation, and quote a range or a P80 value rather than the optimistic sum. Then record what actually happened, because your own history is the most accurate estimation technique of all.
Frequently asked questions
What is test estimation in software testing?
It is predicting the effort, time and cost of all testing activities, from planning and test design to execution, retesting, regression and reporting, ideally as a range with stated assumptions.
What is the three point estimation formula?
The PERT version is E equals O plus four times M plus P, all divided by six, where O is optimistic, M most likely and P pessimistic. The standard deviation is P minus O, divided by six.
What is the best test estimation technique?
For most teams, a work breakdown structure with three point estimates per task, checked against historical data. Percentage rules are useful only as a quick sanity check.
How much buffer should a test estimate include?
Rather than a flat percentage, use the spread from three point estimates. In our example the 95 percent range added about 16 hours above the PERT total.
Why do test estimates go wrong?
Most often because tasks such as environment setup and defect retesting are left out, and because people add up their most likely values, which our simulation met only 4 percent of the time.
Keep learning
Need help with testing, WordPress or SEO?
We help teams ship better software and grow their sites. Tell us what you are working on and we will suggest a clear next step.