Iterate, iterate, (...), and succeed: The importance of iterative design on a product lifecycle

Don't try to build a car if you don't even have proof that users want a bike.

Someone told me this once. And I can't agree more by now.

Building a product is something challenging. Putting ourselves in the user's shoes makes us uncover users' frustrations and identify their problems, which really motivates us to generate ideas and build something for them. Something to meet their needs.

And we want to believe that our solution will be a rock star that users won't stop using. But by the time we finish it, we'll have a hypothesis. A candidate to a solution. Even the best usability experts won't be able to work on a perfect solution with just a single attempt.

So, why should be we spend time building the most robust and complex solution — such as the car example — if we can design a simple one to prove our concept —  as a bike — that can be quickly validated and iterated based on feedback?

Eventually, our bike will turn into a car but let users drive us in the process.

From Prototype to Iteration

Iterative design can be a huge help at any phase of the product lifecycle.
It will allow you to incrementally refine your product based on users' feedback, so you'll know that you are moving in the right direction. So, this iterative approach will be the most cost-effective one, either on an initial go-to-market phase or if your product has already been launched and you are looking to improve it. The earlier you implement it, the more effective and user-oriented your growth will be.


It's almost always safer and cheaper to create a prototype, which might consist of low-fi wireframes or even paper sketches than it is to develop your solution from a gut feeling and then amend it based on user reactions.
It can be a waste of time and resources.
You'll find lots of tools that help you create your prototypes (some design tools already incorporate them, such as Figma does) — so make the most use of it and help your product grow in a sustainable way.

And don't forget: make your solution simple enough to avoid taking you a tremendous amount of time but viable enough to deliver the expected value, as a Minimum Viable Product should be.

Prototype → Test

Once you have your prototype ready to be tested, make sure you find a considerable amount of users to test it. Take notes, identify the problems they had and listen to their thoughts and requests. Then, move forward to the next iteration of your designs. You should then test it again to ensure that the adjustments made solved the problems identified.

Prototype → Test → Iterate

As soon as you have a solid and validated solution, move it into the development and watch out for users' reactions — new requests and adjustments might be required, either to adjust some flaws identified by the users or to evolve your feature to the next level.
That's why the agile mindset is so important in this changing environment.

To make the advantages of this approach visible to you, we'll present you a very special project  built together with Village Capital folks, where this mindset has been the key to success:
Let us introduce you to Abaca.

Into practice: Abaca WebApp Example

Abaca is a WebApp built by Pixelmatters and Village Capital, where an iterative design process was crucial to make it shine.

Each work cycle is MVP-oriented, balancing the value it will bring and the effort it will take, and also teaching us how to fulfill user needs.

We are working on a daily basis to transform their VIL (Venture Investment Level) framework into a WebApp, supported by a sophisticated matching algorithm and assessment mechanism. This algorithm helps entrepreneurs and investors meet each other, find their common interests, create relationships that, ultimately, can lead to good investment opportunities — so a win-win situation for both parties.

This has been a long long journey that started a couple of years ago. And what a beautiful ride this bike took, that with each cycle, makes us even closer to proudly name it a car.

The Problem

One of the biggest challenges we faced was the "Matching" feature, a way to match entrepreneurs and supporters that helps them find each other.

This matching algorithm considers core metrics like the Venture Investment Level, attributed to Entrepreneurs based on their milestones' progress, and to Supporters based on the Venture Investment Level range they are looking for on Entrepreneurs. Other metrics used are location, industry sectors, and other secondary criteria.

A matching percentage would be calculated between them taking all of those criteria into account.

We also wanted to encourage users to improve their matches by adding other criteria, so that was another requirement to have in mind.

As a good match should be, after the love at first sight, someone needs to take the first step and show some interest or should I say request a connection? 👀

Well... let's take a deeper look.

The Proposed Solution: First Iteration

After some brainstorming sessions and layout explorations on the wireframes phase, we came up with a simple yet valuable solution for the Matching feature.

This started to come to life as wireframes, but after some back and forth making sure it was aligned with stakeholder expectations, the UI phase was not long in coming.

Soon, the matching feature was developed and launched. And we were very excited to see users' reactions 🚀 👀

The Evolution: The Iterations

Although it was a huge good surprise and very well received by our users, some feedback started coming our way, as expected — users were asking for some tweaks here and there but they were also looking for other new features to make this Matching tool even more powerful.
So we move forward into a couple of other iteration cycles until we reach a solid and validated solution at the end with already a level of complexity that users incrementally asked us about.

Note that in each cycle, we worked on specific user requests that were released separately.
This iterative approach also helps users assimilate and absorb the changes with time, by understanding some logical changes without feeling confused or overwhelmed.

Summing up the changes made throughout the multiple iterations:

The Discover page become cleaner and easier to digest, making overall a better use of space:

By now, we find ourselves in a comfortable position on Matching, but always with an eye open on what may come next. This is an ever-ending process, while users keep using the product every day.

As you can see, this iterative process is nothing but a methodology that can be applied to every piece of your product. We are currently working on a new feature where the process has been exactly the same, as it already proved us to be successful in multiple contexts.

So, why should you take this iterative approach?

At this point, you should be able to recognize the benefits of using this iterative approach on your projects. But here's a list of undeniable advantages that we'll make you embrace this often:

As designers, we'll learn about when to abandon ideas that totally fail and embrace the promising ones, that can be iterated rapidly until they take sufficient strength to be developed.
It's a cost-effective approach where the user experience is put at the heart of the design process.

Hope this helps you with your projects!
Can't wait to see your bikes turn into the most functional cars.

→ Got curious about Abaca WebApp? Take a look at our case study.

Follow Pixelmatters on Twitter, Facebook, LinkedIn, and Instagram.

Eunice Costa
Product Designer