Agile and Scrum in Practice

// The Scrum events of a two-week Sprint, booked in Austin time, seen from both sites.
// Austin works 08:00–17:00 America/Chicago; India works 11:00–20:00 Asia/Kolkata.
const zones = { Austin: "America/Chicago", India: "Asia/Kolkata" };
const hours = { Austin: [8 * 60, 17 * 60], India: [11 * 60, 20 * 60] };

function offsetMinutes(zone, instant) {
  const name = new Intl.DateTimeFormat("en-US", { timeZone: zone, timeZoneName: "longOffset" })
    .formatToParts(instant).find((p) => p.type === "timeZoneName").value;
  const m = name.match(/GMT([+-])(\d\d):(\d\d)/);
  return m ? (m[1] === "-" ? -1 : 1) * (Number(m[2]) * 60 + Number(m[3])) : 0;
}
function wallToInstant(date, time, zone) {
  const asIfUtc = Date.parse(`${date}T${time}:00Z`);
  let guess = asIfUtc - offsetMinutes(zone, new Date(asIfUtc)) * 60_000;
  guess = asIfUtc - offsetMinutes(zone, new Date(guess)) * 60_000;
  return new Date(guess);
}
const minuteOfDay = (zone, t) => {
  const [h, m] = new Intl.DateTimeFormat("en-GB", { timeZone: zone, hour: "2-digit", minute: "2-digit", hourCycle: "h23" })
    .format(t).split(":").map(Number);
  return h * 60 + m;
};
// Minutes of the event that fall outside a site's working day (events here never cross midnight locally).
const outside = (site, start, minutes) => {
  const from = minuteOfDay(zones[site], start), to = from + minutes;
  return Math.max(0, hours[site][0] - from) + Math.max(0, to - hours[site][1]);
};
const hhmm = (site, t) => new Intl.DateTimeFormat("en-GB", { timeZone: zones[site], hour: "2-digit", minute: "2-digit", hourCycle: "h23" }).format(t);

const events = [ // [name, day of the Sprint (0 = first Monday), Austin start, minutes, how many times]
  ["Sprint Planning", 0, "07:00", 90, 1],
  ["Daily Scrum", 1, "08:00", 15, 8], // the other weekdays, except Planning day and the last day
  ["Refinement", 7, "08:15", 45, 1],
  ["Sprint Review", 11, "07:00", 60, 1],
  ["Sprint Retrospective", 11, "08:00", 60, 1],
];

for (const monday of ["2026-10-19", "2026-11-02"]) { // before and after US clocks go back on 1 November
  const late = { Austin: 0, India: 0 };
  console.log(`Sprint starting ${monday}`);
  for (const [name, day, time, minutes, times] of events) {
    const date = new Date(Date.parse(`${monday}T12:00:00Z`) + day * 86_400_000).toISOString().slice(0, 10);
    const start = wallToInstant(date, time, zones.Austin), end = new Date(start.getTime() + minutes * 60_000);
    const cost = Object.fromEntries(Object.keys(zones).map((s) => [s, outside(s, start, minutes)]));
    for (const s of Object.keys(late)) late[s] += cost[s] * times;
    const note = Object.entries(cost).filter(([, m]) => m).map(([s, m]) => `${s} +${m} min`).join(", ") || "inside both days";
    console.log(`  ${name.padEnd(21)} Austin ${hhmm("Austin", start)}–${hhmm("Austin", end)}  India ${hhmm("India", start)}–${hhmm("India", end)}  ${note}`);
  }
  console.log(`  Minutes outside working hours this Sprint: Austin ${late.Austin}, India ${late.India}`);
}

Sprint starting 2026-10-19
  Sprint Planning       Austin 07:00–08:30  India 17:30–19:00  Austin +60 min
  Daily Scrum           Austin 08:00–08:15  India 18:30–18:45  inside both days
  Refinement            Austin 08:15–09:00  India 18:45–19:30  inside both days
  Sprint Review         Austin 07:00–08:00  India 17:30–18:30  Austin +60 min
  Sprint Retrospective  Austin 08:00–09:00  India 18:30–19:30  inside both days
  Minutes outside working hours this Sprint: Austin 120, India 0
Sprint starting 2026-11-02
  Sprint Planning       Austin 07:00–08:30  India 18:30–20:00  Austin +60 min
  Daily Scrum           Austin 08:00–08:15  India 19:30–19:45  inside both days
  Refinement            Austin 08:15–09:00  India 19:45–20:30  India +30 min
  Sprint Review         Austin 07:00–08:00  India 18:30–19:30  Austin +60 min
  Sprint Retrospective  Austin 08:00–09:00  India 19:30–20:30  India +30 min
  Minutes outside working hours this Sprint: Austin 120, India 60

# SPIKE: Can the web UI read call statistics from the device's local API?
Question:     Which endpoint, if any, returns live call statistics, and at what rate can we poll it?
Why now:      UI-240 (call stats panel) can't be sized until we know.
Timebox:      1.5 days, Dev 2. Stop at the timebox even if unfinished; report what's known.
Output:       a short note in the ticket: endpoints found, sample responses, limits observed,
              a recommendation, and the size of UI-240 re-estimated by the team.
Not in scope: building the panel; production-quality code (throwaway scripts are fine).

Too big (estimated 20+ by everyone, nobody agrees why):
  "Admins can manage device firmware"

Split by workflow step, each one usable and demoable on its own:
  1. Admins can see each device's current firmware version in the device list         (3)
  2. Admins can filter the list by firmware version                                      (2)
  3. Admins can start an update on one device and see its progress                       (5)
  4. Admins can schedule an update for a group of devices at a chosen time               (5)
  5. Admins get a report of devices whose update failed, with the device's error         (3)
Split out as its own item, because nobody knew the answer:
  SPIKE: How does the device report update progress (poll, push, or neither)?   (timebox 1 day)
Deferred by the Product Owner (not needed for the first release):
  Rolling back to the previous firmware from the UI

// "When will these 40 backlog items be done?" A Monte Carlo forecast from past throughput (seeded, so repeatable).
function mulberry32(seed) {
  return () => {
    seed |= 0; seed = (seed + 0x6d2b79f5) | 0;
    let t = Math.imul(seed ^ (seed >>> 15), 1 | seed);
    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
  };
}
const random = mulberry32(42);

const throughput = [5, 7, 4, 6, 6, 3, 7, 5]; // items Done per Sprint, last eight Sprints
const remaining = 40;
const trials = 10_000;

const sprintsNeeded = [];
for (let t = 0; t < trials; t++) {
  let done = 0, sprints = 0;
  while (done < remaining) {
    done += throughput[Math.floor(random() * throughput.length)]; // replay a random past Sprint
    sprints++;
  }
  sprintsNeeded.push(sprints);
}
sprintsNeeded.sort((a, b) => a - b);
const pct = (p) => sprintsNeeded[Math.ceil((p / 100) * trials) - 1];

const avg = throughput.reduce((a, b) => a + b, 0) / throughput.length;
console.log(`Average throughput ${avg} items/Sprint → "${Math.ceil(remaining / avg)} Sprints" if you divide`);
for (const p of [50, 85, 95]) console.log(`${p}% of simulated futures finish within ${pct(p)} Sprints`);
for (const n of [7, 8, 9]) {
  const share = sprintsNeeded.filter((s) => s <= n).length / trials;
  console.log(`Chance of finishing within ${n} Sprints: ${Math.round(share * 100)}%`);
}

const counts = {};
for (const s of sprintsNeeded) counts[s] = (counts[s] ?? 0) + 1;
for (const [s, n] of Object.entries(counts)) console.log(`${s.padStart(2)} Sprints ${"#".repeat(Math.round(n / 100))} ${n}`);

Average throughput 5.375 items/Sprint → "8 Sprints" if you divide
50% of simulated futures finish within 8 Sprints
85% of simulated futures finish within 9 Sprints
95% of simulated futures finish within 9 Sprints
Chance of finishing within 7 Sprints: 31%
Chance of finishing within 8 Sprints: 83%
Chance of finishing within 9 Sprints: 99%
 6 Sprints # 74
 7 Sprints ############################## 3010
 8 Sprints #################################################### 5215
 9 Sprints ################ 1561
10 Sprints # 137
11 Sprints  3

// What happens when velocity becomes a target. Illustrative numbers: the team finishes the same six items
// every Sprint; only the estimates move, because "velocity must go up 10% a Sprint".
const items = [1, 2, 3, 3, 5, 8]; // honest sizes, in points, of the work Done each Sprint

console.log("Sprint  items  points  growth");
let inflation = 1;
let prev = null;
for (let sprint = 1; sprint <= 6; sprint++) {
  // Each Sprint every estimate gets rounded up a little more to hit the target.
  const points = items.reduce((sum, p) => sum + Math.ceil(p * inflation), 0);
  const growth = prev ? `+${Math.round(((points - prev) / prev) * 100)}%` : "";
  console.log(`${String(sprint).padStart(6)}  ${String(items.length).padStart(5)}  ${String(points).padStart(6)}  ${growth}`);
  prev = points;
  inflation *= 1.1;
}

// Two teams Done the same four items. Their point scales differ, so their velocities can't be compared.
const teams = { "Team A": [2, 3, 5, 8], "Team B": [5, 8, 13, 20] };
for (const [name, pts] of Object.entries(teams)) {
  console.log(`${name}: ${pts.length} items Done, velocity ${pts.reduce((a, b) => a + b, 0)}`);
}

Sprint  items  points  growth
     1      6      22  
     2      6      28  +27%
     3      6      30  +7%
     4      6      31  +3%
     5      6      35  +13%
     6      6      38  +9%
Team A: 4 items Done, velocity 18
Team B: 4 items Done, velocity 46

// A service level expectation from past cycle times, then the board checked against it by Work Item Age.
// Cycle time and age are counted in calendar days, inclusive (started and finished the same day = 1 day).
const pastCycleTimes = [2, 3, 3, 4, 2, 6, 5, 3, 9, 4, 3, 7, 2, 4, 5, 3, 12, 4, 6, 3]; // last 20 items Done

const sorted = [...pastCycleTimes].sort((a, b) => a - b);
const percentile = (p) => sorted[Math.ceil((p / 100) * sorted.length) - 1];
const sle = percentile(85);
console.log(`50th percentile ${percentile(50)} days, 85th ${sle} days, 95th ${percentile(95)} days`);
console.log(`SLE: 85% of items finish within ${sle} days of starting`);

const today = Date.parse("2026-10-27T00:00:00Z");
const board = [
  { id: "API-311", column: "In review", started: "2026-10-26" },
  { id: "UI-207", column: "In progress", started: "2026-10-23" },
  { id: "API-298", column: "In progress", started: "2026-10-20" },
  { id: "UI-190", column: "In review", started: "2026-10-14" },
];
for (const item of board) {
  const age = Math.round((today - Date.parse(`${item.started}T00:00:00Z`)) / 86_400_000) + 1;
  const status = age > sle ? "PAST the SLE: swarm or split it" : age >= sle - 1 ? "close to the SLE: talk about it today" : "fine";
  console.log(`${item.id.padEnd(8)} ${item.column.padEnd(12)} age ${String(age).padStart(2)} days  ${status}`);
}

50th percentile 4 days, 85th 6 days, 95th 9 days
SLE: 85% of items finish within 6 days of starting
API-311  In review    age  2 days  fine
UI-207   In progress  age  5 days  close to the SLE: talk about it today
API-298  In progress  age  8 days  PAST the SLE: swarm or split it
UI-190   In review    age 14 days  PAST the SLE: swarm or split it

// Reading a cumulative flow diagram (CFD) as numbers. Illustrative data for ten working days.
// Each array is the cumulative count of items that had ENTERED that state by the end of each day.
const started  = [4, 6, 8, 10, 12, 14, 16, 18, 20, 22]; // entered "In progress"
const inReview = [1, 3, 5, 7, 9, 11, 12, 13, 14, 15];   // entered "In review"
const done     = [0, 1, 3, 5, 7, 9, 10, 10, 11, 11];    // entered "Done"

const bar = (n, ch) => ch.repeat(n);
console.log("day  WIP  in progress | in review  (band widths = items in each state)");
for (let d = 0; d < started.length; d++) {
  const inProgress = started[d] - inReview[d];
  const reviewing = inReview[d] - done[d];
  console.log(
    `${String(d + 1).padStart(3)}  ${String(started[d] - done[d]).padStart(3)}  ` +
      `${bar(inProgress, "▒").padEnd(12)}|${bar(reviewing, "█")}`,
  );
}

// The horizontal gap between the "started" and "done" lines approximates cycle time:
// the Nth item started on day s(N) and the Nth item finished on day f(N) (first in, first out).
const dayReached = (series, n) => series.findIndex((c) => c >= n) + 1;
for (const n of [5, 10]) {
  const s = dayReached(started, n), f = dayReached(done, n);
  console.log(`item #${n}: started by day ${s}, done by day ${f} → about ${f - s} days`);
}
const throughput = (done.at(-1) - done[4]) / 5, arrivals = (started.at(-1) - started[4]) / 5;
console.log(`last 5 days: ${arrivals} started/day vs ${throughput} done/day → WIP grows by ${arrivals - throughput}/day`);

day  WIP  in progress | in review  (band widths = items in each state)
  1    4  ▒▒▒         |█
  2    5  ▒▒▒         |██
  3    5  ▒▒▒         |██
  4    5  ▒▒▒         |██
  5    5  ▒▒▒         |██
  6    5  ▒▒▒         |██
  7    6  ▒▒▒▒        |██
  8    8  ▒▒▒▒▒       |███
  9    9  ▒▒▒▒▒▒      |███
 10   11  ▒▒▒▒▒▒▒     |████
item #5: started by day 2, done by day 4 → about 2 days
item #10: started by day 4, done by day 7 → about 3 days
last 5 days: 2 started/day vs 0.8 done/day → WIP grows by 1.2/day

// An urgent request arrives on day 4 of a 10-day Sprint. What has to come out, and is the Sprint Goal still safe?
// Illustrative backlog. "goal" marks the items the Sprint Goal depends on.
const sprintGoal = "Admins can schedule a firmware update from the web UI";
const backlog = [
  { id: "FW-1", pts: 5, goal: true, state: "done" },
  { id: "FW-2", pts: 3, goal: true, state: "in progress" },
  { id: "FW-3", pts: 5, goal: true, state: "to do" },
  { id: "UI-9", pts: 3, goal: false, state: "to do" },
  { id: "UI-12", pts: 2, goal: false, state: "to do" },
  { id: "DOC-4", pts: 1, goal: false, state: "to do" },
];
const remainingCapacity = 14; // points the team expects to finish in the 6 days left (from the capacity plan)

function absorb(request) {
  const notDone = backlog.filter((i) => i.state !== "done");
  let load = notDone.reduce((s, i) => s + i.pts, 0) + request.pts;
  const out = [];
  // Drop not-started, non-goal work first, largest first; never drop goal work silently.
  for (const item of notDone.filter((i) => !i.goal && i.state === "to do").sort((a, b) => b.pts - a.pts)) {
    if (load <= remainingCapacity) break;
    out.push(item.id);
    load -= item.pts;
  }
  const safe = load <= remainingCapacity;
  console.log(`Request ${request.id} (${request.pts} pts): ${safe ? "fits" : "does NOT fit"} after removing ${out.join(", ") || "nothing"}`);
  console.log(`  load ${load} of ${remainingCapacity} pts → ${safe ? "Sprint Goal still achievable" : "Sprint Goal at risk: Product Owner decides"}`);
}

console.log(`Sprint Goal: ${sprintGoal}`);
absorb({ id: "BUG-77 (customer-facing login bug)", pts: 3 });
absorb({ id: "FEAT-5 (new client demo feature)", pts: 8 });

Sprint Goal: Admins can schedule a firmware update from the web UI
Request BUG-77 (customer-facing login bug) (3 pts): fits after removing UI-9
  load 14 of 14 pts → Sprint Goal still achievable
Request FEAT-5 (new client demo feature) (8 pts): does NOT fit after removing UI-9, UI-12, DOC-4
  load 16 of 14 pts → Sprint Goal at risk: Product Owner decides

| ID  | Question | Asked | Needed by | Default if no answer | Blocks | Answer (who, when) |
|-----|----------|-------|-----------|----------------------|--------|--------------------|
| Q-7 | Do settings changes apply without a device reboot? | 2026-10-28 | 2026-11-06 | Assume reboot may be needed; show "restart required" when the API says so | API-298, UI-207 | |
| Q-8 | Max devices per site for the first customers? | 2026-10-28 | 2026-11-06 | Build server-side paging | UI-220 | |
| Q-9 | Which firmware versions must the web UI support? | 2026-10-29 | 2026-11-13 | The last three releases | test matrix | Client PM, 2026-10-30: 9.8, 10.1, 10.2 |

Thanks, understood: <new item> is now more important than <current goal / item>.
Impact if we switch now:
- <current item> stops at <state>; picking it up later costs about <time to resume>.
- The Sprint Goal "<goal>" won't be met this Sprint / is still achievable if we drop <items>.
- Assumptions this depends on: <A2, A3 from the log>, not yet confirmed.
Options:
1. Switch now: we start <new item> today (India team picks it up tomorrow morning IST).
2. Switch at the Sprint boundary on <date>: current goal finishes, <new item> starts then.
Recommendation: <1 or 2, one sentence why>. Product Owner to decide by <time, with time zone>.

- [ ] Title says the outcome: "Admins can filter devices by firmware version", not "Device filter"
- [ ] Why: who needs it and what it's for, in two lines
- [ ] Acceptance criteria as checkable statements (Given / When / Then where behaviour matters)
- [ ] Sized by the Developers, small enough to finish in a few days (else split it)
- [ ] Dependencies named: API endpoint exists? Design ready? Client decision needed?
- [ ] Open questions either answered or listed in the assumptions log with a default
- [ ] How it will be tested is clear (unit, contract, e2e, device-in-the-loop?)

// Are retrospectives changing anything? Track their actions across Sprints. Illustrative data.
const retros = [
  { sprint: 21, actions: [
    { what: "Post the API contract before UI work starts", owner: "Lead", theme: "handoffs", done: true },
    { what: "Fix the flaky device-simulator test", owner: "Dev 2", theme: "ci", done: false },
    { what: "Shorter Daily Scrum", owner: "Team", theme: "meetings", done: false } ] },
  { sprint: 22, actions: [
    { what: "Fix the flaky device-simulator test", owner: "Dev 2", theme: "ci", done: false },
    { what: "Write a handoff note at the end of the India day", owner: "Dev 3", theme: "handoffs", done: true } ] },
  { sprint: 23, actions: [
    { what: "Fix the flaky device-simulator test", owner: "Dev 4", theme: "ci", done: true },
    { what: "Agree review turnaround: first review within one working day", owner: "Lead", theme: "reviews", done: true },
    { what: "Improve communication", owner: "Team", theme: "handoffs", done: false } ] },
];

let total = 0, done = 0;
const seen = new Map();
for (const r of retros) {
  for (const a of r.actions) {
    total++;
    if (a.done) done++;
    seen.set(a.what, (seen.get(a.what) ?? 0) + 1);
  }
}
console.log(`Actions done: ${done} of ${total} (${Math.round((done / total) * 100)}%)`);
for (const [what, n] of seen) if (n > 1) console.log(`In ${n} retros in a row: "${what}"`);

// "Team" owns nothing: an action needs one named owner.
const unowned = retros.flatMap((r) => r.actions).filter((a) => a.owner === "Team" && !a.done);
for (const a of unowned) console.log(`No single owner, and never done: "${a.what}"`);

const themes = {};
for (const r of retros) for (const t of new Set(r.actions.map((a) => a.theme))) themes[t] = (themes[t] ?? 0) + 1;
for (const [t, n] of Object.entries(themes)) if (n === retros.length) console.log(`Theme in every retro: ${t}`);

Actions done: 4 of 8 (50%)
In 3 retros in a row: "Fix the flaky device-simulator test"
No single owner, and never done: "Shorter Daily Scrum"
No single owner, and never done: "Improve communication"
Theme in every retro: handoffs
Theme in every retro: ci