Let’s say you have an idea for an innovative digital product that the market and users need. Your next step is to attract a team of specialists who can round out the idea so the project can receive the investment it needs for further development. But what exactly does your team need to do to impress investors with the product in its early growth stage?
This issue can be considered in different ways, from a global analysis of possible mistakes to detailed delving into each creative process. As a UI designer, I’d like to share a few insights about how a product design prototype should be created, what differentiates a good prototype from a questionable one, the kind of prototype that users and investors want to see, and why it all has to do with human-centered design.
What Is the Human-Centered Design Approach and how Should it Work?
Human-centered design (HCD) is an interface design methodology that focuses on the users of the product, their needs, and pains. In HCD, people are the key factor in prototype validation at each design iteration.
Over the past few years, more and more products developed by start-ups and established companies have adopted the HCD methodology, having gradually shifted their focus from purely business needs. Below are the main reasons why more companies might benefit from human-centered design. Later in this article, we’ll discuss them in more detail.
- Users find HCD products more valuable, which makes the product more competitive in the market.
- An interface designed using this technique will be effective.
- The workflow algorithm is clearly defined and transparent to all participants.
- The HCD algorithm allows you to improve existing products without the need to create new ones from scratch.
- Product owners clearly understand what user problems their product targets and how it will solve them. This is often what the traditional initial development stage lacks.
- The technique allows you to avoid possible conflicts between the product’s desired functionality and its technical capabilities;
- User testing of the prototype is a mandatory part of the HCD process that enables the developers to detect and solve potential product errors before they occur during later development.
The market is already full of products that make our life easier, whether they’re analog goods, software, or mobile applications. To get users to pay attention to your product among hundreds of others, you must offer an innovative approach to solving their problems. After all, how well the product satisfies users’ needs will determine the product’s market success.
Having innovation at the core of your future application or service is just step zero. Designing an efficient interface is the next major challenge. There are plenty of stats that indicate how disruptive an awkward, incomprehensible, or poorly adapted interface can be to a product’s value. Of course, today there are a lot of methodologies and guides that can help us make a design convenient, and following them will eventually lead you to results. However, none of these guarantees that your product will be warmly received in the market and liked by users.
The only way to get this guarantee is to involve users in the development process. With them on board, you’ll receive feedback about their experience at each iteration, which allows you to change the service or the application interface. This is precisely the core of the human-centered design methodology. And when you have a development team that uses this methodology to create your product, you’ll know at the MVP release stage that every function, every element, every step of your user flow is in place, in the exact configuration that your potential users need.
Human-Centered Design Process: What Does It Look Like?
The general sequence of prototyping steps using the HCD methodology can be visualized through the following algorithm:
Now, let’s discuss each step.
1. Identification of the needs and planning the HCD process
This is the first basic stage, at which the main task is to plan the process by distributing tasks to all subsequent stages, appoint the people responsible for the processes, and outline a general scope of work. That’s also when the team chooses the specific methods within the human-centered design process that are most appropriate for the particular project. At this stage, it’s also necessary to agree on all the details between designers and stakeholders regarding the overall project vision. This synchronizes the process and helps avoid costly mistakes at later stages. All organizational issues, such as setting up communication channels and agreeing on deadlines, should also be resolved here. As you can see in the diagram, this is done only once, at the beginning, unlike during the subsequent stages, when going back and forth is possible.
The ideal outcome: A pivot table that includes all the business analytics, task prioritizations, estimated design team efforts, and ongoing readiness levels. This table may be updated as the project unfolds.
2. Understanding and specifying the context of use
Next comes engaging potential users. Our main task here is to determine who these people are and what problems our product will solve for them. Research, target audience segmentation, user persona creation — all these fundamental processes take place here as well. Based on the data obtained, the team develops hypotheses in the form of assumptions about what an effective design is supposed to be. These hypotheses are the basis for future design solutions, as they aggregate all the insights received from the target audience, statistics, and analytics.
The ideal outcome: A table of the user’s mental models that includes their characteristics, key points of view, the use context (technical and physical conditions of their environment), as well as a structured list of hypotheses.
3. Specification of the user requirements
Now that we have all the input data, we can move on to the next step, which is clarifying requirements and creating specifications. Here we summarize the available information, define the functionality that will meet the wishes of all users, and formulate detailed technical tasks based on the data above.
The ideal outcome: In practice, duplicating the list of requirements in the form of a narrative or script fits very well into the human-centered design approach. After all, we’re designing an interaction, a story where no element should be taken out of context. However, checklists can be used for detailed or group structuring, so it’s best to use both tools at the same time and update them regularly. Plus, it’s important to check both for clarity: all points should be written simply, so that later it’ll be easy to test the prototype for compliance with them.
4. Prototyping the design
Now comes the prototyping stage. Here, we operate with real data gathered earlier in the hypothesis. How does the HCD methodology change it? Mainly, it allows for iterative testing and improvement. Testing as such is the essence of this stage: in the beginning, it can be paper prototyping, through which the necessary user reactions are collected. Then the paper prototype turns into a wireframe that gets tested in the same way. At this sub-stage, it’s better to divide the key flow into 2-3 scenarios, evaluate the users’ interaction at each of them, and stick with the optimal one. Finally, we’ll have a fully fledged UI. Again, we’ll observe users’ reaction to it and make all the necessary adjustments along the way. This whole step and its arrangement is what makes HCD so effective.
The ideal outcome: A prototype with the readiness level planned during stage 1. Oftentimes, it’s the product’s MVP. However, it is important to note that for some projects, it’s better to divide each prototyping sub-stage into a few iterations, as it will enable early development. In such a case, the current step will consist of one phase of prototyping, testing, and adjustment according to the new data obtained. The choice of a particular strategy takes place during stage 1 and depends on your convenience, timing, team, and budget.
5. Evaluating your design
The final stage of the iteration is checking the finished prototype for compliance with the requirements. Of course, user testing serves again as an important part of this step. If at the previous stage we checked individual scenarios and parts of the user flow, here we evaluate the development as a whole in its full existing format. In addition to testing for compliance with the previous requirements, we collect information about general impressions and specific wishes/feedback from users, and thus start to form requirements for the next prototyping iteration.
The ideal outcome: A prototype ready for release or the next iteration (depending on the specific strategy formed during stage 1).
After that, we return to stage 2, either to clarify the current version or to release the product and move on to develop the next version. Once we’ve gone through all these stages correctly, we end up with a fully-tested design that meets the requirements.
Testing Guidelines the HCD Design Team Should Follow
There are many specific user testing methods to apply in practice. In this section, I’ll present the general testing principles.
- The closer to the real people, the better. Budgets and deadlines don’t always allow for a detailed data analysis from potential users, but in this case, a more detailed collection of information always produces a more accurate result. Testing a prototype, even with a small target audience, gives a better result than no testing at all.
- No explanations or judgments. In the testing process, telling users exactly how the product should work and what kind of interaction the designers intended for is a surefire way to undermine the whole idea. The point of testing is to understand how the prototype performs with real people, how the potential users see it and interact with it. They can’t be wrong, so if they don’t behave the way the designers planned, then the prototype needs to be changed.
- Offer alternatives. You’ll have a much better understanding of how people want to interact with the product if you offer them 2-3 options at once and then collect feedback about each interaction. Of course, in the later and more detailed stages of prototyping, this can be cost- and time-consuming, but during the initial testing of the user flow, you don’t need unnecessary details. The best strategy is to make simple interactive sketches of multiple options and let the users test them so you can collect the information.
- Express empathy. It’s important to note not only the actions the users take during every script stage but also what they feel. After all, good design is always a story that should leave pleasant emotions for the user, not make him nervous. Deep empathy will help you notice “points of irritation” and eliminate them in the further prototyping process.
- Encourage them to leave detailed feedback. Observing and testing is only half of the job. The goal is to obtain relevant data. To get the most accurate data, we use specific detailed questionnaires to complete each of our user tests.
The Difference Between Good and Bad Prototypes
This is where we return to the issue of attracting investment. We’ve already figured out the methodology that will make your product attractive for investment, but how do you know when your result meets expectations? By embedding the HCD standard in the development process, which helps with the implementation of each item on this checklist.
- The prototype and functionality incorporated into it fully correspond to the technical capabilities of the development. The human-centered approach addresses this issue at stage 1 (definition and planning) and, partially, at stage 2 (context of use specification).
- When presenting a prototype to investors, it is important that you already know the exact answers to questions about needs and how the product solves them. Given that the requirements drafting in a format suitable for compliance testing – and further testing – are a must within the HCD methodology, this issue will also be addressed at the stages that precede the presentation.
- A good prototype explores all possible scenarios, including the least-probable ones, as well as possible mistakes. Even if an issue isn’t addressed immediately, testing it with more users will help detect the flow’s weak points at the initial stage and find the most convenient ways to fix them.
- A good prototype prioritizes the importance of the proper distribution of different functions. It shouldn’t be overpacked with them or look confusing. Today, a quality product leads the user according to their scenarios, without forcing them to make unnecessary choices or change the settings. And that’s precisely the point of the entire HCD process in the early stages, where we determine exactly what people need from the application or service. Defining the requirements comes next and it’s where we formulate the received data into clear tasks. It ends with testing. Here we can clearly see whether the people who interact with the product feel confused.
- If anything draws a line between a good and bad prototype, it is whether or not the product is a pleasure to use. It should look modern, and most importantly, the look should correspond to the product’s content and functionality. To be confident about the quality of your design, it’s not enough to like it yourself. This confidence, however, can be achieved by iterative testing, which allows you to know when users are satisfied with your product. That’s what you and your investors need, and what HCD aims for.
The Role of HCD in the Product Development Process
Developing a digital product from scratch is a complex task that involves many risks. We’ve already figured out the how and why of the application and that adherence to the HCD methodology guarantees a high chance of success. But in recent years, the popularity of the human-centered approach has increased so much that many existing projects integrate it into their design process.
Does it mean that HCD not only helps develop an innovative product but also prevents typical mistakes inherent to any business? I think it does, and here’s why.
HCD has a well-defined process. No never-ending disputes within the team about the interface, in or out of the discussion stage. The user is the main judge and authority for pursuing a particular solution, and the user’s opinion is recognized as the most objective. However, the team is given a list of requests and requirements that simplifies communication and development.
In many projects, the development process shifts its focus to the nuances of solving certain technical problems and neglects to consider the product’s target audience. Introducing HCD will solve this problem as well because development will focus apriori on the problems seen by the users as such. Also, this will partially solve the team scaling problems. How? With a high level of understanding of the necessary tasks, it’s much easier to assess both the time and human resources that will be needed during development at each separate iteration. That’s why the result will exactly correspond to the initial goal, which, again, is to satisfy the user’s needs.
HCD resolves issues that are well-known to both designers and product owners. I’m talking about the lack of information regarding the desired result, inaccurate technical tasks, and the lack of understanding of the final goal. When HCD is applied, all these issues are covered even before you start working on the prototype, and they get refined with each subsequent iteration.
The most successful product on the market is the one that best serves the needs of its users. All other things being equal, people will always choose the most convenient, most pleasant, most intuitive interface. Following the human-centered design methodology during the development process helps achieve this result. It might seem that all these stages and iterations only complicate the process. The truth is, clarifying the details of the functionality in the early stages leads to significant budget savings later on. This is why Django Stars’ design team always supports the integration of human-centered design into our customers’ projects.