[ 1 ]

The Elements of Design: Think-Make-Check and the Four Models

To help your team build better products, they have to design better. Often, when we think about better design, we focus on the things we design. Do they work better, look better, feel better? Unfortunately, those design outcomes aren’t what designers do.

In this chapter, we’ll look at two foundation concepts:

• What you do when you design: Think-Make-Check
• What you do it to: users, interfaces, interactions, and systems—design’s four models

These two concepts form the foundation for everything else in this book and help your team communicate and collaborate better when they build new products.

Think, Make, Check: What Designers Do

Let’s say you design a fancy coffee mug with a new kind of handle,1 and want to know if the new handle is easy to use. Is it better to ask people if it’s easy to use? Or is it better to watch and see if they have any trouble?

Of course, it’s better to watch what people do than it is to ask them. When you watch people, you see what they do. When you ask them, you hear what they hope to do. Watching people reveals their behavior. Behavior is what you want to affect.

If you ask a designer what they do, they talk about user experience or being user-centered or representing the user or empathy or whatever. That’s what they say they do, what they aspire to. If you watch a designer, what do they really do? Designers think about things, make things, and show things to other people.

If you want to improve as a designer, improve how you think about things, make things, and show things to other people.

Lean UX and Think-Make-Check

Sometime around 2010, Janice Fraser wanted to bring better user experience to startups that didn’t have the budget or the time to do traditional design. Janice sketched a stripped-down, “lean” user experience process with three steps. First you think, then you make, then you check (Figure 1-1). After you check, you start over and think, make, check again. And again. Think-Make-Check.

Think-Make-Check isn’t lean user experience. Think-Make-Check is just user experience.2 Janice learned Think-Make-Check from one of her partners at Adaptive Path3 in early 2001. By Janice’s recollection, Think-Make-Check actually originated sometime in the late 1990s in HotWired’s4 user research lab.

Think-Make-Check frames design as a process of analysis and testing. You don’t need to do “lean UX” to Think-Make-Check. All designers Think-Make-Check whether they know it or not. Even you.

Think-Make-Check in Practice

Imagine you create a persona. You can divide the work into three steps (Figure 1-2):

1. Analyze existing user research.
2. Draft a persona document.
3. Share the persona with your client.

First you think about the users, then you make a persona, and then you check it with your client. Think-Make-Check.

Figure 1-2

You use the Think-Make-Check process when you create personas

Every design activity fits the Think-Make-Check model. Making wireframes? Think about the user’s context and what they need to do, draft a wireframe, and show it to the developer. Developing strategy? Think about the landscape, draft goals and vision, check it with the client. It’s Think-Make-Check all the way through (Figure 1-3).

Figure 1-3

Think-Make-Check runs all the way through the experience machine

If designers think, make, check all the time, you might ask: what do designers think, make, and check?

Design’s Four Concerns: Users, Interfaces, Interactions, and Systems

You can divide what designers Think-Make-Check into four topics:

• The User
• The Interface
• The Interaction
• The System

Every design activity you do and every deliverable you make combines and communicates users, interfaces, interactions, or systems. Every time you Think-Make-Check, you think, make, and check one or more of these four models. To create more effective personas, journeys, and wireframes, you need to understand what we mean by users, interfaces, interactions, and systems.

The User

Every product has users. You might call them customers, end users, actors, influencers, stakeholders, whatever. Design creates things people will experience, use, or get annoyed with. It’s not just designers that think about users. When you start a new project, everyone on the team pictures the user in their head.

Personas represent a model of your user. They are not real users. Real users click around and curse and search and do things. A persona gives your brain a model of a user to think about while you build the experience. Whether or not you actually create a persona, user models pop up in every wireframe or prototype you make.

Every wireframe and prototype assumes a certain type of person will use it. Whether or not you describe a persona or talk about a user, your team imagines who the user is when they see the design. Your team imagines a model of the user even when you don’t specify one.

The user is the most critical thing that you Think-Make-Check. When you think about the user wrong, you build products for the wrong user.

The Interface

How many times has someone asked you to make a wireframe? When most people think about design, they think about what it looks like. They think about the interface.5 When you Think-Make-Check designs, you probably review a picture of some kind of interface.

As a designer, you spend a good portion of your time thinking about and making models of interfaces. Architects draft blueprints. Graphic designers create mockups. Interaction designers code prototypes. Most tutorials and how-tos you see on the web focus on how you can better Think-Make-Check models of interfaces. Interface models are the easiest way for people to talk about a design because they’re so concrete.

The Interaction

The interaction refers to how users interact with an interface over time. Like users, interactions are always there. When you talk about a wireframe, you imagine how a user will see it, then click on something, then see something else. A wireframe seems like it captures a single screen at a single moment in time, but, in your head, you imagine a series of interactions between the user and several screens.

You think in scenes, not screens. Even though we spend much of our time on interfaces, interactions do a better job of describing the entire experience. Keeping the interaction in mind makes it easier to Think-Make-Check interfaces.

The System

When a user engages with an interface, we call that an interaction. When you connect several interactions together, you create a system. Sitemaps, journey maps, and service blueprints illustrate systems. Although you don’t always work at the system level, when you create a visual mockup or design a slick check-out process, you have an idea of the system in your head.

Though we don’t often think about the system, the system creates constraints and opportunities around our products. Architect Eliel Saarinen said: “Always design a thing by considering it in its next larger context—a chair in a room, a room in a house, a house in an environment.”6 Truthfully, you will find it impossible to ever design without thinking about the broader context. Whenever you Think-Make-Check any design, you have a picture of the system in your head.

The Four Models in Practice

As an example, let’s say you create a customer journey map. The journey map illustrates how a user moves into, through, and out of your system. The journey map documents models you and your team have made about the user and their interactions with some interfaces (Figure 1-4):

• The journey map assumes a specific type of user (i.e., your customer)
• The journey map assumes specific types of interfaces (i.e., your website, Google search results, confirmation emails, etc.)
• The journey map assumes specific processes (i.e., how a user searches for and compares products, how a user completes the check-out process, etc.)

Figure 1-4

The journey illustrates assumptions you’ve made about the user, the interfaces, and the user’s interactions with those interfaces

When you share the journey map with your team, you check that everyone has the same picture in their head for how the user will move through the system. You check that everyone has the same model. When you Think-Make-Check your model of the system, everyone on the team imagines who the user is, what the interfaces look like, and how many screens and clicks are involved in each of the interactions.

In product design, you spend your days Thinking, Making, and Checking models of users, interfaces, interactions, and systems. To build better products, you have to get better at two things:

• How you think, make, and check
• Knowing what model to think, make, or check

Each part of this book focuses on a different kind of model, and the tools help you improve how you think, make, and check by yourself or with your team.

Think-Make-Check should be easy, but I’m not sure you noticed: there are a million ways to make the different models. What makes the right persona? Should you make wireframes or prototypes or neither? What elements should appear in a journey map?

This reveals the fundamental question: How do we know what information should go into our models? What information should we include in our personas, wireframes, or journey maps, so we can check them with the right people?

When we talk about what information to include in a model, we’re talking about fidelity.