Much has been said on the differences between a user-centered design methodology and the practice of an agile development team. In fact, many practitioners believe the two cannot coexist. However, in order to understand how to achieve the benefits of user-centered design during Agile development, it is best to recognize what they share in common: an iterative approach to problem solving.
User-centered design best practice: Understand user behaviors in order to design an effortless, powerful and desirable user experience that best satisfies business needs. An iterative approach is required to balance all of these competing, and occasionally contrary factors. The way to execute the approach depends on the needs, capabilities, and constraints of your team. For example, running a product design sprint is useful for kicking off new products and features in quick, five-day cycles. The important thing is that there is continuous alignment with user needs to inform decisions.
Agile development best practice: Frequently and regularly deploy features, allowing users to actually use the software early and often. This approach embraces the fact that people are changed by new experiences. When users are exposed to new features with each deployment, their priorities, desires and assumptions change. An agile development team expects these changes, and can address them easily.
So, both the user-centered design team and the Agile development team need to work in iterations. The difference now lays within the details and how each manages the iterations. A ‘modified scrum’ process can be very effective—the modifications allow each group to manage and coordinate their own iteration cycles.
TandemSeven makes four modifications to a typical scrum process to arrive at a “modified scrum”:
- Modification 1: Minimal upfront user interface design
- Modification 2: Half phase offset
- Modification 3: Some documentation required
- Modification 4: Tactical user participation
Modification 1: Minimal upfront user interface design
In Iteration 0, the design team performs minimal upfront design. They focus on developing a structure and concept that contains all known user stories before Iteration 1 begins. The structure illustrates how the user stories fit in relation to each other. The concepts are high-level wireframes that illustrate key functionality.
Why this modification?
Users do not want to relearn how to perform any given task every time a new version is deployed. Upfront design provides tremendous value—painting the big picture and acting as a guide to ensure a consistent user experience throughout every iteration.
Typical agile development thinking of “coding for current needs only” often leads to an inconsistent user experience. Upfront design solves this problem.
The design team makes a decision regarding form labels: all labels will be to the left of all form elements. In a later iteration, much more complex forms are required; these forms are done best with the labels above the form elements. The team now has a choice: either design this new form inconsistent with the other forms in the application or create new user stories to go back and update all forms so that the labels are above the form elements. In either case, the end result is an inconsistent user experience.
While a simple example, this applies to all design decisions made—from the highest level (which structure should be used: portal structure, page-less structure, or wizard structure?) down to the decision on the selection of UI controls (how many options is the cut-off from radio buttons to drop-down selection menus?)
Watch for “Modification 2: Half phase offset” in our next blog post.