# EventStorming
> **In one sentence:** EventStorming gets the right people in a room with a wall of paper and
> colored sticky notes to map a business process as a timeline of events. The shared understanding
> it builds matters more than the diagram it produces.

## What it is

A **low-tech, group modeling workshop** created by Alberto Brandolini. You choose a scope (one
business process), and the group describes it as **domain events on a timeline**. Step by step you
add commands, actors, policies, read models, external systems, and finally aggregates and context
boundaries, until the wall tells the whole story of how the process works.

## Who and what you need

**People:** anyone with knowledge of the process: domain experts, engineers, product, QA, UX,
support. The more varied the group, the more you'll uncover. Keep it to **about 10 people at most**
in person, so everyone can contribute.

**Supplies:**
- A **huge modeling surface**: a wall covered in paper roll is ideal, or the biggest whiteboard you can find.
- **Plenty of sticky notes** in the standard colors, enough that supplies never slow anyone down.
- **A marker for every person.**
- **A big room** with no table in the middle and ideally **no chairs**, so people stay engaged and
  moving. Keep a few for anyone who needs to sit.
- **Snacks.** Sessions usually run two to four hours.

### Color legend (the usual conventions)

| Element | Note |
|---|---|
| Domain event (past tense) | Orange |
| Pain point / hotspot | Pink, rotated into a diamond |
| Pivotal event | Vertical line on the timeline |
| Command (imperative) | Light blue |
| Actor / persona | Small yellow |
| Policy (automation) | Purple |
| Read model | Green |
| External system | Pink |
| Aggregate | Large yellow |

## The ten steps

Using a made-up **library book loan** process as the running example:

1. **Unstructured exploration.** Everyone writes **past-tense events** on orange notes and sticks
   them up, in any order, duplicates welcome: *Book Reserved, Book Borrowed, Due Date Passed,
   Fine Charged, Book Returned*. Keep going until new ideas slow down.
2. **Timelines.** Put the events in order, starting with the **happy path**, then add alternative
   and failure branches (*Book Reported Lost*). Remove duplicates, fix wording, and fill in gaps.
3. **Pain points.** Mark anything that needs attention (bottlenecks, manual steps, missing
   knowledge) with pink diamonds: *"Who decides when a fine is waived?"* Keep doing this throughout the session.
4. **Pivotal events.** Find events that mark a **change of phase** and draw a vertical line at
   each: *Book Borrowed, Book Returned*. They hint at **bounded context boundaries**.
5. **Commands.** Add **imperative** blue notes *before* the events they cause (*Borrow Book*), and
   small yellow **actor** notes where it's clear who issues them (*Member*, *Librarian*).
6. **Policies.** For commands with no actor, find the automation behind them: *"Whenever* Due Date
   Passed *happens, then* Charge Fine*."* Use purple notes between the event and the command, and
   note any condition (*"only if not renewed"*).
7. **Read models.** Add a green note for the information an actor looks at before issuing a command
   (*"Member's current loans and fines"*), placed **before** the command.
8. **External systems.** Pink notes for anything outside the scope that **sends commands or
   receives events**, such as the payment provider or the email service. By the end of this step,
   every command should come from an **actor, a policy or an external system**.
9. **Aggregates.** Group related commands and events around large yellow notes, **commands on the
   left, events on the right**. An aggregate takes in commands and emits events (*Loan*, *Membership*).
10. **Bounded contexts.** Cluster aggregates that are closely related or tied together by
    policies. Those clusters are **candidate bounded contexts** (*Lending*, *Billing*).

## Variants

The steps are guidance, not rules. A common approach:

- **Big picture first:** run steps 1–4 across a broad area of the business. That lays a foundation
  for the ubiquitous language and sketches possible context boundaries.
- **Then go deep:** run a full ten-step session for each important process you found.

The model you end up with (events, commands, aggregates and candidate contexts) can even be a
blueprint for an event-sourced domain model, if that fits. But **the real value is the
conversation**: shared knowledge, aligned mental models, conflicts brought into the open, and a
ubiquitous language starting to form.

## When to run one

- **Build a ubiquitous language.** People naturally converge on shared terms while they model together.
- **Model a business process**, and find aggregate and context boundaries along the way.
- **Explore new requirements**, so everyone agrees and edge cases come out early.
- **Recover lost domain knowledge**, which is especially useful before modernizing a legacy system.
- **Find improvements** by looking at the process end to end.
- **Onboard new team members.**

**When not to:** simple, linear processes with no interesting logic gain little from it.

## Facilitation tips

- **Start with a short briefing:** the goal, the scope, and a **visible legend** of the note colors.
- **Watch the energy.** When it drops, ask questions or move on to the next step.
- **Keep everyone involved.** Draw quieter people in by asking them about the current state of the model.
- **Take breaks, and restart together:** wait until everyone is back, then walk through the wall to get back in the flow.
- **Remote sessions** (on an online whiteboard such as Miro) are possible but less effective. Be
  patient, keep groups to **about five**, run several small sessions and merge the results, and go
  back to in-person sessions when you can.

It's like riding a bike: you learn far more by running one than by reading about it, and you don't
need to be an expert to facilitate your first session.

## Check yourself

1. Who should be invited?
2. Name three good reasons to run a session.
3. What outcomes can you expect?

<details><summary>Answers</summary>

1. Anyone with knowledge of the business area being explored, not only engineers or only experts.
2. Building a ubiquitous language, exploring a new domain or requirement, recovering lost knowledge from a legacy system, or onboarding newcomers.
3. Shared understanding, a foundation for the ubiquitous language, the gaps in what people know brought into the open, and an event-based model you can build from.

</details>
