The Broken Telephone Game of Defining Software and UI Requirements
The broken telephone game is played all over the world. According to Wikipedia, the game is played as follows: “one person whispers a message to another, which is passed through a line of people until the last player announces the message to the entire group. Errors typically accumulate in the retellings, so the statement announced by the last player differs significantly, and often amusingly, from the one uttered by the first.”
This game is also played inadvertently by a large number of organizations seeking to define software and UI requirements by using information passed from customers to business analysts to UI/UX designers and then to developers and testers.
Here’s a typical example:
- The BA or product owner elicits requirements from a customer and writes them down, often as a feature list and use cases.
- The use cases are interpreted by the UI/UX team to develop UI mockups and storyboards.
- Testing interprets the storyboards, mockups, and use cases to develop test cases.
- The developers then interpret the use cases, mockups and storyboards to write the code.
As with the broken telephone game, information is altered with each handoff. The resulting approach includes a lot of rework and escalating project costs due to combinations of the following:
- Use cases don’t properly represent customer requirements.
- UI/UX design is not consistent with the use cases.
- Incorrect test cases create false bugs.
- Missed test cases result in undiscovered bugs.
- Developers build features that don’t meet customer needs.
The further down the broken telephone line the original requirements get, the more distorted they become. For this reason, UI storyboards, test cases and code typically require a lot of reworking as requirements are misunderstood or improperly translated by the time they get to the UI and testing teams.
How Can We Reduce the Broken Telephone Effect?
The good news is that there are some reasonably simple changes to processes and deliverables that will decrease the broken telephone effect. The following techniques share the goal of reducing handoffs and translations.
Interview the customer with cross-discipline teams
One method is to involve the BA, UI/UX and quality assurance people directly in the elicitation process with the customer. You can even make a case to include the lead developer as well. Having all disciplines represented during the interview process lets each party hear requirements directly from the customer, reducing the reliance on BA documents alone. An equally important benefit is that each discipline brings a different perspective, which can lead the interview process down different paths of conversation and requirement gathering.
For example, the QA resource may ask more questions about the requirements related to edge or error conditions than the BA or UI/UX resource. Putting a UI/UX member in front of the customer will provide a chance to understand features that are frequently used to manage the cognitive load of the end user.
Combine and evolve use cases, UI mockups, and UI storyboards into an integrated deliverable
Another approach to reduce the broken telephone effect is to avoid creating use cases, mockups and storyboards as separate deliverables by combining them into one “integrated deliverable.” To create an integrated deliverable, start with the use case and attach UI mockups to each step. This automatically creates a UI storyboard that has the same steps (including main and alternate flows) as the use case, and means they don’t get out of sync. Also, since the UI mockups are attached to each step, you know they will be consistent with the purpose and requirements outlined in the step.
Often, new requirements or changes to existing requirements emerge, and if your storyboards and mockups are separate from the use cases, the original use cases are not updated. This creates confusion for your developers, testers and stakeholders. Combining your use cases, mockups and storyboards into one integrated deliverable makes it much easier to keep all three in sync, dramatically reducing the potential for conflicting requirements.
The integrated deliverable approach encourages collaborative and combined authoring and review of use cases and UI/UX design by your BA and UI/UX teams, resulting in more accurately defined and understood requirements.
To bring this concept to life, here’s an example that starts with the use case defined by the BA or product manager, without any mention of UI-specific requirements.
Use Case: ATM Cash Withdraw
The steps with the Y-shaped symbol are steps with alternate flows.
When the UI/UX team starts attaching UI mockups to each of the steps, a UI storyboard is created that uses the same exact main flow and alternate flows as the use case. A UI storyboard expressed in terms of a main flow and alternate flows has the benefit of reducing the number of traditional linear storyboards. If you were to create traditional UI storyboards for each of the unique paths through the use case above, you’d have 11 in total, with duplicated steps across them. UI storyboards with main flows and alternate flows reduce rework and errors that pop up in linear UI storyboards.
You can do this in Word by inserting UI mockup images created in a different UI mockup tool, but keeping the UI mockups up to date in the will become time-consuming and error-prone. Products such as PowerStory (a plugin for PowerPoint) make this easier by enabling you to combine use case steps with UI mockups to create UI Storyboards.
In the following screen shot you will see that PowerStory adds a panel specifically designed for creating main flows and alternate flows of use cases, and associates the steps in these flows with typical slides in PowerPoint.
As before, the steps with the Y-shaped symbol beside them indicate an alternate flow. When you hover over the icon you can view and enter the alternate flows associated with that step.
PowerPoint is an extremely powerful tool for creating UI Mockups that can support more UI design ideas than typical wireframe mockup tools, especially with plugins like PowerMockup and Microsoft’s upcoming storyboarding plugin.
Write use cases and UI storyboards with testing in mind
Test cases typically include a “user action” followed by an “expected result.” If you spend a little more up-front time defining which steps are “user actions” and which steps are “expected results” when creating your use cases and UI storyboards, you can save your testing team time. Use cases are well suited for this approach by defining the principle actor for each step. Any step where the actor is a system should be classified as an “expected result” step for the test case, and any step where the actor is an end user should be labeled “user action.”
One of the test cases derived from the combined use case defined above is shown below, following the rule that a step with an end user actor is an action and a step that has a system actor is an expected result.
Automate the creation of your test cases directly from your use cases
Using tools that will automatically generate test cases from your use cases and UI storyboards will save you a significant amount of time and money typically spent by your testing team creating manual test cases. In the context of this article, it also eliminates a handoff and thus mitigates the broken telephone effect. When QA teams interpret requirements and translate them into test cases, they might misunderstand requirements and create faulty test cases and/or miss requirements and their corresponding test cases.
Key Points to Take Away
Developing software requirements, UI designs, and test cases can mirror the broken telephone game we all played as kids. Every time we pass information on, it gets changed and misinterpreted, leading to increased project costs and the delivery of the wrong solutions to your customers. Following the steps outlined above, you can reduce the broken telephone effect and follow a more streamlined process to clear and lucid product development.
Don’t forget to leave your comments below.