Agile Planning: Vision to Release
Open in the Padhaiko app5.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.
The Seven Stages of the Roadmap to Value
- Stage 1 — Product Vision: Define the overarching purpose, target users, core problem solved, and measurable business objectives for the product.
- Stage 2 — Product Roadmap: Organize high-level themes and features along broad strategic timeframes to show how the vision will evolve.
- 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.
- 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.
- Stage 5 — Daily Scrum: Synchronize every 24 hours on progress toward the Sprint Goal, surface blockers, and adapt the day's plan.
- Stage 6 — Sprint Review: Inspect the working, potentially shippable Increment with stakeholders and gather empirical feedback to adapt the Product Backlog.
- Stage 7 — Sprint Retrospective: Reflect on team processes, collaboration, tools, and engineering quality to lock in concrete improvements for the next Sprint.
| Stage | Planning / Execution Horizon | Typical Cadence | Primary Owner(s) | Key Output Artifact |
|---|---|---|---|---|
| 1. Product Vision | Long-term (1–3+ years) | Created at inception; reviewed quarterly/annually | Product Owner + Executive Sponsors | Product Vision Statement & Objectives |
| 2. Product Roadmap | Medium-to-long (6–18 months) | Updated quarterly or after major releases | Product Owner + Key Stakeholders | Visual Feature & Theme Roadmap |
| 3. Release Plan | Medium (1–4 months / multiple sprints) | Updated per release and after each Sprint Review | Product Owner + Development Team | Prioritized Release Backlog & Forecast |
| 4. Sprint Planning | Short (1–4 weeks) | Start of every Sprint (2–8 hours) | Whole Scrum Team | Sprint Goal & Sprint Backlog |
| 5. Daily Scrum | Immediate (24 hours) | Daily (15 minutes) | Developers | Adapted 24-hour tactical plan |
| 6. Sprint Review | Sprint boundary | End of every Sprint (1–4 hours) | Scrum Team + Stakeholders | Inspected Increment & Updated Backlog |
| 7. Sprint Retrospective | Process improvement | End of every Sprint (1–3 hours) | Whole Scrum Team | Actionable 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.
Product Vision and Strategic Objectives
- Product Vision: A concise, inspiring statement of who the product serves, what core problem it solves, how it stands apart from alternatives, and why the organization is investing in it.
- Product Objectives: Concrete, measurable business and user outcomes (often framed as SMART goals—Specific, Measurable, Achievable, Relevant, Time-bound) that verify whether the vision is being realized.
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:
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].- Vision Box (Product Box) Exercise: Teams and stakeholders collaboratively design a mock retail packaging box for the product—writing the product name, tagline, top 3–4 customer benefits on the front, and technical/operating requirements on the back. This aligns business and engineering teams in under an hour without 50-page charter documents.
- Linking Vision to Objectives: Good objectives avoid vague wishes ("improve customer happiness") and state testable targets ("reduce student course-registration checkout time from 12 minutes to under 2 minutes and achieve 85% mobile completion within 3 months of launch").
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.
Product Roadmap Hierarchy
- Theme: A broad strategic focus area or business goal (e.g., Student Onboarding, Offline Reliability, Automated Grading).
- Epic / Feature: A large capability under a theme that delivers tangible user value and is later decomposed into multiple small User Stories.
- Timeframes: Broad release windows (such as Now / Next / Later, Q1 / Q2 / Q3, or Release 1.0 / 2.0), deliberately keeping distant items coarse-grained and near-term items detailed.
5.3.1 Principles of an Agile Product Roadmap
| Dimension | Traditional Gantt Chart | Agile Product Roadmap |
|---|---|---|
| Focus | Fixed tasks, dates, and resource assignments | Customer outcomes, themes, and high-level features |
| Granularity | Equally detailed months into the future | Rolling-wave detail: fine-grained for Now, coarse for Later |
| Change Policy | Treated as a fixed baseline contract | Living visual guide updated after Sprint Reviews and market feedback |
| Communication Audience | Internal project managers and auditors | Executives, customers, sales, and the delivery team |
- Keep Timeframes Flexible Further Out: Near-term features (next 1–3 months) have refined stories and clear release targets; features 6–12 months out remain strategic themes so the team does not waste effort detailing requirements that market feedback may replace.
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.
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
- 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.
- 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.
- 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:
| Letter | Criterion | What It Means in Practice | Fix When Violated |
|---|---|---|---|
| I | Independent | Can be built, tested, and prioritized in any order without strict coupling to another story. | Combine tightly coupled fragments or split along clean interface boundaries. |
| N | Negotiable | Captures user intent rather than locking rigid UI/implementation details up front. | Replace prescriptive tech mandates with the underlying user goal. |
| V | Valuable | Delivers clear, demonstrable value to an end user or business stakeholder (vertical slice). | Merge pure technical layers ("create DB table") into a user-facing slice. |
| E | Estimable | Clear and bounded enough for developers to assign a relative effort estimate. | Run a short timeboxed research spike or refine unknowns with the PO. |
| S | Small | Sized to fit comfortably inside a single Sprint (ideally completed in 1–3 days). | Split oversized Epics by workflow step, data variation, or CRUD operation. |
| T | Testable | Has 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:
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").
Relative Estimation and Story Points
- Relative Estimation: Sizing a backlog item by comparing its combined effort, complexity, and uncertainty/risk against known reference stories rather than predicting wall-clock hours.
- Story Point: A unitless relative measure of overall work size. Teams commonly use a Modified Fibonacci sequence (
1, 2, 3, 5, 8, 13, 20, 40, 100) because widening gaps reflect increasing uncertainty on larger items (distinguishing a 19-point story from a 20-point story is false precision).
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):
- Present & Discuss: The Product Owner reads a story and its acceptance criteria; Developers ask clarifying questions about edge cases and testing needs.
- Private Selection: Each estimator silently chooses a Fibonacci card (
1, 2, 3, 5, 8, 13, ...) representing relative size. - Simultaneous Reveal: All players flip their cards at the exact same moment.
- Resolve Outliers: If estimates match, record the consensus score. If they diverge (e.g., one
2and one13), the highest and lowest estimators explain their assumptions—often uncovering hidden database work or a reusable library someone else knew about. - 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:
- Silent Relative Placement: Team members place story cards along a wall ordered from smallest to largest by gut comparison.
- Group Calibration: Members review and adjust placements collaboratively, discussing only cards that keep moving back and forth.
- 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).
| Aspect | Planning Poker | Affinity Estimating |
|---|---|---|
| Best Use Case | Deep 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) |
| Mechanism | Discussion -> Simultaneous secret card reveal -> Outlier debate | Silent wall ordering -> Collaborative adjustment -> Bucket assignment |
| Bias Protection | Prevents vocal anchoring via simultaneous card flip | Reduces groupthink via silent initial sorting |
| Typical Scale | Modified Fibonacci Story Points | T-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?"
Release Goal, MMF, and Velocity-Based Forecasting
- Release Goal: The unifying business outcome or capability milestone that justifies deploying an increment to users (e.g., "Enable online fee payment and instant digital receipts for Fall registration").
- Minimum Marketable Feature (MMF): The smallest self-contained set of functionality that delivers genuine, standalone value to customers and is worth the effort of releasing and marketing.
- Velocity: The average number of Story Points for Done stories a specific Scrum team completes per Sprint. Velocity is empirically measured—never copied between teams or mandated by management.
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:
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- Fixed-Scope vs. Fixed-Date Release:
- Fixed-Date Release (e.g., university semester opening): Multiply fixed Sprints by Velocity to get a Point Budget, then pack highest-priority MMFs within that budget (keeping lower-priority items as optional scope).
- Fixed-Scope Release (all regulatory MMFs mandatory): Divide total required points by the velocity range to communicate a realistic target sprint window (e.g., "5 to 6 two-week sprints").
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:
- Regression, Performance & Security Verification: Load testing, vulnerability scanning, and end-to-end integration tests across production-like staging environments.
- Cutover & Rollback Plan: Database migration scripts tested forward and backward, canary/blue-green rollout steps, and feature flags to disable faulty features instantly.
- Operational & User Readiness: Monitoring dashboards and alerting configured, release notes published, support staff briefed, and user onboarding guides updated.
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.
- Compute the team's average velocity across the four Sprints.
- Using the average velocity, calculate how many 2-week Sprints (and calendar weeks) Release 1.0 will likely take.
- 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.0Story Points per Sprint.
Forecasting Sprints at Average Velocity:
- Expected Sprints =
192 / 32.0 = 6.0Sprints. - Since each Sprint is 2 weeks long, expected calendar duration =
6 * 2 = 12weeks.
Conservative Forecast (Using Lowest Observed Velocity = 28):
- Exact Sprint ratio =
192 / 28 = 6.857Sprints, which rounds up to 7 whole Sprints (7 * 2 = 14weeks). - 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) = 24points of nice-to-have stories at the bottom as flex scope.
- Average Velocity: 32.0 points/sprint
- Expected Release Duration: 6 Sprints (12 weeks)
- Conservative Forecast: 7 Sprints (14 weeks) (
192 / 28 = 6.86, rounded up), giving a realistic forecast window of 6–7 Sprints (12–14 weeks).
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:
- MMF 1 (Online Course Enrollment): 42 points
- MMF 2 (Digital Fee Payment & Receipt): 38 points
- MMF 3 (Timetable & Exam Schedule Viewer): 26 points
- MMF 4 (Alumni Forum & Social Feed): 18 points
- Compute the team's total 5-Sprint point budget.
- 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).
- 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 = 150Story Points. - Combined scope of MMF 1–4 =
42 + 38 + 26 + 18 = 124Story Points. - Raw slack if all four MMFs are included =
150 - 124 = 26Story 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 (1point to spare), leaving virtually no margin if velocity dips slightly. - Shipping MMF 1 + MMF 2 + MMF 3 requires
42 + 38 + 26 = 106Story Points (106 / 124 * 100 = 85.48%of the candidate backlog), leaving150 - 106 = 44Story Points of safety margin—almost 1.5 full Sprints of protection against unexpected integration bugs or scope discovery.
- 5-Sprint Budget: 150 Story Points.
- 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).
- 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.
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:
- 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.
- Not Independent / Not Negotiable (violates I & N): Prescribing "React Dashboard" and "32 hours" locks implementation details and absolute hours prematurely.
- Not Estimable / Not Testable (violates E & T): "So it looks great" is completely subjective and gives QA no pass/fail acceptance threshold.
- 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):
- Given an active semester course, when the coordinator opens Attendance Summary, then all students below 75.0% attendance appear sorted lowest-first.
- 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.
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
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:
- Product Vision (purpose, target customers, strategic objectives)
- Product Roadmap (themes, high-level features, broad timeframes)
- Release Plan (MMFs, velocity-based release window)
- Sprint Planning (Sprint Goal, Sprint Backlog, task breakdown)
- Daily Scrum (24-hour tactical coordination and blocker checks)
- Sprint Review (Increment demo and backlog adaptation)
- 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.
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).
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.
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.
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:
- Card: Short written token reminding the team of a user need (
As a..., I want..., so that...). - Conversation: Collaborative PO–Developer–QA dialogue uncovering nuances and constraints.
- 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.
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.
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.
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.
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.
- Calculate the team's average velocity.
- Compute the expected number of Sprints (and weeks) required at average velocity.
- 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 = 100points. - Average velocity =
100 / 4 = 25.0points/sprint. - Expected Sprints at average velocity =
175 / 25.0 = 7.0Sprints (7 * 2 = 14weeks).
Optimistic and Conservative Range Forecasts:
- Optimistic (at 28 points/sprint):
175 / 28 = 6.25Sprints -> rounds up to 7 whole Sprints (14 weeks, finishing early inside Sprint 7). - Conservative (at 22 points/sprint):
175 / 22 = 7.95Sprints -> rounds up to 8 whole Sprints (16 weeks). - Recommended release window: 7 to 8 Sprints (14 to 16 weeks).
- Average Velocity: 25.0 points/sprint
- Expected Duration: 7 Sprints (14 weeks)
- Optimistic:
6.25Sprints (7 whole Sprints / 14 weeks); Conservative:7.95Sprints (8 whole Sprints / 16 weeks) -> Recommended forecast window: 14–16 weeks.