# A Scrum sprint, from planning to retrospective

> A process map exported from forks.world (https://forks.world). Author: Brian. Source: https://forks.world/p/cmv0kq1g3001sjv06pdm7531l
> It describes who does what, in what order, and with which technology. Read the plain-language sections first; the JSON at the end is the exact, complete data.

## Summary

- 25 steps across 4 layers
- Persona: Product Owner, Scrum Master, Developers, Stakeholders
- Technology / systems: The sprint board

## Pain points

Where this process hurts, worst first:

- **Remove the blocker** (Inside the sprint; annoying): Blockers are the whole point of the daily scrum

## How to read this file

- A process is made of **layers**. The main layer is the top level; any step of kind `subprocess` opens a detail layer with its own lanes and steps.
- **Lanes** are either persona (people/roles) or technology (systems). Each step belongs to one lane; `using` lists tools a person uses for that step.
- Step kinds: `start`, `task`, `decision` (its arrows carry the answer as a label), `subprocess`, `end`.

## A Scrum sprint, from planning to retrospective

Lanes:
- Product Owner: person / role (id `po`)
- Scrum Master: person / role (id `sm`)
- Developers: person / role (id `dev`)
- Stakeholders: person / role (id `stake`)
- The sprint board: technology / system (id `board`)

Steps, in the order they run:

1. **The product backlog is ordered by value** [start; Product Owner; id `s1`]
   - then Sprint planning: pick what fits and set a sprint goal
2. **Sprint planning: pick what fits and set a sprint goal** [subprocess; Developers; id `s2`], opens the detail layer "Sprint planning"
   - then Work through the sprint: build, test, repeat
3. **Work through the sprint: build, test, repeat** [subprocess; Developers; id `s3`], opens the detail layer "Inside the sprint"
   - then Sprint review: see the working increment
4. **Sprint review: see the working increment** [task; Stakeholders; id `s4`]
   - then Feedback updates the backlog
5. **Feedback updates the backlog** [task; Product Owner; id `s5`]
   - then Retrospective: how can we work better?
6. **Retrospective: how can we work better?** [subprocess; Scrum Master; id `s6`], opens the detail layer "The retrospective"
   - then Is the product goal met?
7. **Is the product goal met?** [decision; Product Owner; id `s7`]
   - if "Yes" go to Release and celebrate; if "No" go to Plan the next sprint
8. **Release and celebrate** [end; Stakeholders; id `s8`]
9. **Plan the next sprint** [task; Product Owner; id `s9`]
   - then Sprint planning: pick what fits and set a sprint goal

```mermaid
flowchart LR
  subgraph l_po["Product Owner"]
    n_s1(["The product backlog is ordered by value"])
    n_s5["Feedback updates the backlog"]
    n_s7{"Is the product goal met?"}
    n_s9["Plan the next sprint"]
  end
  subgraph l_sm["Scrum Master"]
    n_s6[["Retrospective: how can we work better?"]]
  end
  subgraph l_dev["Developers"]
    n_s2[["Sprint planning: pick what fits and set a sprint goal"]]
    n_s3[["Work through the sprint: build, test, repeat"]]
  end
  subgraph l_stake["Stakeholders"]
    n_s4["Sprint review: see the working increment"]
    n_s8(["Release and celebrate"])
  end
  n_s1 --> n_s2
  n_s2 --> n_s3
  n_s3 --> n_s4
  n_s4 --> n_s5
  n_s5 --> n_s6
  n_s6 --> n_s7
  n_s7 -->|"Yes"| n_s8
  n_s7 -->|"No"| n_s9
  n_s9 --> n_s2
```

### The retrospective (detail of step "Retrospective: how can we work better?")

Lanes:
- Scrum Master: person / role (id `sm`)
- Developers: person / role (id `dev`)

Steps, in the order they run:

1. **What went well?** [start; Scrum Master; id `r1`]
   - then What did not?
2. **What did not?** [task; Developers; id `r2`]
   - then Pick one improvement to try
3. **Pick one improvement to try** [task; Developers; id `r3`]
   - then Add it to the next sprint
4. **Add it to the next sprint** [end; Scrum Master; id `r4`]

```mermaid
flowchart LR
  subgraph l_sm["Scrum Master"]
    n_r1(["What went well?"])
    n_r4(["Add it to the next sprint"])
  end
  subgraph l_dev["Developers"]
    n_r2["What did not?"]
    n_r3["Pick one improvement to try"]
  end
  n_r1 --> n_r2
  n_r2 --> n_r3
  n_r3 --> n_r4
```

### Inside the sprint (detail of step "Work through the sprint: build, test, repeat")

Lanes:
- Developers: person / role (id `dev`)
- Scrum Master: person / role (id `sm`)
- The sprint board: technology / system (id `board`)

Steps, in the order they run:

1. **Daily scrum: what I did, what I will do, what blocks me** [start; Developers; id `sp1`]
   - then Is anything blocked?
2. **Is anything blocked?** [decision; Developers; id `sp2`]
   - if "Yes" go to Remove the blocker; if "No" go to Build and test items until they are done
3. **Remove the blocker** [task; Scrum Master; id `sp3`] ⚠ PAIN POINT (annoying): Blockers are the whole point of the daily scrum
   - then Build and test items until they are done
4. **Build and test items until they are done** [task; Developers; id `sp4`]
   - then Move the cards across the board
5. **Move the cards across the board** [task; The sprint board; id `sp5`]
   - then Is the sprint over?
6. **Is the sprint over?** [decision; Developers; id `sp6`]
   - if "Yes" go to A potentially releasable increment; if "No" go to Daily scrum: what I did, what I will do, what blocks me
7. **A potentially releasable increment** [end; Developers; id `sp7`]

```mermaid
flowchart LR
  subgraph l_dev["Developers"]
    n_sp1(["Daily scrum: what I did, what I will do, what blocks me"])
    n_sp2{"Is anything blocked?"}
    n_sp4["Build and test items until they are done"]
    n_sp6{"Is the sprint over?"}
    n_sp7(["A potentially releasable increment"])
  end
  subgraph l_sm["Scrum Master"]
    n_sp3["Remove the blocker"]
  end
  subgraph l_board["The sprint board"]
    n_sp5["Move the cards across the board"]
  end
  n_sp1 --> n_sp2
  n_sp2 -->|"Yes"| n_sp3
  n_sp2 -->|"No"| n_sp4
  n_sp3 --> n_sp4
  n_sp4 --> n_sp5
  n_sp5 --> n_sp6
  n_sp6 -->|"Yes"| n_sp7
  n_sp6 -->|"No"| n_sp1
```

### Sprint planning (detail of step "Sprint planning: pick what fits and set a sprint goal")

Lanes:
- Product Owner: person / role (id `po`)
- Developers: person / role (id `dev`)

Steps, in the order they run:

1. **Explain the top backlog items** [start; Product Owner; id `pl1`]
   - then Ask questions and estimate
2. **Ask questions and estimate** [task; Developers; id `pl2`]
   - then Does it fit this sprint?
3. **Does it fit this sprint?** [decision; Developers; id `pl3`]
   - if "Yes" go to Agree the sprint goal; if "No" go to Take less, or split an item
4. **Agree the sprint goal** [end; Developers; id `pl4`]
5. **Take less, or split an item** [task; Developers; id `pl3a`]
   - then Does it fit this sprint?

```mermaid
flowchart LR
  subgraph l_po["Product Owner"]
    n_pl1(["Explain the top backlog items"])
  end
  subgraph l_dev["Developers"]
    n_pl2["Ask questions and estimate"]
    n_pl3{"Does it fit this sprint?"}
    n_pl3a["Take less, or split an item"]
    n_pl4(["Agree the sprint goal"])
  end
  n_pl1 --> n_pl2
  n_pl2 --> n_pl3
  n_pl3 -->|"Yes"| n_pl4
  n_pl3 -->|"No"| n_pl3a
  n_pl3a --> n_pl3
```

## Full data (JSON)

```json
{
  "title": "A Scrum sprint, from planning to retrospective",
  "maps": {
    "m_root": {
      "id": "m_root",
      "lanes": [
        {
          "id": "po",
          "name": "Product Owner",
          "type": "person"
        },
        {
          "id": "sm",
          "name": "Scrum Master",
          "type": "person"
        },
        {
          "id": "dev",
          "name": "Developers",
          "type": "person"
        },
        {
          "id": "stake",
          "name": "Stakeholders",
          "type": "person"
        },
        {
          "id": "board",
          "name": "The sprint board",
          "type": "system"
        }
      ],
      "steps": [
        {
          "id": "s1",
          "kind": "start",
          "lane": "po",
          "next": [
            {
              "to": "s2"
            }
          ],
          "uses": [],
          "label": "The product backlog is ordered by value"
        },
        {
          "id": "s2",
          "kind": "subprocess",
          "lane": "dev",
          "next": [
            {
              "to": "s3"
            }
          ],
          "uses": [],
          "child": "m_planning",
          "label": "Sprint planning: pick what fits and set a sprint goal"
        },
        {
          "id": "s3",
          "kind": "subprocess",
          "lane": "dev",
          "next": [
            {
              "to": "s4"
            }
          ],
          "uses": [],
          "child": "m_sprint",
          "label": "Work through the sprint: build, test, repeat"
        },
        {
          "id": "s4",
          "kind": "task",
          "lane": "stake",
          "next": [
            {
              "to": "s5"
            }
          ],
          "uses": [],
          "label": "Sprint review: see the working increment"
        },
        {
          "id": "s5",
          "kind": "task",
          "lane": "po",
          "next": [
            {
              "to": "s6"
            }
          ],
          "uses": [],
          "label": "Feedback updates the backlog"
        },
        {
          "id": "s6",
          "kind": "subprocess",
          "lane": "sm",
          "next": [
            {
              "to": "s7"
            }
          ],
          "uses": [],
          "child": "m_retro",
          "label": "Retrospective: how can we work better?"
        },
        {
          "id": "s7",
          "kind": "decision",
          "lane": "po",
          "next": [
            {
              "to": "s8",
              "label": "Yes"
            },
            {
              "to": "s9",
              "label": "No"
            }
          ],
          "uses": [],
          "label": "Is the product goal met?"
        },
        {
          "id": "s9",
          "kind": "task",
          "lane": "po",
          "next": [
            {
              "to": "s2"
            }
          ],
          "uses": [],
          "label": "Plan the next sprint"
        },
        {
          "id": "s8",
          "kind": "end",
          "lane": "stake",
          "next": [],
          "uses": [],
          "label": "Release and celebrate"
        }
      ],
      "title": "A Scrum sprint, from planning to retrospective",
      "parent": null
    },
    "m_retro": {
      "id": "m_retro",
      "lanes": [
        {
          "id": "sm",
          "name": "Scrum Master",
          "type": "person"
        },
        {
          "id": "dev",
          "name": "Developers",
          "type": "person"
        }
      ],
      "steps": [
        {
          "id": "r1",
          "kind": "start",
          "lane": "sm",
          "next": [
            {
              "to": "r2"
            }
          ],
          "uses": [],
          "label": "What went well?"
        },
        {
          "id": "r2",
          "kind": "task",
          "lane": "dev",
          "next": [
            {
              "to": "r3"
            }
          ],
          "uses": [],
          "label": "What did not?"
        },
        {
          "id": "r3",
          "kind": "task",
          "lane": "dev",
          "next": [
            {
              "to": "r4"
            }
          ],
          "uses": [],
          "label": "Pick one improvement to try"
        },
        {
          "id": "r4",
          "kind": "end",
          "lane": "sm",
          "next": [],
          "uses": [],
          "label": "Add it to the next sprint"
        }
      ],
      "title": "The retrospective",
      "parent": {
        "map": "m_root",
        "step": "s6"
      }
    },
    "m_sprint": {
      "id": "m_sprint",
      "lanes": [
        {
          "id": "dev",
          "name": "Developers",
          "type": "person"
        },
        {
          "id": "sm",
          "name": "Scrum Master",
          "type": "person"
        },
        {
          "id": "board",
          "name": "The sprint board",
          "type": "system"
        }
      ],
      "steps": [
        {
          "id": "sp1",
          "kind": "start",
          "lane": "dev",
          "next": [
            {
              "to": "sp2"
            }
          ],
          "uses": [],
          "label": "Daily scrum: what I did, what I will do, what blocks me"
        },
        {
          "id": "sp2",
          "kind": "decision",
          "lane": "dev",
          "next": [
            {
              "to": "sp3",
              "label": "Yes"
            },
            {
              "to": "sp4",
              "label": "No"
            }
          ],
          "uses": [],
          "label": "Is anything blocked?"
        },
        {
          "id": "sp3",
          "kind": "task",
          "lane": "sm",
          "next": [
            {
              "to": "sp4"
            }
          ],
          "pain": {
            "note": "Blockers are the whole point of the daily scrum",
            "level": 1
          },
          "uses": [],
          "label": "Remove the blocker"
        },
        {
          "id": "sp4",
          "kind": "task",
          "lane": "dev",
          "next": [
            {
              "to": "sp5"
            }
          ],
          "uses": [],
          "label": "Build and test items until they are done"
        },
        {
          "id": "sp5",
          "kind": "task",
          "lane": "board",
          "next": [
            {
              "to": "sp6"
            }
          ],
          "uses": [],
          "label": "Move the cards across the board"
        },
        {
          "id": "sp6",
          "kind": "decision",
          "lane": "dev",
          "next": [
            {
              "to": "sp7",
              "label": "Yes"
            },
            {
              "to": "sp1",
              "label": "No"
            }
          ],
          "uses": [],
          "label": "Is the sprint over?"
        },
        {
          "id": "sp7",
          "kind": "end",
          "lane": "dev",
          "next": [],
          "uses": [],
          "label": "A potentially releasable increment"
        }
      ],
      "title": "Inside the sprint",
      "parent": {
        "map": "m_root",
        "step": "s3"
      }
    },
    "m_planning": {
      "id": "m_planning",
      "lanes": [
        {
          "id": "po",
          "name": "Product Owner",
          "type": "person"
        },
        {
          "id": "dev",
          "name": "Developers",
          "type": "person"
        }
      ],
      "steps": [
        {
          "id": "pl1",
          "kind": "start",
          "lane": "po",
          "next": [
            {
              "to": "pl2"
            }
          ],
          "uses": [],
          "label": "Explain the top backlog items"
        },
        {
          "id": "pl2",
          "kind": "task",
          "lane": "dev",
          "next": [
            {
              "to": "pl3"
            }
          ],
          "uses": [],
          "label": "Ask questions and estimate"
        },
        {
          "id": "pl3",
          "kind": "decision",
          "lane": "dev",
          "next": [
            {
              "to": "pl4",
              "label": "Yes"
            },
            {
              "to": "pl3a",
              "label": "No"
            }
          ],
          "uses": [],
          "label": "Does it fit this sprint?"
        },
        {
          "id": "pl3a",
          "kind": "task",
          "lane": "dev",
          "next": [
            {
              "to": "pl3"
            }
          ],
          "uses": [],
          "label": "Take less, or split an item"
        },
        {
          "id": "pl4",
          "kind": "end",
          "lane": "dev",
          "next": [],
          "uses": [],
          "label": "Agree the sprint goal"
        }
      ],
      "title": "Sprint planning",
      "parent": {
        "map": "m_root",
        "step": "s2"
      }
    }
  }
}
```