Project Management Leadership with AIPlanning scope, schedule, budget and resources · Lesson 6 of 21
Estimating, scheduling and budgeting essentials
Video lecture
Estimating, scheduling and budgeting essentials
The narrated lecture is in production
Every chapter is scripted and ready. Browse the chapters and read the full transcript now — the video will appear here when it’s published.
Chapters
Transcript of the narration, chapter by chapter.
0:00 Estimates are forecasts under uncertainty
'How long will it take?' It's the question every project manager dreads, because any single answer is wrong. Say eight weeks, and it becomes a promise. Say 'it depends', and you sound evasive. The way out isn't a better guess. It's a better kind of answer: a range, a most likely value, and the one or two uncertainties that drive the difference. In this lecture you'll learn the main estimation techniques, how three-point PERT estimates work, how estimates become a schedule and a budget, how agile teams estimate and budget differently, and how to counter the planning fallacy. By the end, you'll be able to present an estimate that is honest, useful and hard to turn into an unrealistic commitment.
0:52 Why it matters
Why does this matter? Because estimates become commitments, whether you intended them to or not. A single-point estimate hides the uncertainty that everyone involved actually knows is there. And people are systematically optimistic about their own work, which is called the planning fallacy. It isn't a character flaw; it's how human judgement works when we imagine the task going well and forget the interruptions, rework and waiting. So the professional response is to estimate in ranges, to use more than one technique, and to be explicit about what drives the uncertainty. That turns an estimate from a promise you'll break into a forecast you can manage.
1:38 The concept: techniques
Here are the main techniques. Analogous estimating scales from similar past work: 'the last payments feature took twelve weeks'. It's quick, and only as good as the similarity. Parametric estimating multiplies a rate by a quantity: forty screens at three days each. It works when you have reliable rates. Bottom-up estimating asks the people doing the work to estimate detailed tasks and adds them up. It's more accurate, but it tends to miss the things nobody listed, like reviews, approvals and integration. And three-point estimating captures uncertainty directly with an optimistic, a most likely and a pessimistic value. Think of it like planning a journey: you know the usual time, the best time with empty roads, and the worst case with an accident on the motorway. Using two or three techniques and comparing them is far more reliable than trusting any one.
2:40 Three-point PERT
The PERT formula gives an expected value from three points: E equals O plus four times M plus P, all divided by six. It weights the most likely value most heavily, but lets the extremes pull the answer. An approximate standard deviation is P minus O, divided by six. Here's the key insight. In real work, the pessimistic tail is usually much longer than the optimistic one. Things can go a little better than expected, but they can go a lot worse. So the expected value usually lands later than the most likely value. That's not pessimism. It's arithmetic. And it's exactly why plans built by adding up most-likely estimates tend to finish late: they ignore the skew.
3:31 Worked example one: integration testing
Let's work the example from the lesson. Integration testing. Optimistic: ten days. Most likely: fifteen. Pessimistic: thirty-two, because integration testing is where hidden problems surface. Expected: ten, plus four times fifteen, which is sixty, plus thirty-two. That's a hundred and two, divided by six: seventeen days. Standard deviation: thirty-two minus ten is twenty-two, divided by six, about three point seven days. So the expected duration is two days later than the most likely, because of that long pessimistic tail. If you'd planned fifteen days, you'd be late more often than not. Now, a caution. Adding standard deviations across tasks isn't straightforward, because tasks aren't independent. For whole-project confidence levels, Monte Carlo simulation, which the project controls course covers in depth, is the better tool.
4:25 Worked example two: a London payments feature
Now the realistic example from the lesson. A fictional fintech in London estimates a new payments feature. The analogous estimate, from a similar feature last year: twelve weeks. The team's bottom-up estimate: nine weeks. Why the gap? When the project manager walks through the bottom-up, it excludes security review and regulatory sign-off, because the developers estimated only the work they do themselves. Three-point estimates on those uncertain items add around two weeks. So the project manager presents: most likely eleven weeks, with a realistic range of ten to fourteen weeks; the main uncertainty is the timing of regulatory sign-off. The sponsor agrees a target date at thirteen weeks, with a clear escalation point if sign-off hasn't started by week eight. Notice what happened: the conversation moved from 'why so long?' to 'what can we do about sign-off?'.
5:25 Watch me do it: PERT and a schedule in a sheet
Let me set this up in a spreadsheet. One row per uncertain task, with optimistic, most likely and pessimistic columns. Expected is O plus four M plus P, over six. Standard deviation is P minus O, over six. Then I sum the most likely values and the expected values along the critical path, or the sequence of tasks that drives the end date. In this example, most likely adds up to forty-one days and expected adds up to forty-seven. That six-day gap is the planning fallacy made visible. I present it honestly: most likely forty-one working days, expected forty-seven, and a planning range of roughly forty-four to fifty-five depending on how the uncertain items land. Then I list the two tasks with the largest spread, because those are where attention and contingency should go.
6:23 Budgeting, agile budgeting and the planning fallacy
From estimates to budget: add up the work estimates, add contingency for identified risks, and hold management reserve for unknowns, usually controlled by the sponsor. Agile teams often budget differently: a stable team is funded over a period, say a quarter, and the question becomes which outcomes deliver the most value within that capacity, with regular checkpoints to continue, pivot or stop. Both approaches need honesty about uncertainty. To counter the planning fallacy, compare with reference classes, meaning what similar projects actually took, run a pre-mortem where the team imagines the project finished late and lists why, and always present ranges. The common mistakes: single-point estimates, estimates made without the people doing the work, forgetting reviews and approvals, and padding every task secretly instead of holding visible contingency.
7:19 Recap and try this now
Let's recap. Estimates are forecasts under uncertainty, so treat them that way. Use more than one technique, analogous, parametric, bottom-up and three-point, and compare them. The PERT formula gives an expected value that usually lands later than the most likely, because real work has long pessimistic tails. Build the schedule from logic and the budget from estimates plus visible contingency and management reserve, and present a most likely value, a range and the key uncertainty. Counter optimism with reference classes and pre-mortems. Your try-this-now: produce three-point estimates for five uncertain tasks on a project you know, calculate the PERT expected values, and present a date range with the one uncertainty that matters most.
Estimates are forecasts under uncertainty
Every estimate is a prediction. Good project managers make the uncertainty visible, use more than one technique and refine estimates as knowledge improves.
Estimation techniques
| Technique | How | Strengths | Watch out for |
|---|---|---|---|
| Analogous | Compare with a similar past project | Fast, early | Differences in scope or context |
| Parametric | Use a rate (e.g., hours per screen, cost per m²) | Scalable, data-based | Needs reliable historical data |
| Bottom-up | Estimate each work package, then sum | Detailed, accurate when scope is clear | Time-consuming; misses integration work |
| Three-point | Optimistic (O), most likely (M), pessimistic (P) | Captures uncertainty | Needs honest ranges |
| Expert judgment / Delphi | Structured input from experts | Uses tacit knowledge | Groupthink, anchoring |
| Relative estimation (story points) | Size items relative to each other (agile) | Fast, team-owned | Points are not hours; not comparable across teams |
Three-point (PERT) estimates
PERT expected duration E = (O + 4M + P) / 6
Approximate standard deviation σ ≈ (P − O) / 6Illustrative. Integration testing: O = 10 days, M = 15, P = 32. E = (10 + 60 + 32)/6 = 17 days; σ ≈ 22/6 ≈ 3.7 days. Note that E is later than the most likely value because the pessimistic tail is long, which is typical for real work.
From estimates to schedule
- Break work into activities (or backlog items) from the WBS.
- Sequence with dependencies (finish-to-start mostly).
- Estimate durations from effort and resource availability (effort ÷ available people × efficiency).
- Build the network and identify the critical path (the longest path, which determines the end date).
- Add buffers where uncertainty is high, visibly, rather than padding every task.
- Validate with the team: is it realistic given holidays (for example Eid, Christmas, Ramadan working hours in Muslim-majority countries), other commitments and onboarding time?
Budgeting
A project budget typically includes:
Labour (internal) effort × loaded rate
Contractors/suppliers quotes or rates × effort
Hardware, software, licences quotes
Travel, facilities, training estimates
Contingency reserve for identified risks (visible line)
= Cost baseline
Management reserve for unknowns (held by sponsor, outside baseline)
= Total funding requirementTime-phase the budget along the schedule to produce a spending profile (S-curve) for cash planning and progress tracking.
Agile budgeting
In agile delivery, budgets often fund teams over time rather than fixed scope: for example, two teams for six months. Scope flexes within the budget based on prioritisation. Forecasts use velocity (story points per sprint) or throughput (items per week) ranges: "At 25–32 points per sprint, the remaining 240 points will take 8–10 sprints."
Worked example
Illustrative. A fictional fintech in London estimates a payments feature. Analogous estimate from a similar feature: 12 weeks. Bottom-up by the team: 9 weeks, but it excludes security review and regulatory sign-off. Three-point on the uncertain items adds a buffer of 2 weeks. The PM presents: "Most likely 11 weeks, with a realistic range of 10–14 weeks; the main uncertainty is regulatory sign-off timing." The sponsor agrees a target date at 13 weeks with a clear escalation point.
Planning fallacy and how to counter it
People systematically underestimate time and cost for their own tasks. Counter it by using historical data (reference classes), separating estimation from commitment pressure, asking "what would have to go right for this to be the minimum?", and tracking estimate accuracy over time.
Common mistakes
- Single-point estimates presented as certainties.
- Padding hidden in every task (and consumed by Parkinson's law: work expands to fill the time available).
- Estimates set by managers without the people doing the work.
- Ignoring holidays, onboarding and non-project duties.
- Converting story points into hours to compare teams.
Quick self-check
For your current plan, can you state the three biggest estimate uncertainties and the range they create for the end date? If you can only give one date, you are hiding risk from your sponsor.
Communicating estimates
When presenting estimates, state the basis ("bottom-up by the team, calibrated against two similar projects"), the range and the main drivers of uncertainty. Update estimates as work progresses and explain changes clearly; stakeholders tolerate revised estimates far better when they understand why they changed.
Hands-on: PERT in Excel
Columns: A Task | B O | C M | D P | E Critical? (Y/N)
F Expected (E) =(B2+4*C2+D2)/6
G Std dev (σ) =(D2-B2)/6
H Skew check =IF((D2-C2)>2*(C2-B2),"Long pessimistic tail","")
Sum of M (critical) =SUMIF(E:E,"Y",C:C)
Sum of E (critical) =SUMIF(E:E,"Y",F:F)
Sigma (critical) =SQRT(SUMPRODUCT((E2:E20="Y")*G2:G20^2))
Indicative range =Sum_E-1.28*Sigma to =Sum_E+1.28*Sigma (≈ P10–P90 if tasks were independent and roughly normal)The summed σ assumes independent tasks, which real tasks rarely are; treat the range as indicative and use Monte Carlo for decisions.
Hands-on: a quick Monte Carlo on three-point estimates (Python)
import numpy as np
rng = np.random.default_rng(5)
tasks = { # O, M, P in working days (illustrative)
"Design": (8, 10, 16), "Build": (15, 20, 32), "Integration test": (10, 15, 32),
"Security review": (3, 5, 12), "Regulatory sign-off": (5, 10, 25),
}
N = 20_000
total = sum(rng.triangular(o, m, p, N) for o, m, p in tasks.values())
most_likely = sum(m for _, m, _ in tasks.values())
print(f"Sum of most-likely: {most_likely} days | P(meet it): {np.mean(total <= most_likely):.0%}")
print(f"P50 {np.percentile(total, 50):.0f} days | P80 {np.percentile(total, 80):.0f} days")The probability of meeting the sum of most-likely values is typically low: the planning fallacy in one number.
Template: presenting an estimate
Most likely: ____ Range (P20–P80 or O–P): ____ Target/commitment proposed: ____
Main uncertainties (top 2) and what would reduce them: ____
Assumptions (people, dependencies, approvals): ____ Escalation point: ____How to measure success
- Estimates presented as ranges with named uncertainties.
- Actual versus estimate tracked by task type to build reference classes.
- Contingency visible and linked to risks, not hidden in task padding.
Key takeaways
- Use several estimation techniques and present ranges, not single points.
- PERT: E = (O + 4M + P)/6, σ ≈ (P − O)/6.
- Schedule from dependencies and realistic availability; make buffers visible.
- Budgets include visible contingency; management reserve sits outside the baseline; agile often funds teams over time.
Check your understanding
Quick questions to lock in the lesson. They don’t count towards your certificate.
Put it into practice
Produce a three-point estimate for five uncertain tasks in a project you know, calculate PERT values and present a date range.
Enrol for free to save your progress
Reading is always free. Enrol to keep your place, take the final assessment and earn a verifiable certificate.