One-Page Project Plan Template
Updated: Oct 19
A new engineering manager inherits a 34-page project plan. It has a resourcing table, a responsibility matrix and a risk register with severity scores. Buried in the scope section, one sentence assumes another team will deliver an API by week six. Nobody on that team has agreed to the date. All 34 pages rest on that sentence. When the API slips, the plan doesn't bend, it breaks, because the volume hid the one assumption everything depended on instead of exposing it.
This is a composite, and the pattern is common. Length is where uncertainty hides: when there's room for everything, nobody has to admit what they don't know. A one-page plan forces the opposite. With no room to spare, every line has to earn its place, and the assumptions that hold the plan up end up on the same page as the goal, where someone will question them in week one.
If you've written a project charter, it settled whether the project should happen and what "done" means. The one-page plan is how you'll get there, and what has to stay true along the way.
The template
# [Project name]: One-Page Plan
Goal: [one sentence: what will exist or be true when we're done]
Why: [one sentence: the problem this solves, with a number if you have one]
Success measures: [2 or 3, each with baseline, target, date]
Failure line: [the result, by date, that means we stop and review]
Scope
In: [3 to 5 bullets]
Out: [the things people will ask for, and where they go instead]
Assumptions this plan rests on
[assumption]: confirmed by [name, date] / signpost: [early warning]
Approach: [3 to 5 bullets, ordered so the biggest uncertainty goes first]
Milestones: [5 to 7, each something a stranger could check, with a date range]
Team: [name, role, real allocation after other commitments]
Risks: [top 2 or 3, each with owner and fallback]
Decisions pending: [decision, who decides, needed by]
Change log: [date, change, approved by]
It fits on a page. The sections that do the most work, and that most plans skip, are the assumptions, the order of the approach, and milestones someone outside the team could verify.
Find the assumptions the plan rests on
RAND developed a planning method in the early 1990s, Assumption-Based Planning, that starts here. It defines an assumption as important "if its negation would lead to significant changes" in the plan. It also notes how rare it is for an organisation to set out all of its important assumptions explicitly. Most have to be dug out of documents, interviews and observation.
For a project, go through the plan line by line and ask of each: what has to be true for this line to hold? Then keep the assumptions where the answer to "and if it's false?" is "the plan breaks":
Assumption If false Confirmed?
Platform team ships the switch API Weeks 4 to 12 slip with it Platform lead
by week 3 agreed in writing 2 Mar
Existing auth flow supports Need a permissions change, Spike, week 1
mid-session workspace change security review (+3 weeks)
Two engineers available full time Timeline doubles No: one engineer on
call in week 6
The last column is the discovery move. An assumption about another team's work is either a commitment, with a name and a date, or a hope. The 34-page plan treated a hope as a commitment.
The test: for every dependency on another team, can you name the person on that team who agreed to the date, and when? If not, write it on the plan as an unconfirmed assumption, which is honest, and go and get the agreement this week.
Give each risky assumption a signpost and a fallback
Some assumptions are solid. Others could plausibly fail before the project ends. RAND calls these vulnerable. For each one, the method adds three things, and they translate directly to a project plan:
A signpost: an event or threshold that clearly shows the assumption is weakening. "API contract not published by the end of week 2."
A shaping action: something you can do now to make the assumption hold. "Pair with the platform team on the contract in week 1."
A hedging action: preparation in case it fails anyway. "Build the UI against a stub, so a late API delays release but not front-end work."
A signpost turns "the dependency slipped" from a surprise in week six into a decision in week two, while there's still time to act.
The test: for each vulnerable assumption, is there a signpost with a date, and a named person watching it? A risk without a signpost is only noticed after it has happened.
Do the most uncertain work first
Plans are usually ordered by how the system is built: backend, then frontend, then rollout. Order them instead by what you know least about. If the riskiest assumption is that the auth flow handles a mid-session switch, the first week's work is a spike that proves or disproves it, not the database schema.
This doesn't make the project shorter. It moves the bad news earlier, while the timeline, the scope and the sponsor's expectations can still change.
The test: name the plan's riskiest assumption. In which week will you know whether it's true? If the answer is after the halfway point, reorder the approach.
Milestones a stranger could check
"Design complete" and "MVP in staging" describe activity. They're easy to declare done and hard to dispute, which is why they slip quietly. Write each milestone as something observable that someone outside the team could check on the day:
Activity milestone | Checkable milestone |
Design complete | Design review signed off by PM and one support lead; no open questions on switching from deep links |
API done | A user with three workspaces can switch through the API in staging, URL context preserved, under 300 ms |
Beta | 5 named customer accounts using the switcher for a week; usage and errors visible on the dashboard |
Launch | Flag at 100%; support tickets about workspace confusion tracked against baseline |
Five to seven milestones is enough for most projects. More than that, and they start describing tasks.
The test: could a person who isn't on the team look at your next milestone on its due date and say, without asking anyone, whether it was met?
Date ranges from past work
Estimates from the plan itself are optimistic. Buehler, Griffin and Ross's studies of the "planning fallacy" found people's predictions of their own completion times were too optimistic across a range of tasks. People focused on plan-based scenarios rather than relevant past experience. When participants were told to connect their predictions to past experience, the optimistic bias disappeared. Observers, predicting other people's tasks, made more use of past experience.
For a one-page plan, that means two habits. First, before the dates go in, look up what the last similar piece of work actually took. Flyvbjerg calls this reference class forecasting: basing the forecast on how comparable projects actually performed. Second, give milestones a range ("weeks 9 to 11"), not a single date, and narrow it as the uncertain work gets done.
The test: for the largest milestone, name the comparable past project and its real duration. If the plan is faster, write down why this time is different.
Names and real allocation
"Engineering: two engineers" isn't a commitment. "Pat, full time, except on-call in week 6" is. List each person by name with their real availability after their other commitments: on-call rotations, a second project, leave already booked. Those are the gaps that turn a 12-week plan into a 15-week one without anyone deciding they should.
The test: for each named person, check their calendar for the plan's duration. Is the allocation on the plan what's actually left?
When one page isn't enough
Project | One-page plan is | What else you need |
Under 3 months, one or two teams | The plan | Nothing more |
Multi-quarter or multi-team | The summary everyone reads | Detailed plans per team, linked |
Vendor or contractor work | Your view of the plan | A statement of work for deliverables and acceptance |
Regulated or compliance-heavy | The summary | Whatever the control framework requires, linked |
Things that live elsewhere and get linked: the task-level schedule (in the team's tracker), the full risk register, the stakeholder map, detailed budgets.
Keep it current
A plan that's out of date is worse than none, because people still act on it. Look at the signposts weekly. Update the page when a milestone moves, an assumption is confirmed or broken, or a decision is made, and add a line to the change log with who agreed. When a decision is made, move it out of "pending" and into the scope or the approach.
A worked example
Here is a composite plan for a feature that lets customers switch between workspaces. The figures are illustrative.
# Workspace Switching: One-Page Plan
Goal: customers with several workspaces can switch between them from any
page without signing in again
Why: switching is the second most-cited friction point in churn interviews;
140 support tickets a month mention it
Success measures
Weekly switcher use: 0% now, 30% of multi-workspace users by 60 days
after launch
Switching-related tickets: 140 a month now, 40 or fewer by 90 days
Failure line: under 10% weekly use at 90 days: stop and review
Scope
In: switcher on every page, URL context kept, recent list, keyboard access
Out: bulk workspace actions (separate project), mobile (Q3, not committed),
workspace search (v2 candidate)
Assumptions this plan rests on
Platform team ships switch API by week 3: confirmed by platform lead,
2 March / signpost: contract not published by end of week 2
Auth flow supports mid-session switch: unconfirmed; spike week 1 /
signpost: spike fails, then permissions change + security review
Pat full time: true except on-call week 6 (covered by Alex)
Approach
Week 1 spike on auth before any UI work
Build UI against an API stub until the real API lands
Feature-flag rollout 10%, 50%, 100%
Milestones
Weeks 2 to 3: auth spike result written up; go or replan
Weeks 4 to 5: user with 3 workspaces switches in staging, URL kept,
under 300 ms
Weeks 7 to 8: internal beta, errors and use on the dashboard
Weeks 9 to 11: 5 named customers using it for a week
Weeks 12 to 13: flag at 100%
(Last comparable feature, account switcher: planned 10 weeks, took 14)
Team: lead engineering manager; Pat (full time, on-call week 6);
Alex (50%); designer (3 weeks); PM; sponsor VP Product
Risks
Back-button behaviour after a switch confuses users (owner: designer;
fallback: user test in week 7, before beta)
Analytics events slip to after launch (owner: PM; fallback: launch
blocked until the usage measure is live)
Decisions pending
User loses access mid-session: what happens? (lead and PM, week 3)
Change log
9 Mar Auth spike passed; permissions change not needed (lead)
It fits on a page. Anyone reading it can see what's being built, what it depends on, which of those dependencies are confirmed, and how they'll know early if one fails.

What to do this week
Take the plan for your current project, whatever length it is. List every assumption whose failure would break it, and mark each confirmed (with a name and date) or not. For the unconfirmed ones on other teams, ask for the commitment this week. For the riskiest, set a signpost and move the work that tests it to the front. Then rewrite the next two milestones so someone outside the team could check them. Track the signposts in your status report.
Final takeaway
A one-page plan is useful because it can't hide anything. Use that. List the assumptions the plan rests on, and for every dependency on another team, get a named person and a date, or mark it unconfirmed. Give each vulnerable assumption a signpost that warns early and a fallback you've prepared. Order the work so the biggest uncertainty is resolved first. Write milestones a stranger could check, give dates as ranges grounded in what similar work actually took, and list people by name with the time they really have. Then keep the page current, because a plan people stop trusting stops being used.
Sources
Dewar, J. A., Builder, C. H., Hix, W. M. and Levin, M. H., Assumption-Based Planning: A Planning Tool for Very Uncertain Times, RAND Corporation, MR-114-A, 1993: an assumption is important "if its negation would lead to significant changes" in plans; vulnerable assumptions; signposts, shaping actions and hedging actions. https://www.rand.org/pubs/monograph_reports/MR114.html
Buehler, R., Griffin, D. and Ross, M., "Exploring the 'Planning Fallacy': Why People Underestimate Their Task Completion Times", Journal of Personality and Social Psychology 67(3), 1994, pp. 366–381: predictions of own completion times were too optimistic; people focused on plan-based scenarios rather than past experience; the bias was eliminated when predictions were connected to relevant past experience. https://doi.org/10.1037/0022-3514.67.3.366
Flyvbjerg, B., "From Nobel Prize to Project Management: Getting Risks Right", Project Management Journal 37(3), 2006, pp. 5–15: reference class forecasting based on the actual performance of comparable projects. https://doi.org/10.1177/875697280603700302
Related reading
Part of the Engineering Templates & Playbooks guide — ShiftQuality's collection of ready-to-adapt templates.


