A product's success (or failure) largely depends on how a design process is organized.
A team generally follows two popular approaches when creating a new product: the waterfall approach and the iterative design approach.
The waterfall, which follows a linear design process from initial brief to final design, has been the most popular way to create new products for a while. But it has its flaws: if the initial requirements are inaccurate, a team can waste a lot of time creating a product that no one needs.
By comparison, the flexibility of the iterative process allows teams to ideate along the way and improve their solution during design iterations. Since the team constantly evaluates its solution, it also means that it has a higher chance of creating a product that will satisfy user needs and become commercially successful. We dig into all of that and more in this article, including how the iterative process of product creation works, its benefits and downsides.
What is iterative design?
Much like the name suggests, iterative design is a process in which you regularly create a design, validate it with your target audience and refine the design according to their feedback.
Three important facts about this design process:
User feedback and involvement are at the heart of the design process.
“You are not your user” is a simple rule worth remembering. The best way to ensure that you're building something valuable to your target audience is to show your creation to someone who will use it.
It's not a linear process.
At any point during this process, you can jump out and start again with new information: you keep improving the product as you work to meet user needs in the best way possible.
It requires deep collaboration between people involved in the design process.
Collaboration during design thinking helps to drive product design in the right direction. For example, if a team realizes that the initial project requirements were incorrect, they can reach out to stakeholders to discuss the issue, introduce necessary changes and restart the design process.
What are the benefits of iterative design?
Perhaps the most crucial benefit of this design process is treating a product design like it’s never finished. This might sound scary, but it's extremely powerful, and can greatly impact how you create products.
People rarely get things perfect on the first try, and good design takes time to get right. The more you hone an idea/concept, the better your solution becomes. Also, when you treat your design as something that is in progress, you’re more open to new ideas and solutions, and naturally more willing to introduce changes in your design.
This process allows product teams to:
1. Create more usable products.
User interfaces improved by 38 percent each iteration, according to a recent study by Nielsen Norman Group.
2. Learn whether a product solves real user problems.
Involving users in the UX design process allows you to get closer to the real problems they face every day and build rapport, which may eventually turn your participants into evangelists for your brand.
3. Reduce the cost of production.
The iterative design process allows you to find issues before your product is developed. Finding an issue prior to spending money and putting in effort to construct the product is much cheaper than retroactively solving the problem.
However, interactive design also has one crucial disadvantage. It doesn't have a default "definition of done," meaning it doesn't state when the team should stop iterating. As a result, without a clearly defined timeline and milestones, product design might be stuck in an infinite iteration loop and run out of time while iterating the design to make it perfect.
That's why experienced teams typically practice iterative design during design sprints. They set a clear timeline (usually between 1 to 4 weeks) and goals for design interactions (i.e., to explore problem space during the first week) and let the team experiment.
What is the difference between iterative design and long-term design?
The traditional product design process consists of a few phases. It starts with identifying a problem, ideating solutions, prototyping the best possible solutions, testing and refining them, and, finally, implementing a product. Both iterative and long-term designs have this design process in their foundation, but the key difference is how they treat the process.
Long-term design is basically a synonym of the waterfall design process. Plenty of iterations can happen within each of the phases. But once a phase is finished, you can’t go back to the previous one.
Iterative design, on the other hand, makes it possible to go back to the very first stage of the design process if you realize that something isn’t working.
What are the 5 stages of the iterative design process?
1. Identify a problem through user research
Before we dive into creating potential solutions, we need to know what problem we’re solving. Spending time solving a problem that doesn’t exist or isn't valuable to your users is a waste of time, money and effort for everyone involved. So, how do you better understand the problems people face, and that people will pay to solve? You learn about them.
Let's say we have a metaphorical food delivery app called Bites, and we want to know how we can make it easier for our customers to quickly find and buy their favorite meals. Techniques like user interviews and focus groups can help you better understand your target audience and what they’re interested in.
2. Ideate solutions
Once we have settled on a problem to solve, we begin to create potential solutions. People participate in design collaboration sessions to identify the best way (or ways) to solve the problem.
The ideas should be good enough that you can communicate them to a client, colleague or stakeholder—but rough enough that you wouldn’t care about ripping up the page and starting again. There is no point in getting too attached to ideas at this stage.
Once you’ve been through a few rounds of scribbling, feedback and further doodles, you can choose one or two concepts which you want to take forward and begin to prototype.
3. Prototype the best option(s)
Prototyping is at the core of the iterative design process. At this point, we want to begin making our designs look and feel tangible, so that we can test them and see if they work before moving into production.
An important step in design thinking processes as well, prototyping is a cost-effective method to see if the design we have in mind will perform in the way we had hoped, and to examine additional alternatives before it becomes too expensive.
The prototypes you create can be anything from simple pen and paper sketches to high-fidelity mockups. If you want to design a digital prototype, you can use collaboration tools like Figma, Adobe XD, or Editor X. The latter is ideal for creating high-fidelity prototypes of websites you can share with stakeholders.
While the idea at this point is to start polishing the designs a little, you should still refrain from falling in love with one idea. There is nothing more counterintuitive than a designer being too stubborn to admit they could do better.
If your team has more than one potential idea that you’d like to explore, prototyping is a great opportunity to go down several paths. The relatively low-investment prototyping stage allows you to test several designs, gather quick user feedback on them, and assess which of the options has the most benefits.
Last but not least, designers should collaborate more with developers during the prototyping stage. It's possible to explore what is tangible and what's not before sending the design to the development team. Check out more tips on how to work with a developer as a designer.
4. Analyze how good the prototype is
Now is the time to start reaching out to whoever will actually be using the product and eliciting their feedback. A common mistake at this point is getting feedback from management or the client company’s executives, but nobody else. While it’s great to keep everybody in the loop, your first priority should be getting the prototype in the hands of people who will be using your product.
The feedback you’ll get in user testing will be gold. The great thing is that you don’t need to invite a lot of test participants if you want to know how your solution performs. You only need to test a prototype with five users to identify the majority of usability problems that the prototype has.
Your next job is to create some sort of metric to analyze your prototype against, in relation to the problem you are trying to solve. For example, if your initial problem was that people struggled to find the top-rated local restaurants in your carry out app, you could record a metric on the current app of how long it takes users to find the correct option, and then compare that to how long it takes users on the prototype. If the prototype shows a significant improvement in efficiency, you’ll know you’re on the right path.
However, if your prototype confuses the user even further, this is an important point of reflection. Get as much critique from the users as possible, and use that new information to drive your changes and modifications in the next iteration of the design.
Based on how your analysis phase went, you have two choices:
Push forward with your current design and fully polish it.
Go back to the beginning with a new understanding of the problem.
Typically, if you’ve only had one iteration so far, the chances are that you’ll need to iterate at least once more. People rarely get things perfect on the first try, and good design takes time to get right.
You should stop iterating when metrics set by your team indicate that your design is good enough. No design will ever be perfect, and you may always have outliers in your feedback sessions who can skew your metrics, but the most important skill you can grow is your ability to know when to stop.
You can easily set metrics in feedback sessions by choosing a quantitative measure of success. For example, if your users can find the most popular local restaurant through the quickest possible route 70% of the time, you could consider that good enough.
Knowing when to move forward with the project is an important skill on its own. As a rule of thumb, more than three design iterations on an interface may hinder the experience in other aspects.
Iterative design example
As part of my role at my current company, my colleague and I have been responsible for the design of their application from the ground-up. We adopted an iterative design process throughout: from greeting a user into the app to sharing a certificate, every design decision has been very intentional and data-backed.
For example, when designing the certificate page, you can see how we went from a rather long design with a lot of options all expanded on the page to a short and simple design. The newest version still allows access to all the functionality, but reduces cognitive overload.
These incremental changes were based on user feedback. We used UsabilityHub to trial user journeys, and examine where people were running into issues.
Through a few rounds of testing, we found a good balance of simplicity and intuitiveness. If we had stopped at our first design, we would’ve only had a success rate of around 50%.
Iterative design will help you create user-centered products
Iterative design is all about creating user-focused products. Whether you begin small with iterating on a specific call-to-action, or you plan to redesign an entire application, it’s down to you to keep striding forward and improving the experience for your users. Just remember one thing about the iterative design process: perfect is the enemy of good. There is such a thing as iterating too much, and good enough is often better than trying to make everything perfect.