story-mapping

What this skill does

# User Story Mapping Expert

## Overview

Visualize the user journey and translate strategy into prioritized, deliverable work using Jeff Patton's user story mapping technique. Story maps shift teams from feature-first thinking to flow-first thinking -- understanding the complete user experience before deciding what to build and in what order.

### When to Use

- **MVP definition** -- When you need to draw a clear line between "must ship" and "can wait."
- **Release planning** -- When sequencing work across multiple releases or sprints.
- **Cross-team alignment** -- When multiple teams need a shared understanding of the user journey.
- **Backlog reorganization** -- When a flat backlog has lost context and priority clarity.
- **New product kickoff** -- When starting from scratch and need to decompose a vision into work.

### When NOT to Use

- When work is purely technical infrastructure with no user journey (use technical spikes instead).
- When the team already has a well-prioritized, context-rich backlog.
- For single-feature work that doesn't span multiple user activities.

## Story Map Anatomy

A story map has three layers arranged in a 2D grid:

```
                    USER JOURNEY (left to right) →
                    
    ┌──────────────────────────────────────────────────┐
    │  Activities    Activity 1    Activity 2    Act 3  │  ← Backbone
    ├──────────────────────────────────────────────────┤
    │  Steps         Step 1.1      Step 2.1     Step   │  ← Backbone
    │                Step 1.2      Step 2.2      3.1   │
    ├──────────────────────────────────────────────────┤
    │  Tasks         Task A        Task D       Task G │  ← Body
    │  (Release 1)   Task B        Task E              │  ← MVP line
    │  ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ │
    │  Tasks         Task C        Task F       Task H │  ← Body
    │  (Release 2)                                     │  ← Follow-up
    └──────────────────────────────────────────────────┘
    
    PRIORITY (top to bottom) ↓
```

| Layer | What It Contains | Granularity |
|---|---|---|
| **Activities** | High-level user goals (what are they trying to accomplish?) | Epic-level |
| **Steps** | Sequential actions within each activity | Feature-level |
| **Tasks** | Specific implementation items for each step | Story-level |

### Key Principle: Flow First, Then Priority

- **Horizontal axis (left to right):** The user's journey through time -- activities and steps in the order users experience them.
- **Vertical axis (top to bottom):** Priority -- most critical tasks at the top, nice-to-haves at the bottom.
- **MVP line:** A horizontal line drawn across the map separating "Release 1" from "Later."

## Building a Story Map

### Step 1: Define Who and What

| Element | Description |
|---|---|
| **Segment** | The target user segment for this map |
| **Persona** | The specific persona experiencing this journey |
| **Narrative/JTBD** | The job or goal the user is trying to accomplish |
| **Decision** | What this map should inform (MVP scope, release plan, sequencing) |

### Step 2: Map the Backbone (Activities)

Walk through the user's journey and identify 3-7 high-level activities:

```markdown
#### Activities:
1. [Discover the product]
2. [Sign up and onboard]
3. [Complete core task]
4. [Review results]
5. [Share with team]
```

**Tips:**
- Use active verbs ("Discover," "Configure," "Review") not nouns.
- Keep to 3-7 activities -- more means you need to zoom out.
- Arrange left to right in the order users experience them.

### Step 3: Break Activities into Steps

For each activity, identify 3-5 sequential steps:

```markdown
#### Steps for "Sign up and onboard":
- Step 1: Create account
- Step 2: Verify email
- Step 3: Set up profile
- Step 4: Complete tutorial
- Step 5: Invite team members
```

### Step 4: Decompose Steps into Tasks

For each step, list specific implementation tasks:

```markdown
#### Tasks for "Create account":
- Email/password registration
- Social login (Google, GitHub)
- SSO integration
- Terms acceptance
- Password strength validation
```

### Step 5: Prioritize Vertically

Arrange tasks within each column from top (highest priority) to bottom (lowest):

- **Top:** Must-have for the journey to work at all.
- **Middle:** Important for a good experience.
- **Bottom:** Nice-to-have, can defer.

### Step 6: Draw Release Lines

Draw horizontal lines across the map to define releases:

```
═══════════════════════════ Release 1 (MVP) ═══════════
- Email/password registration
- Verify email
- Basic profile setup
- Core task (minimal)
- View results

═══════════════════════════ Release 2 ═══════════════════
- Social login
- Team invitations
- Advanced tutorial
- Share results
- Export results

═══════════════════════════ Release 3 (Polish) ══════════
- SSO integration
- Custom branding
- Advanced analytics
- API access
```

## Story Map Template

```markdown
## User Story Map

### Context
- **Segment:** [Target segment]
- **Persona:** [Persona name and key characteristics]
- **Narrative:** [The job or goal being mapped]
- **Decision:** [What this map informs]

### Backbone

#### Activities:
1. [Activity 1]
2. [Activity 2]
3. [Activity 3]
4. [Activity 4]
5. [Activity 5]

#### Steps:
**[Activity 1]:**
- Step 1: [Description]
- Step 2: [Description]
- Step 3: [Description]

**[Activity 2]:**
- Step 1: [Description]
- Step 2: [Description]
- Step 3: [Description]

[Continue for each activity]

#### Tasks:
**[Activity 1, Step 1]:**
- Task 1: [Description]
- Task 2: [Description]
- Task 3: [Description]

[Continue for each step]

### Release Slices

**Release 1 (MVP):**
- [Task list -- minimum viable journey]

**Release 2:**
- [Task list -- improved experience]

**Release 3:**
- [Task list -- full vision]

### Assumptions to Validate
- [Assumption 1]
- [Assumption 2]
- [Assumption 3]

### Risks and Dependencies
- [Risk or dependency 1]
- [Risk or dependency 2]
```

## Common Story Map Patterns

### Pattern 1: Walking Skeleton

Map the thinnest possible end-to-end journey first:

```
Activity 1 → Activity 2 → Activity 3 → Activity 4
    ↓             ↓             ↓             ↓
  1 task        1 task        1 task        1 task
```

One task per activity, proving the full flow works. Then add depth.

### Pattern 2: Thick Slice

When one activity is the core value, go deep there first:

```
Activity 1 → Activity 2 → Activity 3 → Activity 4
    ↓             ↓             ↓             ↓
  1 task        5 tasks       1 task        1 task
                (core)
```

### Pattern 3: Progressive Enhancement

Layer capabilities across releases:

```
Release 1:  Basic flow    (all activities, minimum tasks)
Release 2:  Error handling (edge cases, validation)
Release 3:  Power features (automation, customization)
Release 4:  Scale          (performance, enterprise)
```

## Facilitation Guide

### Running a Story Mapping Workshop

| Phase | Duration | Activity |
|---|---|---|
| **Setup** | 10 min | Define persona, narrative, and decision scope |
| **Backbone** | 20 min | Map activities and steps (sticky notes on wall or Miro) |
| **Body** | 30 min | Decompose into tasks (everyone contributes) |
| **Prioritize** | 15 min | Arrange vertically by priority |
| **Slice** | 15 min | Draw release lines; debate MVP scope |
| **Review** | 10 min | Identify risks, dependencies, and assumptions |

**Total:** ~100 minutes for a focused session.

**Materials:** Sticky notes (3 colors: activities, steps, tasks), markers, large wall or whiteboard, or Miro/FigJam for remote.

**Key facilitation rules:**
- Keep each sticky note to 4-8 words.
- Activities and steps first; resist jumping to tasks.
- Everyone writes, not just the PM.
- Debate the MVP line, not individual task priority.

## Integration with Other Skills

- Use `job-stories/` JTBD discovery canvas to define the narrative before mapping.
- Feed Release 1 tasks into `create-prd/` for detailed requirements.
- Use `prioritization-frameworks/` RICE