PadhaikoAll subjects

Agile Planning: Vision to Release

Agile Methodologies (ENCT 465)

Open in the Padhaiko app

5.1 Roadmap to Value: The seven stages of planning and execution

Agile teams do more planning than traditional Waterfall teams—not less. Instead of locking a single speculative plan at project kickoff, Agile distributes planning across multiple rolling horizons (the Agile Planning Onion: Vision -> Roadmap -> Release -> Sprint -> Daily). Mark Layton's Roadmap to Value captures this complete cycle in seven continuous stages of planning and execution.

Definition

The Seven Stages of the Roadmap to Value

  1. Stage 1 — Product Vision: Define the overarching purpose, target users, core problem solved, and measurable business objectives for the product.
  2. Stage 2 — Product Roadmap: Organize high-level themes and features along broad strategic timeframes to show how the vision will evolve.
  3. Stage 3 — Release Plan: Select a coherent bundle of Minimum Marketable Features (MMFs) for an upcoming release, sized with story points and forecast using team velocity.
  4. Stage 4 — Sprint Planning: Pull top-priority Product Backlog items into a timeboxed Sprint, agree on a Sprint Goal, and break stories into execution tasks.
  5. Stage 5 — Daily Scrum: Synchronize every 24 hours on progress toward the Sprint Goal, surface blockers, and adapt the day's plan.
  6. Stage 6 — Sprint Review: Inspect the working, potentially shippable Increment with stakeholders and gather empirical feedback to adapt the Product Backlog.
  7. Stage 7 — Sprint Retrospective: Reflect on team processes, collaboration, tools, and engineering quality to lock in concrete improvements for the next Sprint.
Horizon, Cadence, and Owner Across the Seven Stages
StagePlanning / Execution HorizonTypical CadencePrimary Owner(s)Key Output Artifact
1. Product VisionLong-term (1–3+ years)Created at inception; reviewed quarterly/annuallyProduct Owner + Executive SponsorsProduct Vision Statement & Objectives
2. Product RoadmapMedium-to-long (6–18 months)Updated quarterly or after major releasesProduct Owner + Key StakeholdersVisual Feature & Theme Roadmap
3. Release PlanMedium (1–4 months / multiple sprints)Updated per release and after each Sprint ReviewProduct Owner + Development TeamPrioritized Release Backlog & Forecast
4. Sprint PlanningShort (1–4 weeks)Start of every Sprint (2–8 hours)Whole Scrum TeamSprint Goal & Sprint Backlog
5. Daily ScrumImmediate (24 hours)Daily (15 minutes)DevelopersAdapted 24-hour tactical plan
6. Sprint ReviewSprint boundaryEnd of every Sprint (1–4 hours)Scrum Team + StakeholdersInspected Increment & Updated Backlog
7. Sprint RetrospectiveProcess improvementEnd of every Sprint (1–3 hours)Whole Scrum TeamActionable Process Improvement Plan

5.2 Defining the Product Vision: Developing objectives and vision statements

Before writing a single line of code or user story, the team and sponsors must share an unambiguous Product Vision—the "True North" that guides every prioritization trade-off when scope, budget, or deadlines collide.

Definition

Product Vision and Strategic Objectives

5.2.1 Crafting a Vision Statement (Elevator Pitch Template)

A widely used Agile standard (adapted from Geoffrey Moore's Crossing the Chasm) structures the Product Vision into six crisp clauses:

Agile Product Vision Statement (Elevator Pitch) TemplateText
FOR       [target customer or user segment]
WHO       [statement of need or opportunity]
THE       [product name] IS A [product category]
THAT      [key benefit / compelling reason to adopt]
UNLIKE    [primary competitive or current manual alternative]
OUR PRODUCT [statement of primary differentiation / unique advantage].

5.3 The Product Roadmap: Arranging features, themes, and timeframes

While the Product Vision sets the destination, the Product Roadmap bridges high-level strategy and day-to-day backlog execution by arranging themes, features, and approximate timeframes.

Definition

Product Roadmap Hierarchy

5.3.1 Principles of an Agile Product Roadmap

Traditional Gantt Schedule vs. Agile Product Roadmap
DimensionTraditional Gantt ChartAgile Product Roadmap
FocusFixed tasks, dates, and resource assignmentsCustomer outcomes, themes, and high-level features
GranularityEqually detailed months into the futureRolling-wave detail: fine-grained for Now, coarse for Later
Change PolicyTreated as a fixed baseline contractLiving visual guide updated after Sprint Reviews and market feedback
Communication AudienceInternal project managers and auditorsExecutives, customers, sales, and the delivery team

5.4 User Stories: Definition, creation (Three C's), and acceptance criteria

In Agile, requirements are captured not as dense IEEE specification clauses ("The system shall...") but as User Stories—short, value-focused descriptions written from the user's perspective that invite team conversation.

Definition

User Story, Three C's, and INVEST Criteria

A User Story is a concise description of a small increment of functionality valued by a user or customer, typically written in the Connextra role-feature-benefit format: As a [type of user], I want [some goal/capability] so that [some measurable value/reason].

5.4.1 Creating Stories: Ron Jeffries' Three C's

  1. Card: A brief written summary (historically on a 3x5 index card, or a ticket title/description) acting as a promise for a conversation, not a complete specification.
  2. Conversation: Ongoing dialogue among the Product Owner, Developers, and Testers during Backlog Refinement and Sprint Planning to uncover edge cases, UI expectations, and business rules.
  3. Confirmation: Explicit Acceptance Criteria documented on the story that define exact observable tests proving the story works as intended.

5.4.2 Writing High-Quality Stories: The INVEST Model

Bill Wake's INVEST checklist tests whether a User Story is ready for Sprint execution:

The INVEST Checklist for Quality User Stories
LetterCriterionWhat It Means in PracticeFix When Violated
IIndependentCan be built, tested, and prioritized in any order without strict coupling to another story.Combine tightly coupled fragments or split along clean interface boundaries.
NNegotiableCaptures user intent rather than locking rigid UI/implementation details up front.Replace prescriptive tech mandates with the underlying user goal.
VValuableDelivers clear, demonstrable value to an end user or business stakeholder (vertical slice).Merge pure technical layers ("create DB table") into a user-facing slice.
EEstimableClear and bounded enough for developers to assign a relative effort estimate.Run a short timeboxed research spike or refine unknowns with the PO.
SSmallSized to fit comfortably inside a single Sprint (ideally completed in 1–3 days).Split oversized Epics by workflow step, data variation, or CRUD operation.
TTestableHas objective Acceptance Criteria so QA and PO can verify pass/fail unambiguously.Replace vague words ("fast", "user-friendly") with concrete thresholds and scenarios.

5.4.3 Acceptance Criteria (Confirmation)

Acceptance criteria define the behavioral boundaries of a story before coding begins. Teams commonly write them in Given-When-Then (Gherkin) scenario format:

Sample User Story with Given-When-Then Acceptance CriteriaText
Story:
  As a registered student,
  I want to reset my forgotten password via an emailed one-time link,
  so that I can regain access to my course portal without calling support.

Acceptance Criteria:
  1. Given a registered email address,
     When the student submits the "Forgot Password" form,
     Then the system sends a single-use reset link valid for 15 minutes.
  2. Given an expired or already-used reset link,
     When the student clicks the link,
     Then the system rejects the reset and prompts the student to request a new link.
  3. Given a newly entered password shorter than 8 characters,
     When the student submits the new password,
     Then the form displays an inline validation error and does not update credentials.

5.5 Effort Estimation: Relative estimation, planning poker, and affinity estimating

Traditional software projects fail notoriously when managers ask developers to guess exact hours months in advance ("How many hours will the billing engine take?"). Humans are poor at absolute time prediction under uncertainty, yet remarkably accurate at relative comparison ("Story B is roughly twice as complex as Story A").

Definition

Relative Estimation and Story Points

5.5.1 Planning Poker (Consensus Estimation)

Planning Poker (popularized by James Grenning and Mike Cohn) combines expert judgment, group discussion, and simultaneous reveal to eliminate anchoring bias (where a loud senior member or manager speaks first and skews everyone else's estimate):

  1. Present & Discuss: The Product Owner reads a story and its acceptance criteria; Developers ask clarifying questions about edge cases and testing needs.
  2. Private Selection: Each estimator silently chooses a Fibonacci card (1, 2, 3, 5, 8, 13, ...) representing relative size.
  3. Simultaneous Reveal: All players flip their cards at the exact same moment.
  4. Resolve Outliers: If estimates match, record the consensus score. If they diverge (e.g., one 2 and one 13), the highest and lowest estimators explain their assumptions—often uncovering hidden database work or a reusable library someone else knew about.
  5. Re-Vote: After brief discussion, the team re-votes until converging (usually within 2 rounds).

5.5.2 Affinity Estimating (Rapid Bulk Sizing)

When a team starts a brand-new product with 60–120 backlog items, running Planning Poker on every item would take days. Affinity Estimating sizes large batches in 30–60 minutes:

  1. Silent Relative Placement: Team members place story cards along a wall ordered from smallest to largest by gut comparison.
  2. Group Calibration: Members review and adjust placements collaboratively, discussing only cards that keep moving back and forth.
  3. Bucket Mapping: The ordered line is grouped into relative size buckets—either T-shirt sizes (XS, S, M, L, XL) or Fibonacci Story Point columns (1, 2, 3, 5, 8, 13, 20).
AspectPlanning PokerAffinity Estimating
Best Use CaseDeep refinement of near-term Sprint candidate stories (5–15 stories/hour)Rapid initial sizing of an entire new Release or Product Backlog (50–100+ stories)
MechanismDiscussion -> Simultaneous secret card reveal -> Outlier debateSilent wall ordering -> Collaborative adjustment -> Bucket assignment
Bias ProtectionPrevents vocal anchoring via simultaneous card flipReduces groupthink via silent initial sorting
Typical ScaleModified Fibonacci Story PointsT-shirt sizes (XS–XL) or Fibonacci buckets

5.6 Release Planning: Goals, minimum marketable features, and deployment prep

A Release Plan bridges the strategic Product Roadmap and tactical Sprints by answering a crucial business question: "What cohesive set of value can we ship to customers, and roughly how many Sprints will it take?"

Definition

Release Goal, MMF, and Velocity-Based Forecasting

5.6.1 Forecasting a Release with Team Velocity

Because software delivery carries natural variation, Agile release plans forecast ranges rather than brittle single-day promises:

Velocity-Based Release Forecasting FormulaText
Total Release Scope (Points) = Sum of story points for all MMF stories in the release
Expected Sprints Needed      = Total Release Scope / Average Team Velocity
Optimistic Sprints Needed    = Total Release Scope / Upper-Bound (Best Sustained) Velocity
Conservative Sprints Needed  = Total Release Scope / Lower-Bound Velocity

5.6.2 Deployment Preparation (Release Readiness)

In mature DevOps teams, every Sprint Increment is potentially deployable via automated CI/CD. Even then—and especially in regulated or customer-facing environments—teams execute explicit Deployment Preparation before going live:


Example 5.1

5.1

A product team preparing Release 1.0 has broken its Minimum Marketable Features (MMFs) into User Stories totaling 192 Story Points. Over the last four 2-week Sprints, the team's completed ("Done") velocities were 28, 34, 31, and 35 points.

  1. Compute the team's average velocity across the four Sprints.
  2. Using the average velocity, calculate how many 2-week Sprints (and calendar weeks) Release 1.0 will likely take.
  3. Using the team's lowest observed velocity (28 points/sprint) as a conservative bound, compute the conservative Sprint count (rounded up to whole Sprints) and compare the realistic vs. conservative calendar window.

Computing Average Velocity: Total completed points over 4 Sprints = 28 + 34 + 31 + 35 = 128 Story Points.

  • Average Velocity = 128 / 4 = 32.0 Story Points per Sprint.

Forecasting Sprints at Average Velocity:

  • Expected Sprints = 192 / 32.0 = 6.0 Sprints.
  • Since each Sprint is 2 weeks long, expected calendar duration = 6 * 2 = 12 weeks.

Conservative Forecast (Using Lowest Observed Velocity = 28):

  • Exact Sprint ratio = 192 / 28 = 6.857 Sprints, which rounds up to 7 whole Sprints (7 * 2 = 14 weeks).
  • Release communication: The Product Owner communicates a realistic forecast of 6 to 7 Sprints (12 to 14 weeks)—or locks a 12-week target date by placing roughly 192 - (6 * 28) = 24 points of nice-to-have stories at the bottom as flex scope.
Answer:
  1. Average Velocity: 32.0 points/sprint
  2. Expected Release Duration: 6 Sprints (12 weeks)
  3. Conservative Forecast: 7 Sprints (14 weeks) (192 / 28 = 6.86, rounded up), giving a realistic forecast window of 6–7 Sprints (12–14 weeks).
Example 5.2

5.2

A university portal project has a fixed deadline of 5 two-week Sprints (10 weeks) before fall classes start. The team's proven average velocity is 30 Story Points per Sprint. Four candidate MMFs are prioritized in the backlog:

  1. Compute the team's total 5-Sprint point budget.
  2. Determine whether all four MMFs (totaling 124 points) fit inside the 5-Sprint budget, and calculate the buffer remaining after packing all 4 MMFs (or which MMFs fit if the team reserves a 25-point risk buffer).
  3. If management decides to ship MMF 1, MMF 2, and MMF 3 first and defer MMF 4 to Release 1.1, what percentage of the total 124-point scope is committed, and how many points of schedule safety buffer remain?

Total 5-Sprint Budget vs. Combined MMF Scope:

  • 5-Sprint Point Budget = 5 * 30 = 150 Story Points.
  • Combined scope of MMF 1–4 = 42 + 38 + 26 + 18 = 124 Story Points.
  • Raw slack if all four MMFs are included = 150 - 124 = 26 Story Points.

Evaluating With vs. Without MMF 4:

  • If the team reserves a 25-point risk/deployment buffer, all 4 MMFs (124 + 25 = 149 <= 150) technically fit right at the limit (1 point to spare), leaving virtually no margin if velocity dips slightly.
  • Shipping MMF 1 + MMF 2 + MMF 3 requires 42 + 38 + 26 = 106 Story Points (106 / 124 * 100 = 85.48% of the candidate backlog), leaving 150 - 106 = 44 Story Points of safety margin—almost 1.5 full Sprints of protection against unexpected integration bugs or scope discovery.
Answer:
  1. 5-Sprint Budget: 150 Story Points.
  2. All four MMFs total 124 points, leaving 26 points of raw slack (just enough for a 25-point buffer with only 1 point to spare).
  3. Committing MMF 1–3 (106 points) covers 85.48% of the candidate scope while preserving 44 points of schedule safety buffer, ensuring core fall registration launches reliably on time.
Example 5.3

5.3

Exam-Style Story Quality & Planning Question: A Product Owner writes the following backlog item: "Build the entire Admin & Student Analytics Database and React Dashboard in 32 hours so it looks great." Using the User Story template, Three C's, and INVEST model, identify four defects in this item and rewrite it into an INVEST-compliant User Story with testable Acceptance Criteria.

Identifying Four INVEST / Story Defects:

  1. Not Valuable (or mixed technical layer) & Too Big (violates V & S): Bundling "entire database + dashboard" is an oversized Epic mixing backend infrastructure with multiple user capabilities.
  2. Not Independent / Not Negotiable (violates I & N): Prescribing "React Dashboard" and "32 hours" locks implementation details and absolute hours prematurely.
  3. Not Estimable / Not Testable (violates E & T): "So it looks great" is completely subjective and gives QA no pass/fail acceptance threshold.
  4. Missing Role-Feature-Benefit Structure: Does not state who needs analytics or why it creates value.

Rewriting as an INVEST-Compliant Slice + Acceptance Criteria:

  • User Story (Card): As an Academic Coordinator, I want to view a per-course attendance summary table showing students below 75% attendance, so that I can send early warning notices before final exams.
  • Conversation: PO, developer, and coordinator clarify CSV export vs. on-screen filter, date range (current semester), and privacy rules.
  • Confirmation (Acceptance Criteria):
    1. Given an active semester course, when the coordinator opens Attendance Summary, then all students below 75.0% attendance appear sorted lowest-first.
    2. Given a selected course, when the coordinator clicks "Export CSV," then a file downloads within 3 seconds containing Student ID, Name, Attended Classes, Total Classes, and Percentage.
Answer:

The original item violates Value/Small (oversized technical bundle), Negotiable (hardcoded tech stack), Estimable (absolute hour guess), and Testable (vague "looks great"). Splitting it into a user-centered slice with role-goal-benefit phrasing and concrete threshold-based Given-When-Then acceptance criteria satisfies both INVEST and the Three C's.


Exercises

Practice Exercises — Agile Planning: Vision to Release

Question 1

List the seven stages of the Roadmap to Value in order, and explain how planning granularity changes from Stage 1 (Product Vision) down to Stage 5 (Daily Scrum).

The Seven Stages of the Roadmap to Value:

  1. Product Vision (purpose, target customers, strategic objectives)
  2. Product Roadmap (themes, high-level features, broad timeframes)
  3. Release Plan (MMFs, velocity-based release window)
  4. Sprint Planning (Sprint Goal, Sprint Backlog, task breakdown)
  5. Daily Scrum (24-hour tactical coordination and blocker checks)
  6. Sprint Review (Increment demo and backlog adaptation)
  7. Sprint Retrospective (team process inspection and improvement)

Rolling-Wave Granularity Across Horizons: At Stage 1 (Vision) and Stage 2 (Roadmap), planning is coarse-grained (outcomes and quarterly themes over 6–36 months) so teams avoid wasting effort detailing volatile distant requirements. At Stage 3 (Release) and Stage 4 (Sprint), near-term features are decomposed into small, INVEST-ready User Stories and tasks. At Stage 5 (Daily Scrum), planning zooms into 24-hour tactical adjustments.

Answer:

The seven stages are Product Vision, Product Roadmap, Release Plan, Sprint Planning, Daily Scrum, Sprint Review, and Sprint Retrospective. Planning transitions from coarse, outcome-oriented strategic horizons (Vision/Roadmap) to fine-grained, empirically adjusted execution (Sprint/Daily).

Question 2

Write a complete Product Vision Statement using the 6-part Elevator Pitch template for a mobile offline exam-study application aimed at BE Computer students, and explain the purpose of a Product Roadmap compared to a traditional Gantt chart.

Sample 6-Part Product Vision Statement:

  • FOR BE Computer engineering students in Nepal
  • WHO struggle with fragmented PDFs and unreliable internet while preparing for university exams,
  • THE Sem-Prep Study App IS A mobile offline learning companion
  • THAT delivers interactive step-by-step solutions, syllabus-aligned lessons, and timed practice exercises without requiring Wi-Fi.
  • UNLIKE static textbook scans and scattered online video playlists,
  • OUR PRODUCT unifies worked derivations, built-in code/formula verification, and personal progress tracking in one fast offline workspace.

Product Roadmap vs. Traditional Gantt Chart: A Product Roadmap communicates strategic themes, customer-valued features, and flexible timeframes (Now / Next / Later) that evolve after Sprint Reviews. Unlike a rigid Gantt chart locking detailed task dependencies months ahead, a roadmap keeps distant plans coarse and focuses stakeholders on outcomes.

Answer:

A structured 6-part Vision Statement aligns target audience, problem, product category, core benefit, alternative, and differentiator. A Product Roadmap translates that vision into evolving themes and release horizons, emphasizing business outcomes and rolling-wave adaptability rather than rigid Gantt task schedules.

Question 3

Explain Ron Jeffries' Three C's of a User Story and define every letter of the INVEST acronym with one practical check for each criterion.

The Three C's of User Stories:

  1. Card: Short written token reminding the team of a user need (As a..., I want..., so that...).
  2. Conversation: Collaborative PO–Developer–QA dialogue uncovering nuances and constraints.
  3. Confirmation: Verifiable Acceptance Criteria confirming the story works as expected.

The INVEST Checklist:

  • I — Independent: Can be built/deployed without rigid sequential dependency on another story.
  • N — Negotiable: States user goal, leaving technical/UI trade-offs open to team collaboration.
  • V — Valuable: Delivers observable value to a user or stakeholder (not an isolated DB script).
  • E — Estimable: Clear enough for the team to assign Story Points reliably.
  • S — Small: Small enough to complete and test inside one Sprint (typically 1–3 days).
  • T — Testable: Supported by objective pass/fail Acceptance Criteria.
Answer:

The Three C's are Card, Conversation, and Confirmation. INVEST stands for Independent, Negotiable, Valuable, Estimable, Small, and Testable—ensuring stories are sliced cleanly for single-sprint delivery and unambiguous verification.

Question 4

Compare Planning Poker and Affinity Estimating, explaining why Agile teams prefer relative estimation (Story Points) over absolute hour estimates and why Planning Poker requires simultaneous card reveals.

Why Relative Estimation Beats Absolute Hours: Developers vary widely in speed, and hidden complexity makes up-front hour predictions inaccurate. Story Points compare relative effort, complexity, and uncertainty against a baseline reference story using Modified Fibonacci gaps (1, 2, 3, 5, 8, 13, 20)—which stay stable across a team and naturally map to historical Velocity.

Planning Poker vs. Affinity Estimating & Anchoring Bias:

  • Planning Poker sizes near-term stories deeply through discussion, simultaneous secret reveal (preventing anchoring bias where the first speaker sways everyone else), and outlier debate.
  • Affinity Estimating rapidly sorts 50–100+ stories silently onto a relative scale on a wall and groups them into T-shirt or Fibonacci buckets during initial backlog creation.
Answer:

Story Points measure relative effort, complexity, and risk rather than brittle hour guesses. Planning Poker uses simultaneous reveals to eliminate anchoring bias during detailed story sizing, while Affinity Estimating silently groups large backlogs into relative size buckets for fast release sizing.

Question 5

A startup team's Minimum Marketable Features for a mobile payment release total 175 Story Points. Their completed velocities over the past four 2-week Sprints were 22, 26, 24, and 28 Story Points.

  1. Calculate the team's average velocity.
  2. Compute the expected number of Sprints (and weeks) required at average velocity.
  3. Compute the exact and whole-sprint optimistic (at max velocity 28) and conservative (at min velocity 22) Sprint forecasts, and state the recommended release window in weeks.

Average Velocity and Mean Forecast:

  • Sum of last 4 Sprint velocities = 22 + 26 + 24 + 28 = 100 points.
  • Average velocity = 100 / 4 = 25.0 points/sprint.
  • Expected Sprints at average velocity = 175 / 25.0 = 7.0 Sprints (7 * 2 = 14 weeks).

Optimistic and Conservative Range Forecasts:

  • Optimistic (at 28 points/sprint): 175 / 28 = 6.25 Sprints -> rounds up to 7 whole Sprints (14 weeks, finishing early inside Sprint 7).
  • Conservative (at 22 points/sprint): 175 / 22 = 7.95 Sprints -> rounds up to 8 whole Sprints (16 weeks).
  • Recommended release window: 7 to 8 Sprints (14 to 16 weeks).
Answer:
  1. Average Velocity: 25.0 points/sprint
  2. Expected Duration: 7 Sprints (14 weeks)
  3. Optimistic: 6.25 Sprints (7 whole Sprints / 14 weeks); Conservative: 7.95 Sprints (8 whole Sprints / 16 weeks) -> Recommended forecast window: 14–16 weeks.
← Agile Roles, Behaviors, and Team DynamicsSprint Execution and Quality Management (part 1: 6.1–6.3) →