Handling Analysis Projects: Scope, Critical Path and Change
Plan a small analysis project with a scope, task dependencies, slack and a critical path, and handle a change request calmly.
In this lesson you will
- Write a scope
- Order tasks by what they wait for
- Find slack and the critical path
- Handle a change request with choices
About 30 minutes
Three weeks, one report, no surprises
The charity from the last lesson accepts Dev’s quote and asks for the report by the end of November. Dev has a start date, Monday the 2nd, and a list of tasks. What he needs now is a plan that tells him whether the end of November is realistic, which tasks cannot be late, and what happens when the client asks for one extra thing. Handling a project is less about clever analysis than about order, honesty and keeping the client’s expectations in step with reality.
Scope first
A scope is a written list of what you will deliver and what you will not. For this job it might say: one cleaned table of donations, a report answering three named questions, and a handover of the code. Just as important is what is outside it: new data sources, a dashboard, or a second report. Most arguments about projects begin with a sentence that starts “I thought you would also”. A scope written down and agreed at the start is the cheapest protection against it.
Tasks, durations and dependencies
Break the work into tasks small enough to estimate, and note which tasks must wait for others. Cleaning cannot start before the data arrives. The checks wait for the cleaning. The report draft waits for the analysis. Two tasks can sometimes run side by side, such as the chart notes, which only need the cleaned data. Each task gets a length in working days.
import datetime
tasks = {
"question": (2, []),
"access data": (2, ["question"]),
"clean": (4, ["access data"]),
"checks": (2, ["clean"]),
"analyse": (5, ["checks"]),
"draft report": (3, ["analyse"]),
"chart notes": (2, ["clean"]),
"review": (2, ["draft report", "chart notes"]),
"handover": (1, ["review"]),
}
def plan(tasks):
early = {}
def finish(n):
if n not in early:
dur, deps = tasks[n]
start = max([finish(d) for d in deps], default=0)
early[n] = (start, start + dur)
return early[n][1]
for name in tasks:
finish(name)
end = max(f for s, f in early.values())
late = {}
for name in sorted(tasks, key=lambda n: -early[n][1]):
after = [late[k][0] for k in tasks if name in tasks[k][1]]
lf = min(after) if after else end
late[name] = (lf - tasks[name][0], lf)
slack = {n: late[n][0] - early[n][0] for n in tasks}
return end, slack
def add_days(start, n):
d = start
while n > 0:
d += datetime.timedelta(days=1)
if d.weekday() < 5:
n -= 1
return d
start = datetime.date(2026, 11, 2)
def show(label, tasks):
end, slack = plan(tasks)
print(label + ": " + str(end) + " working days, finish " + add_days(start, end - 1).strftime("%a %d %b"))
return slack
slack = show("plan", tasks)
print("critical:", [n for n in tasks if slack[n] == 0])
print("slack:", {n: s for n, s in slack.items() if s})
change = dict(tasks); change["chart notes"] = (4, tasks["chart notes"][1])
show("chart notes take 2 days longer", change)
change = dict(tasks); change["analyse"] = (7, tasks["analyse"][1])
show("analyse takes 2 days longer", change)
plan: 21 working days, finish Mon 30 Nov
critical: ['question', 'access data', 'clean', 'checks', 'analyse', 'draft report', 'review', 'handover']
slack: {'chart notes': 8}
chart notes take 2 days longer: 21 working days, finish Mon 30 Nov
analyse takes 2 days longer: 23 working days, finish Wed 02 Dec
The program works out the earliest each task can start and finish, then works backwards from the end to find the latest each could finish without delaying the project. The difference is the slack. Tasks with no slack form the critical path: the chain of tasks that sets the length of the whole project. The plan takes 21 working days, finishing on Mon 30 Nov. Eight of the nine tasks are critical. Only the chart notes have room to move, with 8 days of slack.
What the critical path tells you
The last two lines of the output show why the idea is useful. If the chart notes take two days longer, nothing changes: the plan still ends on Mon 30 Nov, because that task had slack to spare. But if the analysis takes two days longer, the whole project slips to 23 working days and finishes on Wed 02 Dec. The same delay has no effect in one place and a big effect in another. A project manager who knows the critical path knows where to spend attention, and where a delay can be absorbed.
Handling change
- Write the request down, however small, in the client’s words.
- Find the tasks it touches and see whether they are on the critical path.
- Price it in hours and in days, using the floor rate from lesson 28 and the plan above.
- Offer choices: do it and move the date, do it and drop something, or leave it for a second phase.
- Get a yes in writing before you start, and update the plan.
A good plan is a tool for conversations. When the client asks, “Can you also look at donations by month?”, Dev does not say yes or no. He says what it would cost in time, and what it would do to the date. That is respectful, and it keeps the relationship healthy.
Keeping a project honest
- Give a range for the date, not a promise, until the data has arrived and you have seen its state. Bad data is the biggest unknown.
- Share progress early and in small pieces. A first look at cleaned data after one week avoids a shock at the end.
- Name the risks. What would hurt most: late data, a key person away, unclear questions? Plan something for the top two.
- Record what you learned at the end, so the next estimate is better.
The working-day count skips weekends but not public holidays or leave. Before you promise a date, check the calendar for your place and for the client’s.
Treating every task as equally urgent. Time spent hurrying a task with slack does nothing for the end date, while a slip on a critical task moves it day for day.
The tasks, lengths and dates are invented for this example. Real estimates should come from similar past jobs. The plan counts weekdays only.
Practice for this lesson
Check what you learned
Five quick questions. Pick an answer and you will see straight away whether it is right and why.
What is a scope?
- A chart of the results
- A list of mistakes
- A kind of meeting
- A written list of what you will deliver and what you will not
What is left out matters as much as what is in.
What is slack?
- The cost of a task
- How long a task can slip without delaying the project
- A kind of dependency
- The first task
The chart notes had room to move.
What is the critical path?
- The longest task
- The cheapest route
- The chain of tasks with no slack that sets the project length
- The list of clients
A delay on it moves the whole end date.
Why did analysing two days longer change the end date, but the chart notes did not?
- Analysis is on the critical path and the notes have slack
- Analysis is longer in cost
- The notes were cancelled
- Dates are random
The same delay has different effects in different places.
What should you do first when a client asks for an extra piece of work?
- Say yes at once
- Say no at once
- Write it down and find what it touches and costs
- Ignore it
Then offer choices and get a yes in writing.
Summary
- Write down what is in and out of scope.
- Tasks with no slack form the critical path.
- A delay costs days on the path and nothing elsewhere.
- Price changes in hours and days, and offer choices.
Questions
How do I estimate task lengths?
Use similar past jobs where you can, break tasks into small pieces, and add a buffer for surprises. After each project, compare estimates with what happened and learn from the gap.
Do I need special software?
No. A list of tasks with lengths and what each waits for, plus a few lines of code like the lesson, is enough for a small project. Larger teams use planning tools, but the ideas are the same.
What if the critical path changes?
It can. When a task with slack grows large enough, it becomes critical. That is why you update the plan whenever a task runs long or short.
