Event storming isn’t a workshop fad. Here’s when I’d use it — and when a doc would do
Casey Holt
September 18, 2026
I used to treat event storming the way some teams treat retrospectives: book the room, buy the stickies, invite twelve people who have calendar conflicts, and hope the wall tells us what the product is. Sometimes it did. More often it told us that we already knew the happy path and were using a workshop to delay writing it down.
Alberto Brandolini’s format is still the best cheap way I know to get a room to agree on what happened in a business, in the order it happened. I have run it for billing, for onboarding, for a warehouse that thought “shipped” meant three different things. I have also cancelled it and written a two-page sequence instead. The skill is not facilitating. The skill is noticing when the wall is cheaper than the document — and when it is theatre.
Here is the line I actually use.
What I am buying when I book the room
Event storming is not a requirements workshop with prettier paper. You put orange stickies for domain events — past-tense facts: InvoiceIssued, PaymentFailed, ShipmentHeld — on a timeline. You add commands, actors, aggregates, read models, policies, and the hot spots where people start arguing. The argument is the product.
I do not run it to “discover bounded contexts” as a poster. I run it when I need three things in the same afternoon:
- A shared vocabulary that survives the meeting. If finance says “posted” and ops says “confirmed,” the wall makes the collision visible before someone names a Kafka topic
order.confirmedand we spend a quarter translating. - An honest timeline, not a capability map. Capability maps hide time. Time is where money leaks — retries, late fees, “we already refunded that.”
- A list of questions nobody wanted to own. Those become tickets or they become a doc. Either is fine. Pretending they were settled is not.
I use Miro when the team is remote. I use a paper roll when we are in the same city and I can stand people up. I do not care which. I care that people can move a sticky without asking me for edit access.

The last time it earned its keep
We were replacing a home-grown invoicing path with Stripe Billing plus a thin ledger in Postgres. Product thought “subscription started” was one event. Finance thought it was three: trial converted, tax calculated, invoice finalized. Support thought dunning was a Zendesk macro. Engineering had already sketched a Temporal workflow because someone had read a blog post.
I booked two hours, not a day. Six people: the billing PM, one backend, one frontend who owned the customer portal, someone from finance who actually closed the books, a support lead, and me. No vendors. No “stakeholders” who only wanted a readout.
The first twenty minutes were boring on purpose. We dumped events we already agreed on: CheckoutCompleted, CustomerCreated, PaymentMethodAttached. Then finance put TaxIdRejected on the wall and the room got quiet. Nobody in engineering had that event. Stripe had it. Our code treated a failed tax ID as a generic card_error and the portal showed “try another card.”
That sticky paid for the workshop. We did not need DDD after that. We needed a policy: if tax collection fails, do not start the subscription, do not send the “welcome” email from Customer.io, and do not let the Temporal workflow mark the customer active. We wrote that as six events and two commands. I photographed the wall, typed it into a Notion page that night, and cancelled the second session we had held “just in case.”
That is a good storming: you stop when the disagreement is named and assigned. You do not keep going until the wall looks like a conference talk.
When I would not bother
I skip event storming when the system is small, the people who know it can sit in a Google Doc together, and the disagreement is about implementation, not meaning.
A CRUD admin for internal SKUs does not need a timeline of orange squares. A single-player CLI that writes a YAML file does not need aggregates. If two backend engineers are arguing about whether to use sqlc or Hibernate, that is a design review, not a storming. If they are arguing about whether “SKU retired” means “hidden from storefront” or “blocked from purchasing forever,” that is a storming — or a one-page decision record. I pick the cheaper one.
I also skip it when the room cannot tell the truth. If legal will not say how refunds actually work, or sales will not admit they promise same-day activation, the wall becomes a fiction. You get a clean timeline of the process as marketed. I have sat through those. They produce nice photos and a service that still pages you at 2 a.m. because the real process lives in Slack.
And I skip it when we already stormed this domain six months ago and the only change is a new vendor. Re-storming because a new EM wants “alignment” is how the format got a reputation as a fad. Update the doc. Invite the two people who know the exception path. Do not rent a loft.
The doc I write instead
When I cancel the workshop, I do not write a 40-page SAD. I write a short sequence that a new hire can argue with.
The shape I reuse:
- Trigger. Who or what starts this. A Stripe webhook, a cron in GitHub Actions, a human in the admin, a customer in the Next.js portal.
- Events in order. Past tense. One line each. If two things can happen in either order, I say so. If something is async, I say what we do if it never arrives.
- The lie we are not telling. “We say the order is paid when Stripe says
invoice.paid. We do not wait for payout. Support should not promise that.” - Open questions. Named owners, not “TBD.” If there is no owner, it is not an open question. It is a landmine.
I keep this in the repo when the audience is engineers — a markdown file next to the service, not a Confluence graveyard. I keep it in Notion when finance and support have to edit it. I do not keep two copies. The second copy is where the process dies.
A good doc is hostile to adjectives. “Eventually consistent” is not a sentence. “The portal may show Processing for up to 15 minutes after checkout.session.completed; we do not email until invoice.paid” is a sentence.

Pivotal events, hotspots, and the stuff that wastes an afternoon
Brandolini’s later variants — process-level, software-design-level, the big-picture storming with a whole department — are useful when you are actually redesigning a company process. I have used big-picture storming once, for a marketplace that had never written down how disputes moved from buyer to seller to Stripe to a human. It took a day. It was worth a day because the company was about to hire a “trust and safety” team into a vacuum.
I do not use software-design-level storming to invent aggregates on the wall. The wall is a terrible IDE. Once we agree PaymentFailed can happen after InvoiceIssued and before AccessGranted, I take that to a sequence diagram in the repo and to the actual types: a Rust enum, a Go struct, a Kotlin sealed class, whatever the service already speaks. Designing class boundaries on stickies is how you get a folder of nouns and a service that still has a 400-line BillingService.
Hotspots — the pink stickies — are the only decoration I insist on. A hotspot is not “this is complex.” A hotspot is “two people in this room just contradicted each other and we moved on.” If I leave a hotspot unnamed, I have facilitated a mural, not a decision.
I am allergic to the extra taxonomy. People who have just read a DDD book want to label every sticky as an aggregate, a saga, a process manager, an anti-corruption layer. That labeling is useful after you know the events. Doing it during the first pass is how a room of product people checks out and the engineers start performing fluency.
Remote, hybrid, and the “async storming” that is just a board
Fully async event storming — everyone adds stickies in Miro over a week — has never worked for me. You lose the interruption. The interruption is the method. Someone says “we already refunded that” and someone else says “no, we issue store credit,” and you watch their faces. A board that fills up overnight is a backlog with colors.
Hybrid is fine if the remote people can grab a sticky as fast as the people in the room. If the in-room group is talking to the wall and the Zoom square is watching, stop. Write the doc. Or fly. I have done both. I have also run a 90-minute session with three people in a room and three on a call where I was the only one allowed to move stickies. That was a facilitated interview, not a storming. It still produced a decent timeline. I just did not pretend it was the ceremony.
Timebox brutally. Two hours for a slice (billing start, not all of billing). A full day only when the company process itself is the product and you have the people who can say no. If you need four days, you do not have a discovery problem. You have a politics problem, and paper will not fix it.
What I take off the wall so it does not rot
The wall is not the artifact. The photograph of the wall is not the artifact. The artifact is whatever a stranger can use in six months to decide if AccessGranted still happens before tax succeeds.
My transfer ritual is short on purpose:
- I type the event list into the repo or Notion the same day. Same names as the stickies. If I “clean them up,” I have already started lying.
- I add the two or three policies we actually agreed — not the ones I wish we had agreed.
- I open tickets only for the hotspots with owners. A hotspot without an owner gets a sentence in the doc: “We did not decide. Current production does X.”
- I do not recreate the mural in Lucidchart. Pretty diagrams are how teams avoid updating the truth.
If the next change is small — a new Stripe tax behavior, a new dunning cadence — I edit the doc and mention it in Slack. I do not reconvene the circus. If the next change is “we are adding a second processor” or “we are moving from invoices to usage,” I storm the delta. I do not storm the universe again.
How this collides with the way we actually ship
Most of my teams ship in GitHub, talk in Slack, and plot work in Linear or Jira. Event storming does not replace any of that. It feeds them. A good session produces five tickets that were invisible and kills three that were fantasies. That is a win. A session that produces a “domain model” and no tickets is a book club.
I have seen storming used to justify microservices. That is backwards. The wall might show you that invoicing and access-granting are different because they fail differently and are owned by different people. That is a reason to draw a boundary. It is not a reason to stand up eight Spring Boot apps and a Kafka cluster because the stickies were different colors. A modular monolith with clear events in the log is often the thing I want after a storming. The events are the contract. The process boundaries can wait until the team is actually too big to share a database without crying.
I also do not storm to pick a stack. Whether the policy lives in Temporal, in a Postgres LISTEN, in a Sidekiq job, or in a boring cron is a later conversation. Storming tells you InvoiceFinalized must not imply EntitlementActive. Implementation tells you who writes that check.
A personal rule that has saved me from both extremes
If I can write the timeline in twenty minutes and the two people who would fight about it are free for a 30-minute call, I write the doc and have the call. If I cannot write the timeline without guessing at someone else’s job, I book the room — and I book the people whose jobs I would be guessing.
If the only reason to storm is that a consultant sold a “DDD kickoff,” I write the doc and spend the budget on a restore drill or on the person who knows the exception path. Workshops are not strategy. They are a synchronization primitive. Use them when clocks have drifted. Do not use them because the calendar had a hole and the stickies were on sale.
I still like the wall. I like watching a CFO and a junior engineer point at the same orange square and realize they have been using one word for two facts. That moment is why Brandolini’s format stuck. It is also why I will walk out of a four-hour session that is just redrawing the happy path from the pitch deck.
Use event storming when meaning is contested and the contestants can be in the same conversation. Use a doc when meaning is mostly settled and you need something that git can blame. If you cannot tell which situation you are in, start with the doc. You can always throw stickies at a wall later. You cannot get a Tuesday afternoon back from a mural that told you what you already believed.