EventStorming with Solace: From Sticky Notes to a Governed Event Mesh

Every successful event-driven architecture starts the same way: with people who understand the business standing in front of a wall, telling the story of what actually happens. An order is placed. Stock is reserved. A payment fails. A customer gets a notification. Long before anyone argues about brokers or schemas, the events themselves have to be discovered, named, and agreed on.

That discovery practice has a name: EventStorming, the workshop format created by Alberto Brandolini. It is fast, inclusive, and famously effective at surfacing what an organization really does, including the parts nobody wrote down. Domain experts and engineers storm a timeline of domain events on sticky notes, attach the commands and reactions around them, and walk out with a shared picture of the business.

There has always been one problem with that picture: it dies on the wall. The photos of the sticky notes go into a slide deck, the energy of the workshop fades, and six weeks later someone starts designing topic hierarchies from memory.

We created EventStorming with Solace to close that gap. It is the workshop tool our facilitators use to run EventStorming sessions with customers, and it is designed around a single promise: everything the room discovers becomes a durable, reviewable, exportable event architecture. The wall does not die; it becomes your Solace Event Portal catalog.

Start with the Big Picture

A typical EventStorming workshop opens on a big-picture map: one shared wall where the room storms the coarse events of the whole business, names candidate domains, and seats events with the domains and teams that own them. Domain cards carry a name and a pitch; the room dot-votes on which use cases matter most; and when the facilitator approves a candidate, the tool spawns a dedicated board for it, carrying the relevant events along.

The big-picture map: coarse events, domain cards, and team seating on one shared wall

This matters because scope is where most architecture efforts wobble. The map keeps the whole landscape visible while each use case gets stormed in depth on its own board, and the tool remembers the lineage between them.

A Live Wall, Powered by an Event Mesh

Each use-case board is a real-time collaborative canvas. Every participant joins from their own browser, places stickies in Brandolini’s canonical notation (orange domain events, blue commands, purple policies, actors, systems, hotspots, read models), and sees everyone else’s moves as they happen, including live cursors.

A stormed use-case board: the event timeline with commands, policies, actors, and systems around it

Here is the part we could not resist: the collaboration itself runs on a Solace event broker. Every sticky placed, moved, or linked is a real event published over the broker and appended to an event-sourced log. Board state is a projection of that log. The tool is not just a way to design an event-driven system; it is one, and the room is using the very technology it is designing with.

That event-sourced core is not a novelty. It is what makes late joiners converge instantly to the same wall, what makes undo a clean compensating action instead of a destructive rewind, and what makes full session replay possible (more on that below).

Structure Emerges from Chaos

Raw storming is deliberately chaotic. When the room is ready, the same wall snaps into structured views: swim lanes by actor, lanes by system, or lanes by bounded context, with the parking lot and unassigned work kept honest at the edges. Nothing is retyped; the stickies simply reorganize around what the room has learned.

The same wall viewed as lanes: structure emerges without retyping anything.

Context boundaries get first-class treatment. Anyone can propose a boundary with a name and a pitch; the room votes; the facilitator approves. Approved boundaries live on the wall with their rationale attached, and they later drive how the architecture is organized.

Context boundaries drawn on the wall, each carrying a name and a pitch.

Facilitation Is Built In, Not Bolted On

A good EventStorming session is a facilitated performance, and the tool treats the facilitator as a first-class user. Workshops can run to an opt-in clock with a phased agenda, from concept alignment through storming to event architecture and build planning. Each phase transition briefs the room with a card that says what to do now, what to hold off on, and when to move on, so nobody is guessing what the current exercise is.

A phase briefing card orienting the room: purpose, do this now, not yet.

The facilitation kit runs deep:

• A facilitator or participant can take the stage and drive every screen in the room, so “everyone look here” actually works in a remote workshop.
• Dot voting. Participants vote on the stickies that matter; totals and voters are visible to everyone.
• Hotspots with a lifecycle. Disagreements go on the wall as hotspots, and when the room settles one, the decision is recorded on the sticky itself. Resolved questions stay visible as workshop product, not deleted as noise.
• A moderated mode for large or unruly rooms, where participant stickies route through a facilitator tray before landing on the wall.
• A shared glossary and a chat dock with voice notes, so terminology and side conversations stay attached to the workshop instead of scattering into other tools.

A hotspot resolved on the wall: the question stays, the decision is attached

Walk the Story: The Wall Proves Itself

Every wall claims a story. Alberto Brandolini’s consistency check makes it prove one, and EventStorming with Solace builds that check directly into the canvas as the story walk.Pick any outcome on the wall and the walk asks one question per hop, backwards through the causal chain: what made this possible? An event points to the command that caused it, the command to the policy that issued it, the policy to the event that woke it, and so on until the chain completes at a person issuing a command. There is no auto-advance; every hop is a click, so the room answers before the wall does. The walked chain stays lit while the rest of the wall dims, and the same card asks the forward question too: what does this set in motion?

A chain that completes proves the story holds. A chain that breaks is not a failure of the exercise: the gap is the finding, whether it is a policy that never fires, an event nobody reacts to, or a command with no outcome. And because the walk moves the walker’s own camera and selection, a presenter running it carries the whole room through the same question, hop by hop.

Walking the story: from “Order prepared” back through policies, commands, and events to the customer who started it all.

From Discovery to Architecture

This is where EventStorming with Solace departs from a typical whiteboard and postit-based session. After the “storm,” every domain event can be enriched with the details an event-driven system actually needs: a hierarchical topic address composed from workshop and board roots, delivery quality of service, an owning team, and an optional schema sketch. The side panel shows who produces and who consumes each event, derived from the links the room drew, so the pub/sub picture is explicit before anyone writes code.

The enrichment panel: topic address, QoS, owner, schema sketch, and the event’s producers and consumers.

Board Review

A built-in board review then acts as a tireless co-facilitator. Dozens of deterministic rules check the wall for the gaps that hurt later: events nobody reacts to, commands with no outcome, events with no topic or owner, systems that quietly span contexts. At the workshop level, the review reconciles across boards, catching ownership conflicts and contract divergence between teams, and many findings carry a one-click fix.

The review register: findings ranked by priority, each teaching the method rather than scolding.

The Payoff: Straight into Event Portal

The end state of a workshop is not a photo. With one click, the workshop exports as a Solace Event Portal application domain file, or pushes directly into your Event Portal tenant: application domains from your boards, applications from your systems, events with their topic addresses and schemas, and the full publish/subscribe matrix the room discovered. The merged workshop export resolves event ownership across boards, marks shared events, and homes every event with the domain that claimed it.

Pushing the workshop’s architecture directly into a Solace Event Portal tenant.

There is also a spreadsheet workbook for stakeholders who live in Excel, an architecture diagram as a self-contained interactive SVG, and a full board export that can be re-imported anywhere, because the event log itself is the portable format.

Replay the Whole Session

Because every action in the workshop is an event in an append-only log, the session itself is a first-class artifact. Open replay and the workshop becomes a timeline: scrub back to the empty wall, press play, and the model re-emerges sticky by sticky, decision by decision, with each step narrated as it lands. Speed it up, slow it down, or jump straight to any moment.

Replay is a lens, not a rewind: the live wall is never touched, and hopping back to it takes one click. Alongside the session-level replay, every sticky carries its own change history, from creation through every edit, enrichment, and decision, each attributed to the person who made it. Six weeks later, when someone asks “why does this event belong to that team?” the answer is not in anyone’s memory. It is on the record, and you can watch it happen.

Session replay: scrub back to the empty wall, press play, and the workshop re-happens sticky by sticky — then open any sticky’s own change history.

Walk through a Workshop: Solly’s Coffee, Order to Pickup

Everything above is easier to feel than to describe, so here is one workshop end to end. The three-minute tour below opens Solly’s Coffee, a complete sample workshop that ships with the tool: a coffee chain’s operations, stormed across five use-case boards, enriched, reviewed, and ready to export. Anyone can clone it from the Samples tab in one click and explore their own copy without touching the original.

A guided tour of the Solly’s Coffee sample workshop, from the big-picture map to the Event Portal export.

Here is what the tour walks through, and why each stop matters:

• The big-picture map. The workshop home shows the whole business at a glance: six domain cards, each with its pitch, five of them already spawned as live use-case boards (the sixth is deliberately left as a voted-but-not-yet candidate, because a real landscape always outgrows one session). Dot votes on the cards record what the room chose to storm first, and the domains and teams views show every coarse event seated with its expected owner. The workshop-level review reports zero findings: ownership, contracts, and the map all agree.
• One use case, read left to right. Drilling into the Order to Pickup board, the story reads as a timeline: commands, the orange events they produce, the policies that react, and the cast of actors and systems around them. A star marks the pivotal event the story hinges on, and a hotspot the room argued about carries its recorded decision, with the question kept on the wall as workshop product.
• Where the wall becomes architecture. Opening a sticky’s side panel shows the enrichment on a single event: its modeled topic address, quality of service, owning team, and schema sketch, plus the parties view of who produces and who consumes it. One event is shared across boards, and the panel shows the rule that keeps that sane: one owner defines the contract, everyone else consumes it.
• Two link layers, two questions. Flow links answer what causes what; cast links answer who does what. Toggling between them, then switching through actor lanes, system lanes (a live preview of the Event Portal application split), and the context view shows how the same wall answers different architectural questions without anyone retyping a sticky.
• The consistency check. The story walk picks the Order prepared event and asks, hop by hop, “what made this possible?”: the command that caused it, the policy that issued the command, the event that woke the policy, all the way back to the customer placing the order. The chain holds, so the story is sound. Where a chain breaks instead, the gap itself is the finding.
• Replay and the deliverables. The tour ends by scrubbing the session replay back to an empty wall and watching the model re-emerge sticky by sticky, then opening the export menu: the workbook, the board diagrams, and the Event Portal import file. The wall, shipped.

If you would rather drive than watch, the same Solly’s Coffee workshop is the first thing a facilitator can hand you in a session: clone it, break it, and the sample resets with the next click.

Built with Solace

EventStorming with Solace isn’t just a tool for designing event-driven systems — it is one. The live wall, the multi-user collaboration, the cursors, the screen sharing, the instant convergence for late joiners: all of it rides on a Solace broker and event mesh. Every interaction in the room is a published event on the same technology the room is there to design with.

Storm with Us

EventStorming works best with an experienced facilitator and a room that includes the people who actually know the business. That is exactly the workshop we run with our customers: a facilitated session that takes you from a blank wall to a reviewed, exportable event architecture in your own Event Portal tenant, often in a single day.

If you are starting an event-driven initiative, untangling an existing integration landscape, or trying to get business and engineering to agree on what the events even are, we would love to storm it with you.

Sound like a plan? Connect with us to schedule an EventStorming with Solace workshop!