Skip to content
Tutorials Center
My learning

Topics

Lesson 37 of 50 ยท Management, Risk and Professional Practice

Project Management Basics

Learn the basics of software project management: the scope-schedule-cost triangle, work breakdown, critical path, Gantt charts and earned value, with runnable calculators.

A project is a temporary effort with a defined goal, a start and an end, and limited people, time and money. Building an invoicing app for one client is a project; operating it for years afterwards is not. Project management is the work of planning that effort, tracking it and steering it so it delivers something useful within its limits. Software projects are notoriously hard to predict, which is why good basics matter: they will not make a project certain, but they make problems visible earlier, when they are cheaper to fix.

This lesson covers the core tools: the scope, schedule and cost trade-off, breaking work into tasks, finding the critical path, reading a Gantt chart, and tracking progress with earned value. A project management tool (a tracker or planner) is a product you would use in practice; here, the runnable examples are JavaScript stand-ins with invented numbers that show how the calculations work. For estimating the effort in the first place, see estimation and planning and cost estimation models.

Scope, schedule and cost

Every project is shaped by three linked constraints, often drawn as a triangle:

  • Scope: what will be delivered (features, quality level).
  • Schedule: when it will be delivered.
  • Cost: the money and effort available.

Change one and at least one of the others moves. Adding features (scope) takes more time or more people. Cutting the deadline (schedule) forces cuts in scope or more spending. Some people add quality as a fourth force: squeezing all three corners without admitting it usually shows up as defects later.

The project triangle

Scope What gets delivered.
Schedule When it is ready.
Cost Money and effort spent.

Pull one corner and another moves.

1 / 2

A useful habit is to ask which corner is fixed and which is flexible at the start. A legal deadline fixes the schedule, so scope must flex. A fixed feature list for a contract fixes scope, so schedule or cost will flex. Agile teams usually fix the schedule and cost of each iteration and let scope flex (Scrum in practice).

Breaking the work down

Nobody can estimate "build the app". The first planning tool is the work breakdown structure (WBS): split the project into deliverables, split those into tasks, and keep going until each task is small enough to estimate and assign, typically a few days of work. A good WBS has three properties: tasks cover all the work (nothing is missing), tasks do not overlap, and each task has a clear "done" condition.

Next, record dependencies: which tasks must finish before others can start. "Write the report page" depends on "design the database". Dependencies, together with durations, determine the earliest possible finish.

The critical path

Suppose a project has these tasks (days of work, and what each needs first):

Task Days Needs
A Requirements 5 none
B Design 7 A
C Database 4 B
D Backend 10 B
E Frontend 8 B
F Integration 4 C, D, E
G Testing 6 F
H Documentation 3 D
I Release 2 G, H

Tasks that do not depend on each other can run in parallel. The total duration is not the sum of all days. It is the length of the longest chain of dependent tasks, called the critical path. Any delay on a critical task delays the whole project one-for-one. Tasks off the critical path have slack (also called float): how long they can slip without moving the end date.

The critical path method (CPM) computes this with two passes:

  1. Forward pass. For each task, the earliest start is the latest earliest finish of its prerequisites; earliest finish = earliest start + duration.
  2. Backward pass. Starting from the project end date, compute each task's latest finish (the latest it can end without delaying the project) and latest start.
  3. Slack = latest start - earliest start. Tasks with zero slack are the critical path.

The calculator below runs both passes for the table above.

JS Critical path calculator

Press Run (or Ctrl + Enter) to see the console output here.

No output.

The critical path here is A, B, D, F, G, I. The documentation task has plenty of slack, so a delay there is harmless, but a delay in the backend delays the release. Practical consequences: put your best attention and your most experienced people on the critical path, and watch for the moment a slipping non-critical task uses up its slack and becomes critical. Shortening the project means shortening a critical task (by adding people, reducing scope or overlapping work). Speeding up a non-critical task changes nothing. Adding people is not a free fix either, since new people need onboarding and add communication cost, a point made famous as Brooks's law: adding people to a late project tends to make it later.

Gantt charts

A Gantt chart draws each task as a horizontal bar on a calendar, with dependencies shown as links. It answers "what is happening when" at a glance and is the standard way to show a schedule to stakeholders. Its weaknesses are that it looks more precise than the estimates behind it, and that it becomes stale quickly unless someone updates it.

A Gantt chart is a view of the same data, so a few lines can draw one from the critical path numbers. This stand-in prints each task's bar (using # for work) at its earliest start.

JS A text Gantt chart

Press Run (or Ctrl + Enter) to see the console output here.

No output.

Real planners also draw milestones, points in time with no duration that mark something important being complete, such as "design approved" or "release candidate ready". Milestones are useful because they are checkable: either the thing is done or it is not.

Tracking progress with earned value

"We are 60% through the schedule" tells you little if you have also spent 90% of the budget. Earned value management (EVM) compares three numbers, all measured in money (or effort units), so that schedule and cost can be judged together:

  • Planned value (PV): the budgeted value of the work that should be finished by today.
  • Earned value (EV): the budgeted value of the work that is actually finished by today.
  • Actual cost (AC): what you have actually spent so far.

From them come simple indicators:

TEXT
schedule variance SV = EV - PV      (negative: behind schedule)
cost variance     CV = EV - AC      (negative: over budget)
schedule index   SPI = EV / PV      (below 1: behind)
cost index       CPI = EV / AC      (below 1: over budget)
estimate at completion EAC = BAC / CPI

Here BAC (budget at completion) is the total approved budget. The EAC forecast assumes the project keeps performing at its current cost efficiency. It is a forecast, not a promise, and should be revised as conditions change. The most important rule is how to count EV: only completed work earns value. A task that is "90% done" for three weeks should earn little. Many teams use a strict rule such as 0% until finished, or 50% when started, so that optimism does not inflate progress.

JS Earned value calculator

Press Run (or Ctrl + Enter) to see the console output here.

No output.

Alpha is both late and over budget: it earned 35,000 of work while spending 42,000, so if nothing changes it will finish near 120,000. Beta is ahead and under budget. The value of EVM is the early warning: a CPI of 0.83 at week 8 is a prompt for a conversation now rather than a surprise at the end.

Rolling-wave planning

You cannot plan a 12-month project in detail on day one, because most details are unknown. Rolling-wave planning (also called sliding-window planning) plans the next few weeks in detail and the later phases only at a coarse level. As the window moves forward, the team replans the next stretch with what it has learned. The benefit is plans that stay realistic; the risk is that stakeholders mistake the coarse far-future plan for a commitment, so label its confidence honestly.

Monitoring and control

Planning is only half the job. Monitoring is collecting data on how the project is really going; controlling is acting on what the data says. Together they form a loop that runs for the whole project:

  1. Define key performance indicators (KPIs): schedule variance, cost variance (see earned value above), defect counts, scope changes, velocity, risk exposure.
  2. Collect data regularly, ideally automatically (issue tracker, build system, time sheets) so it is accurate and cheap.
  3. Compare with the plan and decide whether the variance matters.
  4. Take corrective action: reprioritize scope, add or move people, change the schedule, mitigate a risk, or formally change the baseline through change control.
  5. Record lessons learned for the next project.

The benefits are early issue detection, better use of resources, quality and compliance checks, informed decisions, transparency and more predictable delivery. Typical problems and their remedies:

Problem Remedy
Incomplete or inaccurate data Automate collection; define who owns each number
Communication breakdowns Regular status meetings and one source of truth
Weak stakeholder engagement Short reviews with decision makers; visible dashboards
Unforeseen risks Keep the risk register alive; reserve contingency
Resistance to change Explain why, involve people early, start small
No standard process Agree templates and definitions of done

Everyday project practices

  • Define "done" for the project and for each task, so progress is measured against something concrete.
  • Communicate status honestly. Early bad news is cheap; late bad news is expensive. A status report that is always green deserves suspicion.
  • Manage stakeholders. Know who decides scope changes, and route every change through them (change management).
  • Keep a risk list and review it regularly (risk management).
  • Plan buffers on purpose. Estimates are uncertain; a visible buffer at project level is better than hidden padding on every task.
  • Review after the project. A short retrospective turns this project's lessons into the next one's plan.

Check your understanding

Quick check ยท 5 questions

of 5 answered You scored / 5 ยท perfect!

  1. 1. What does the critical path of a project determine?

    The critical path is the longest chain of dependent tasks. It sets the minimum project length, and its tasks have zero slack.
  2. 2. A task has 3 days of slack. What does that mean?

    Slack is the delay a task can absorb without moving the project end date; critical tasks have zero slack.
  3. 3. EV is 30,000, PV is 40,000 and AC is 36,000. What do the indexes say?

    SPI = 30,000 / 40,000 = 0.75 and CPI = 30,000 / 36,000, about 0.83. Both are below 1.
  4. 4. Why does EVM count only finished work as earned value?

    Strict crediting rules keep the progress figure honest, which keeps the SPI and CPI trustworthy.
  5. 5. Which is a typical limitation of a Gantt chart?

    A Gantt chart is a view of the plan. Its neat bars can hide uncertain estimates, and it needs maintenance.

Summary

  • A project is limited by scope, schedule and cost (and quality); changing one moves the others.
  • A work breakdown splits the goal into estimable tasks; dependencies and durations set the schedule.
  • The critical path is the longest dependent chain; its tasks have zero slack and any delay moves the end date.
  • A Gantt chart shows tasks on a timeline; it is a view of the plan, not a guarantee.
  • Earned value compares planned value, earned value and actual cost to produce SPI, CPI and a cost forecast.
  • Honest status reporting and a regularly reviewed risk list matter more than the tool.

Next: Risk Management.