Following are the steps of the design process I am currently using. It’s a iterative and flexible process, and of course it changes over time.
- 1. Discovery
- 2. Define hypotesis
- 3.Prioritize Hypotesis
- 4. Design Solution
- 5. Test
- 6. Implementation
Step 1. Discovery
The discovery step is a preliminary and crucial phase in the design process that involves researching the problem space, framing the problem(s) to be solved, and gathering enough evidence and initial direction on what to do next.
It’s very important not to underestimate this phase, to be sure you have valid insights that are the foundations for the next steps of the process.
Essentially, the goal discovery phase is to understand who the users are, how they are affected by a particular problem, as well and their needs and values.
During discovery, the team works with stakeholders to understand overarching business objectives and desired outcomes and get answers to questions such as ‘what do we want to achieve?’, or ‘what does success look like?’.
This approach, in turn, focuses the team on the problems (and later the solutions) that will have the greatest impact on that outcome. The team should also have an idea of what to measure going forward, to understand whether the solution is working towards the desired outcome.
Step 2. Define hypotesis
Once identified the problem to solve and the users’ needs, behaviors and pain points, it’s time to define define one (ore more) possible solution. This is what we call hypotesys.
What is a design hypotesis? The design hypotesis is essentially a prediction created from a study of a given situation.
Let’s take for example a possible real-life situation: you dog is feeling sick or have some strange symptoms, you can probably say he is sick. This is a guess. But if you take you tog to the vet, he/she will ask you several questions to better understand the situation, and based on the answers and symptoms presented will define a hypothesis of possible illnesses. From there, the vet will probably do some specific exams that will eventually confirm the hypotesis.
Now the idea of what an hypotesis is sounds more clear, doesn’t it?
There are different hypotesis statement model. Personally I am currentli using the We Belive that statement model. It consists of three elements.
- We believe that [doing this] should detail your proposed solution to users’ problems.
- for [these people] would identify who you are targeting.
- will achieve [this outcome] is where you should document your measure of success. What is your expected result?
Step 3. Prioritize hypotesis
Generally at the end of step 2, there are several hypothesis and many of them seem to be valid.
But in the end you have to solve the problem in a defined time frame, so you have to choose which hypothesis to proceed with. And your decision must be as precise as possible to avoid wasting time and / or becoming a bottleneck for the rest of team.
Some of those includes the Value vs. Complexity Quadrant, the Kano Model, etc. Personally, what I am using the most right now is the RICE score model. RICE is an acronym for Reach, Impact, Confidence and Effort. Those are the four factors used to evaluate each hypotesis. In detail:
- Reach. How many people will be affected by that feature in a given time? For example, “users per month” or “conversions per quarter.”
- Impact. How users will be impacted from this feature?
- Confidence. How confident we are that this given solution will solve the user’s problem?
- Effort. How many effort will the implementation of this hypotesis need? It’s calculated on all the company
Once defined, those 4 factors are combined with a formula that give a more precise idea of what hypotesis is the most reasonable to invest on.
|Hypotesis||Reach (users/month)||Impact (1-5)||Confidence (%)||Effort (1-5)||RICE Score|
The step #3 is also the best moment to define how the success will be measured. It can involve business metrics (eg. CR, traffic, click-trough-rate, etc.), UX Metrics (time on task, task success rate, error rate, etc.)
Step 4. Design solution
And here we are, the funnies part. Once we have a clear idea of what we have to solve and how we want to do it, it’s time to give life to the project.
I usually start with sketching preliminary solutions using pen and paper. It’s more flexible than every tool I know and starts up the creativity.
The goal of this step is to figure out what UI components and styles will be needed in the final design.
After this, it’s time to actually make the design more precise: hi-fidelity design,
This is basically the moment when we start playing around with our defined UI structures. You start building typography hierarchies, a color palette, an icon style and so on to move your design from wireframes to high-res mockups. Of course, you won’t always have full control over these design elements. Sometimes you’ll need to respect a set brand guideline.
Once, during college, a great teacher told me that the only way to become a good visual designer is to soak in quality design. By constantly watching and admiring good design you actually build a visual criteria and learn how to best combine shapes, colors, and fonts to create an interesting piece. This does not in any way mean that you should copy another designer’s work because as you of course know, that’s unethical. Also, I think you wouldn’t enjoy it if done to you.
What I like to do at this moment
Anyways, what I’m trying to say is that I like to start out by creating a visual mood-board, where I collect inspiration that is relevant to the current problem that I’m trying to solve, and to the audience that I’m trying to solve it for. That way I can get acquainted with the standard visual languages used in a set field, for a set audience.
Step 5. Test solution
If the solution is validated (you are enough confident that the selected hypotesis will solve the initial problem) you can go forward with the implementation of the feature.
Otherwise, you’ll have to step back to #3 and work on another hypotesis.
Step 6. Implementation
Finally, it’s time to develop the selected feature! Handoff with developers, monitor results.