How Do You Work Through a Brief?
Picture a table with a few people you may have met minutes ago, a whiteboard, and a brief for a system that doesn’t exist yet. Before the kata ends, your team has to agree on what matters, sketch a design, and defend it in front of the room.
The work moves through three phases, and each one starts from what the last one left you with. By the end, your team has a short list of priorities, a diagram with the decisions behind it, and a plan for what ships first.
Understand and Prioritize
Work out who the system serves, rank the characteristics that matter most, and scope a first release.
Design
Turn those priorities into components, decide what to build and what to buy, draw the architecture, and record each key decision.
Share
Present your design to the room and question how other teams solved the same brief.
Three ground rules hold through every phase. They come up again and again, so keep them in view from the start:
There is no correct answer, only trade-offs.
Technology choices wait until the design is clear.
An unstated assumption is a hidden decision.
Before You Start#
You don’t need to prepare anything or know the brief by heart. Most of what you need is already at the table:
You work in a team of three to five people, often with people you don’t work with every day.
A kata takes an hour or two. At a tech event it gets one hour, so you prioritize faster and leave more questions open.
Nobody writes code. The whole time goes into sketching, discussing, and deciding, on paper or a whiteboard.
Whoever runs the kata plays the conference organizers. Ask them about anything the brief leaves out, and expect some questions to come back without a clear answer, the way they would on a real project.
Keep two lists from the first minute, one for your assumptions and one for your decisions. Every phase adds to both, and by the time you present, they hold the reasons your diagram can’t show. If you practice alone, you play the organizers too, so every answer you give yourself goes on the assumptions list.
Understand and Prioritize#
You bring
- The brief, which you’ve already read once.
- Two empty lists, one for assumptions and one for decisions.
You leave with
- The actors and what each one does.
- Your three top characteristics, ranked.
- A first release that fits the ticket-sales date.
- Your assumptions, with one open question marked.
Start with the brief, which is the familiar one for a conference platform. Read it on your own before anyone at the table speaks, and write down the first questions it raises. If the first voice in the room sets the direction, the team ends up designing one person’s idea, an anti-pattern known as The Loudest Voice.
The Show Must Go On!
Description
A team of organizers runs a large annual technology conference, bringing together thousands of developers, technology professionals, and industry experts.
Each year features a new lineup of speakers, talks, and activities. The organizers need a platform to manage the conference, keep attendees informed, and support interactions between speakers and participants.
Early-bird ticket sales open in three months.
The platform must also maintain an archive of previous editions, allowing visitors to explore past schedules, speakers, and presentations.
Users
- Thousands of attendees
- Hundreds of speakers
- Dozens of staff
Requirements
Conference Management
Organizers and speakers can manage talks, schedules, room assignments, and conference information.
Attendee Engagement
Attendees can explore the program, interact with talks, provide feedback, and receive important updates.
Conference Archive
Visitors can explore previous editions, including their programs, speakers, and presentations.
Mobile Accessibility
All capabilities must be usable on mobile devices, including during the conference.
Reliability
The platform must remain useful during periods of high demand and unreliable venue connectivity.
Then list the actors and what each of them does. The brief names attendees, speakers, and staff, but look at the archive requirement and you’ll find visitors, who aren’t on that list at all. An actor nobody listed is a set of needs nobody has thought through yet.
Three gaps stand out in the brief, such as who sells the tickets and what interacting with a talk means. Take them to the organizers, along with questions like these:
Requirements
- Does interacting with a talk mean questions to the speaker, live polls, ratings, or something else?
- Who reads the feedback, the speakers, the organizers, or both?
Architectural Drivers
- Which moments create the peak load, such as the early-bird launch, the first morning, or the breaks between talks?
- How much of the program must keep working when the venue’s network drops?
Alternatives
- Does the archive belong inside the platform, or could each edition be published as a static copy once it ends?
- Does mobile access call for a native app, or is a mobile web app enough?
Uncertainty
- Is ticketing part of the platform, or does the sales date only set the deadline for a first release?
- Which assumption would change the design most if it turned out to be wrong?
Some questions won’t get an answer, and that’s useful too, because each one shows an assumption your design depends on. Write those assumptions down, and keep them apart from what the brief actually says.
Mark the one open question that could change your design most. Come back to it when you design, and again when you present.
Next, agree on the architectural characteristics that matter most. They aren’t features, and the brief only hints at them, so they depend on what your team assumes about users and load:
- Availability
- Scalability
- Elasticity
- Performance
- Security
- Maintainability
- Testability
- Deployability
- Interoperability
- Cost
Pick three and rank them, because these qualities pull against each other and no design serves all ten. The ranking settles arguments later, when two of them collide.
Picture attendees checking the schedule on their phones while the venue Wi-Fi struggles. They make a strong case for availability. The three months until ticket sales make a different one, for cost and deployability, because a small team has to ship quickly and keep changing what it shipped.
Last, scope a first release. It’s the smallest scope that still gives the main actor something of value, and the ticket-sales date limits what fits. Everything else waits for a later release, and every move to a later release changes other decisions.
Before tickets go on sale, your main actor may well be someone deciding whether to buy one. If so, the program and the speakers matter long before anything that happens during a talk.
Design#
You bring
- The actors and what each one does.
- Your three top characteristics, ranked.
- A first release.
- Your assumptions, with one open question marked.
You leave with
- Components, each marked as built or bought.
- A diagram with each key decision numbered on it.
- A decision record for each key decision.
- A release timeline.
Now your notes turn into a design. Every choice in this phase should point back to an actor, a characteristic, or an assumption from the first phase, which is what makes it possible to defend.
Start by grouping what your actors do into components. Managing the schedule, publishing the program, and browsing past editions are different jobs for different people, so they’re natural places to draw the first lines.
For each component, decide where it comes from. These decisions depend on what your team assumes about budget, skills, and time:
- Build or buy
- Off-the-shelf, open source, or custom
- Managed or self-hosted
- Extend an existing system or replace it
Interacting with a talk is a good test case. The right answer depends on what you assumed it means:
- If it means questions and polls, an existing audience tool may cover it. You pay with a second product for attendees to open and a dependency you don’t control.
- If it means something only this conference needs, you’ll probably build it. Then the three-month date and the size of your team decide how much of it you can build.
Then choose a style for the parts you build. The choice depends on what your team assumes about the system’s size and how it will change:
- Layered
- Modular monolith
- Service-based
- Microservices
- Event-driven
- Microkernel
This is where the second ground rule earns its place. Name a style, not a product, because picking a database before you know what the data is skips the problem entirely. Jumping straight to products is the anti-pattern known as The Solution-First Thinker.
Now draw it. A context and a container diagram from the C4 model are usually enough, and any notation works as long as another team can read it. Whatever you draw, make sure it shows:
- Each technology by its category, such as relational database, not by its vendor.
- Which parts you build and which you buy.
- A number on each key decision, matching its record.
- A title, and a key for its shapes and lines.
Each key decision gets an architectural decision record, so the reasoning is written down by the time you present. In a kata, the record carries the decision’s number, names two alternatives you considered, and states the trade-off you accept.
Keeping a copy of the schedule on each phone makes a good first record. The alternatives are a schedule that lives only on the server and a copy kept on every phone. Choosing the copy means attendees can still read the program when the Wi-Fi drops, and the trade-off you accept is that every room change has to reach all of those copies.
If time runs short, stop drawing and finish the records. A half-drawn diagram with clear reasons says more than a full whiteboard nobody can explain, and rushing to fill the board is the anti-pattern known as The Empty Hands Fear.
Finally, turn your first release into a release timeline. Now that you know what you build and what you buy, you can see what really fits before ticket sales. A bought audience tool might let interaction ship early, while building your own could push it past this year’s conference.
Share#
You bring
- Your three top characteristics, ranked.
- Your diagram, with its numbered decisions.
- Your decision records.
- Your release timeline.
You leave with
- The questions other teams asked about your design.
- The assumptions you didn’t know you were making.
Now every team presents to the room. Each one shows the same four things, so the designs are easy to compare:
- Your three characteristics, in rank order.
- Your diagram.
- Your release timeline.
- One key trade-off, usually the one you argued about longest.
Every team worked from the same brief, so the differences between the designs are the interesting part. They point to assumptions each team didn’t know it was making, and that includes yours.
This is where the first ground rule matters most. When another team chose differently, ask what their design gives up and what yours does, instead of deciding who is right.
While the others present, ask each team at least one question about an assumption or a trade-off. Sitting through every presentation in silence is the anti-pattern known as The Silent Audience, and the questions you ask often show you what your own team took for granted.
If you’re practicing alone, write the presentation down for someone who wasn’t there. Ask them to question it, or set it aside for a day and question it yourself.
After the Kata#
Judgment grows over many katas, so the next one goes better if you look back at this one. Before you leave the table, ask yourselves:
- Did anyone start designing before the team agreed on its priorities?
- Did one voice settle most of the decisions?
- Which assumption mattered most, and did you write it down in time?
- Did you ask every presenting team a question?
Most of these are anti-patterns, and they read differently once you’ve been through a kata. When you want another brief, Ted Neward’s collection has plenty to choose from.
The One-Hour Workshop#
We also run katas as a one-hour workshop at tech events, where you work through these phases with people you’ve just met.
See how the workshop runs