Skip to content

12 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)

ElementNote
Domain event (past tense)Orange
Pain point / hotspotPink, rotated into a diamond
Pivotal eventVertical line on the timeline
Command (imperative)Light blue
Actor / personaSmall yellow
Policy (automation)Purple
Read modelGreen
External systemPink
AggregateLarge 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?
Answers
  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.