Summary: The Roadmap Generator is a production-grade system that converts candidate initiatives into prioritized, scheduled, and risk‑adjusted delivery plans by combining deterministic priority scoring, probabilistic duration estimation, constrained optimization, and Monte Carlo simulation to yield committed initiatives, timelines with confidence intervals, and critical-path visibility. This document is the canonical spec for building or evaluating such systems, providing the conceptual model (initiative attributes, dependencies, risk), underlying mathematics and formulas, implementation-ready templates, algorithms/pseudocode, visual/UX guidance, and founder best practices.

Roadmap Generator Template & Technical Specification

Authoritative blueprint for a production-grade Roadmap Generator. This document provides: the conceptual model, underlying mathematics and formulas, implementation-ready templates, algorithms and pseudocode, visual/UX suggestions, and a concise set of founder best practices. Use it as the canonical spec to build or evaluate any roadmap-generation system.

Executive summary

A Roadmap Generator converts a list of candidate initiatives (features, experiments, projects) into prioritized, scheduled, and risk-adjusted delivery plans under capacity and time constraints. It combines deterministic scoring (priority), probabilistic duration estimation, optimization (resource/time constraints), and Monte Carlo simulation for uncertainty. The result is a set of committed initiatives and a timeline with confidence intervals and critical path visibility.

Key building blocks:

• Initiative model (value, effort, dependencies, risk)
• Priority scoring (RICE, WSJF, or custom weighted scoring)
• Resource-constrained optimization (knapsack / ILP)
• Time/cost uncertainty (PERT, triangular distributions, Monte Carlo)
• Scheduling (topological ordering, CPM, Gantt)
• Metrics and visual outputs (expected completion, confidence bands, cost of delay)

Conceptual flow

1. Inputs: initiatives + metadata (reach, impact, effort, dependencies, lead, earliest start)
2. Normalize and compute priority scores (RICE/WSJF/custom weights)
3. Compute risk-adjusted value and cost-of-delay
4. Solve optimization to select initiatives within capacity/time/budget constraints
5. Estimate durations with uncertainty (PERT/triangular) and run Monte Carlo to produce probabilistic timelines
6. Produce schedule via CPM + resource leveling, exposing earliest/latest starts, slack, and critical path
7. Output roadmap (Gantt + confidence bands), KPIs, and “what-if” scenarios

Data model (minimum)

• Initiative

  • id
  • name
  • description
  • reach (R)
  • impact (I)
  • confidence (C) ∈ [0,1]
  • effort (E) e.g., person-weeks
  • cost (dollars)
  • dependencies: list of initiative ids
  • optimistic_duration (O)
  • most_likely_duration (M)
  • pessimistic_duration (P)
  • time_criticality (T) e.g., 0–10
  • risk_reduction_value (RR) optional
  • owner
  • earliest_start_date

• Global parameters

  • capacity (person-weeks per time unit)
  • planning_horizon (time units)
  • confidence_target (e.g., 80%)
  • simulation_runs (e.g., 10,000)

Priority scoring formulas

Use one or more scoring models. The two widely adopted are RICE and WSJF.

1. RICE (Reach, Impact, Confidence, Effort):

RICE score:
RICE = (R × I × C) / E

Where:

• R = number reached in a period (users, accounts)
• I = impact per user (quantitative or ordinal)
• C = confidence (0–1)
• E = effort (person-weeks)

2. WSJF (Weighted Shortest Job First) from SAFe:

WSJF = Cost_of_Delay / Job_Size

Common Cost_of_Delay decomposition:
Cost_of_Delay = User-Business-Value + Time-Criticality + RiskReduction / OpportunityEnablement

If you quantify components each on comparable scales:
CoD = V + T + RR

Job_Size = normalized effort or duration (e.g., story points, person-weeks)

Thus:
WSJF = (V + T + RR) / Job_Size

3. Custom weighted score (vector scoring):

Let features have numeric attributes a_j. Define weight vector w_j. Score S:

S = Σ_j w_j × normalize(a_j)

Normalization typically maps each attribute into [0,1].

Normalization (min-max):
normalize(a_i) = (a_i - min(a)) / (max(a) - min(a))

Or z-score for statistical behaviors:
z(a_i) = (a_i - μ(a)) / σ(a)

Risk-adjusted value

Adjust raw value by success probability to reflect expected value:

EV = Value × p_success

If Confidence (C) can approximate p_success:
EV = (R × I) × C

If multiple risk factors, combine:
p_success = Π_k (1 - p_k)

Then:
EV = Value × p_success

Cost of Delay (CoD) continuous approximation

When value accrues over time, model CoD as a rate r (value per time unit). If delay from t0 to t results in lost value:

CoD = ∫_{t0}^{t} r(τ) dτ

Discrete linear approximation:
CoD ≈ r × Δt

WSJF uses CoD per unit time normalized by job duration to prioritize.

Duration estimation PERT (beta) and variance

For each initiative, capture three-point estimates:

• O = optimistic duration
• M = most-likely duration
• P = pessimistic duration

PERT expected duration (mean):
E[D] = (O + 4M + P) / 6

Variance:
Var(D) = ((P - O) / 6)^2

If you prefer triangular distribution:
E[D] = (O + M + P) / 3
Var(D) = (O^2 + M^2 + P^2 - O M - O P - M P) / 18

Use these distributions to sample durations for Monte Carlo.

Monte Carlo for timeline uncertainty

Algorithm:

• For i in 1..N simulations:
  • Sample each initiative duration D_i from its distribution (PERT/triangular/lognormal)
  • Apply dependencies and schedule (topological order)
  • If resources constrained, apply resource allocation rules (simple FIFO, priority-based, or constrained scheduling solver)
  • Record project finish time(s), initiative finish times
• Aggregate: median, p10, p50, p80, p90 completion times for each milestone

This produces confidence bands on the roadmap.

Scheduling & Critical Path Method (CPM)

For DAG of initiatives with durations D_i:

Earliest Start (ES_i), Earliest Finish (EF_i):
ES_i = max_{j ∈ preds(i)} EF_j
EF_i = ES_i + D_i

Latest Finish (LF_i), Latest Start (LS_i):
LF_i = min_{k ∈ succ(i)} LS_k (for sinks LF = project_end)
LS_i = LF_i - D_i

Slack / Float:
Slack_i = LS_i - ES_i

Critical path = initiatives with Slack_i = 0

With resource constraints you need resource leveling iterative adjustment or a constrained scheduling solver (heuristic or MIP).

Optimization: Selection under capacity (0/1 knapsack / ILP)

When you must choose a subset of initiatives maximizing value subject to resource or budget constraints:

Binary decision x_i ∈ {0,1}

Maximize Σ_i v_i x_i

Subject to:
Σ_i effort_i x_i ≤ capacity
Σ_i cost_i x_i ≤ budget
x_i = 0 or 1
(and additional precedence constraints can be linearized)

If v_i is risk-adjusted EV (or WSJF score mapped to expected monetary benefit), the ILP finds the optimal portfolio.

Integer Linear Programming formulation with precedence (optional):

If j depends on i:
x_j ≤ x_i

Use solvers: CBC, Gurobi, CPLEX, OR-Tools.

Resource leveling & capacity allocation

At any time t, capacity C_t (person-weeks per time unit). For assigned initiatives with effort E_i, allocation a_{i,t} must satisfy:

Σ_i a_{i,t} ≤ C_t for all t
Σ_t a_{i,t} = E_i × (conversion factor)

And dependencies must be honored: a_{i,t} = 0 for t < ES_i

This is a resource-constrained scheduling / project scheduling problem (RCPSP), NP-hard; solve heuristically or with MIP for small instances.

Simple heuristic: priority-based greedy allocation:

• Maintain ready set (no unmet dependencies)
• At each time-step:
  • Sort ready initiatives by priority score
  • Allocate capacity to highest priority until exhausted (pro-rate if necessary)
  • Advance time by delta (e.g., 1 day/week)

Putting it together computation pipeline

1. Normalize attributes
2. Compute Priority score S_i (RICE/WSJF/custom)
3. Compute EV_i = Value_i × p_success_i
4. Compute CoD_i and WSJF_i if used
5. Solve selection ILP: maximize Σ EV_i x_i subject to Σ effort_i x_i ≤ capacity
6. For selected initiatives, sample durations (N runs)
7. For each run, schedule using CPM + resource leveling
8. Aggregate timeline outputs and compute confidence intervals
9. Produce visual and tabular outputs

Template: Roadmap Generator (Markdown)

Use this as a template file for the Roadmap Generator UI or API output.

Roadmap Generator Output

Metadata

• Product:
• Planning horizon:
• Capacity (person-weeks / time unit):
• Simulation runs:
• Confidence target:

Initiatives (table)

id	name	owner	reach	impact	confidence	effort (pw)	O	M	P	time_criticality	RR	dependencies
1	Example Feature A	Alice	1000	2.5	0.8	8	2	4	8	6	2	[]

Parameterization

• Scoring method: RICE / WSJF / Custom
• Cost-of-delay components and scales:
  • User-Business-Value weight:
  • Time-Criticality weight:
  • Risk-Reduction weight:
• Duration distribution: PERT / Triangular / Lognormal
• Resource allocation heuristic: greedy-priority / MIP

Computation details

• Priority score formula used: RICE = (R × I × C) / E
• Risk-adjusted value: EV = (R × I) × C
• PERT expected duration: E[D] = (O + 4M + P) / 6
• Variance: Var(D) = ((P - O) / 6)^2

Selected initiatives

• Selected set (after optimization): [1, 4, 7]
• Objective value (sum EV): $XXX
• Total effort: YY person-weeks

Timeline (aggregated)

• Median completion date: YYYY-MM-DD
• p80 completion date: YYYY-MM-DD
• Gantt: (rendered)

Risks & critical path

• Critical path: [2 → 4 → 7]
• Key risks: [feature 4 integration risk, dependency on partner X]
• Mitigation actions: [investigate API, schedule spike 2 weeks prior]

Recommendations (auto-generated)

• Kick off spikes for high-uncertainty items: [7]
• Re-evaluate in 2-week sprint: [1, 4]
• Reserve contingency buffer of 15% capacity for unforeseen issues

Example walkthrough (small dataset)

Initiatives:

• A: R=1000, I=2, C=0.8, E=4 pw, O=1, M=2, P=5, V=R×I=2000
• B: R=200, I=10, C=0.6, E=6 pw, O=2, M=4, P=8, V=2000
• C: R=500, I=3, C=0.9, E=3 pw, O=1, M=1.5, P=3, V=1500

RICE:

• RICE_A = (1000×2×0.8)/4 = 400
• RICE_B = (200×10×0.6)/6 = 200
• RICE_C = (500×3×0.9)/3 = 450

If capacity = 8 pw, select subset maximizing EV (approx EV ≈ V×C):

• EV_A = 2000×0.8 = 1600
• EV_B = 2000×0.6 = 1200
• EV_C = 1500×0.9 = 1350

Feasible combinations:

• A + C effort = 7 ≤ 8; EV = 2950
• B + C effort = 9 > 8 infeasible
• A + B effort = 10 infeasible
  So pick A + C.

Duration (PERT E[D]):

• A: (1 + 4×2 + 5)/6 = (1 + 8 + 5)/6 = 14/6 ≈ 2.33 pw
• C: (1 + 4×1.5 + 3)/6 = (1 + 6 + 3)/6 = 10/6 ≈ 1.67 pw

Run Monte Carlo if there are many dependencies and resource contention; aggregate to produce p50/p80.

Algorithms / Pseudocode

Priority-compute + selection (high-level):

INPUT: initiatives[], capacity, scoring_method
for each i in initiatives:
    normalize attributes as needed
    compute priority_score[i] using scoring_method
    compute EV[i] = Value[i] * Confidence[i]   # risk-adjusted value
# Solve 0/1 knapsack (or ILP) to maximize Σ EV[i] x[i] subject to Σ effort[i] x[i] ≤ capacity
selected = solve_ILP(EV, effort, capacity)
# For selected initiatives compute durations, run simulation and schedule
for run in 1..N:
    for each i in selected:
        D[i] = sample_duration(i)  # PERT/triangular
    schedule = schedule_with_resources(selected, D, priorities)
    record run results
aggregate results => percentiles
OUTPUT selected, schedule, percentiles, critical_path

Monte Carlo sampling (PERT) sample function:

# approximate PERT by Beta distribution mapped to [O,P]
alpha = ((M - O) * (2 * M - O - P)) / ((M - O) * (P - O))
beta  = alpha * (P - M) / (M - O)
sample = O + beta_dist_sample(alpha, beta) * (P - O)

(Use libraries to avoid numerical pitfalls or use triangular/simple distributions.)

Visualizations & UX

• Gantt chart with p10/p50/p80 shading bands for each bar
• Swimlanes by team/owner
• Interactive slider for confidence target (e.g., show p50 vs p80 roadmap)
• Priority list view (sortable by RICE, WSJF, EV)
• Dependency graph (DAG) with critical path highlighted
• “What-if” toggles: increase capacity, add budget, change confidence, include/exclude an initiative
• Export: CSV, JSON, PDF

Implementation notes & tooling

• Languages: Python (pandas, numpy, scipy), TypeScript (frontend)
• Schedulers: OR-Tools, PuLP/CBC for ILP, Gurobi/CPLEX for speed at scale
• Monte Carlo: numpy.random or scipy.stats; use vectorized sampling
• Visualization: D3, visx, or Bam-Gantt for Gantt; canvas for many items
• Persist data in relational DB (schema above) or document DB with proper indices
• API design: endpoints to submit initiatives, run solve, fetch schedule/results
• Performance: sample size default 5k–10k; parallelize simulations; cache sample seeds

Best practices for founders (concise & authoritative)

1. Define outcomes, not features

   • Roadmaps should express business outcomes and metrics (revenue uplift, retention, activation) not just feature checklists.

2. Quantify value early

   • Capture reach and impact estimates for every initiative. Use conservative baselines and surface uncertainty.

3. Prioritize by expected value and cost of delay

   • Use risk-adjusted EV and WSJF to incorporate urgency. Make CoD explicit it changes decisions.

4. Keep the roadmap dynamic and short-horizon

   • Treat the first 3 months as commitments, 3–9 months as probable, 9+ months as directional. Re-evaluate every sprint.

5. Model uncertainty

   • Use three-point estimates and Monte Carlo. Communicate confidence bands rather than single deterministic dates.

6. Solve for portfolio, not pointwise

   • Optimize selections under resource and budget constraints. Greedy lists lead to local-optima waste.

7. Reserve contingency capacity

   • Hold 10–20% capacity for research, unplanned work, and integration unknowns. Avoid 100% allocation.

8. Prioritize learning early

   • For high-uncertainty items, schedule short spikes/experiments to reduce variance before committing large effort.

9. Make dependencies explicit

   • Represent and track upstream/downstream dependencies; they often drive schedule risk more than absolute effort.

10. Use objective scoring, but permit strategic override

    • Scores reduce bias. Founders should retain the power to override with documented rationale tied to outcomes.

11. Communicate with precision

    • Share p50/p80 dates, critical-path items, key assumptions, and leading indicators. Update stakeholders on model changes.

12. Instrument outcomes and close the loop

    • Track metrics post-launch. Feed actual value and duration back to the model to recalibrate estimates and priors.

13. Start simple; iterate complexity

    • Begin with RICE + PERT + greedy scheduler. Add ILP, resource leveling, and Monte Carlo as data and stakeholders justify complexity.

Appendix: Quick reference formulas

• RICE = (R × I × C) / E
• WSJF = CoD / JobSize
• EV = Value × p_success
• PERT E[D] = (O + 4M + P) / 6
• PERT Var(D) = ((P - O) / 6)^2
• Runway (months) = Cash_on_hand / Monthly_burn
• ILP: maximize Σ v_i x_i subject to Σ effort_i x_i ≤ capacity and x_i ∈ {0,1}

If you want, I can:

• Produce a ready-to-run Python prototype implementing scoring + ILP + Monte Carlo + CPM for a sample dataset.
• Convert the template into a JSON schema for API use.
• Create a mockup of the UI views (Gantt + confidence bands + priority list).