top of page

One-Page Project Plan Template

Shift Quality Editorial
Jul 16
9 min read

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.

A one-page plan earns its keep by exposing the assumptions it rests on. In the composite example, a 34-page plan hid one sentence assuming another team would deliver an API by week six, which nobody on that team had agreed to. The method: list each assumption whose failure would break the plan, and mark it confirmed with a name and date, or unconfirmed. For each vulnerable assumption, set a signpost that warns early, a shaping action to keep it true, and a hedging action in case it fails, following RAND's Assumption-Based Planning. Then order the work so the riskiest assumption is tested first, write milestones a stranger could check on the day, and give dates as ranges based on what comparable past work took, because people's own estimates are optimistic, as Buehler, Griffin and Ross found.

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.

bottom of page