When to use iterative design
Although iterative design can be incorporated at any phase of the software development life cycle (when the solution has been launched, but you want to seamlessly introduce new features or improvements), multifunctional teams prefer to either iterate or not — to make the whole process more productive and cost-effective.
Indeed, it’s much easier and cheaper to develop a prototype and test it than to build the whole system and fussily start making changes according to user feedback. Moreover, the tech market offers a great number of powerful tools you can make use of to enhance the prototype development.
And if you’ve come up with several variants of key features or early-stage products, iterative design can really help you to choose the right starting position and go ahead with it until invalidated or a pivot is needed.
Iterative design and agile methodology
Iterative design is closely intertwined with Agile software development. Unlike the traditional waterfall model with its stringent development stages, iterative design welcomes new information that may affect the initial requirements.
The process starts with research for user needs or with a hypothesis. Then, the team meets to compile a list of desired features or functionality, known as a product backlog. After the features have been worked through and prioritized, they are implemented within short timeboxed cycles (sprints), with each sprint typically lasting one or two weeks.
Once the first functionality has been released, the development team receives feedback from the product owners and users. This feedback is analyzed during a sprint review and serves as a cornerstone for planning the next increment. In other words, the team proceeds to backlog grooming and prioritizes features for the next sprint, which might include, for example, addressing the bottlenecks found in the customer journey.
However, when the feedback reveals evident bugs that can’t wait a week to be dealt with, the team proceeds to so-called hotfixes.
Getting started with iterative design
Iterative design presupposes the completion of three key stages.
User analysis and design thinking
Like in most software development models, iterative design starts with user analysis. Based on the gathered information, you identify the major problems and goals that will help you define the core functionality of your future product.
For example, if you’re building a live streaming platform, you’ll probably deal with the need for high quality of streaming content, cross-browser and cross-device compatibility, an advanced video player, multiple payment options, and more.
With all this information in mind, you proceed to solution ideation, akin to the third stage of the design thinking model. During this stage, you’re looking into the ways to solve the above-mentioned problems and, in agreement with your client, create customer journey maps, user scenarios, and personas.
During the ideation stage, you can implement one of these design-thinking techniques:
- Brainstorming represents an oral discussion of various ideas (even wild ones) in the group and blending them to create the optimal one.
- Brainwriting consists in writing down new ideas on a sheet of paper and passing it on to other team members for tweaking or enhancement.
- Brainwalking is very similar to brainwriting; the core difference is that it makes the participants get out of their seats and move to other spots of the brainstorming table.
- Braindumping is individual brainstorming that entails sharing the ideas in the group later on.
- SCAMPER helps you explore new ideas or review the existing ones by looking at them through seven “provocation lenses”: substitute (S), combine (C), adapt (A), modify (M), put to another use (P), eliminate (E), and reverse (R).
Design and implementation
When the initial planning and analysis are out of the way, it’s time to get down to prototype creation (if it’s a new design) or to expand the already available design.
To continue with a streaming app example, you’ll have to tackle the following challenges:
- Creating an uncluttered UI
- Optimizing the system for various browsers, platforms, and operating systems
- Introducing various subscription models and payment options
- Building a customizable video player with DVR controls, subtitle management, and multi-language support
- Implementing a holistic CDN approach so that the system could support a slew of simultaneous users.
Testing and evaluation
When the first shippable functionality is delivered, it’s time to implement a range of testing procedures to identify potential bugs and make the corresponding changes. During this stage, you also get valuable feedback by trying your product on real users.
For instance, with UI and UX testing, you’ll make sure your video streaming app matches the initial mockups and that all users, including those with disabilities, can easily navigate the app — across all resolutions and screen orientations.
Functional testing will help verify that your app behaves the way it’s supposed to. This may include validating the correctness of user data, like purchasing or personal information.
Integration testing will check how your solution interacts with third-party systems, such as payment gateways. Another testing type you’ll likely tap into is load testing aimed at determining a system’s behavior under normal conditions and peak traffic.
After all the needed testing procedures are complete, the evaluation or review phase begins, where you and your client discuss where the project is, what should be changed, etc. This is the heart of iterative design, when you’re brought back to the first stage and repeat the process.
Looking into examples and case studies
The use of Wikipedia is probably one of the most notable examples of iterative design on the web. It creates content that can be changed by any registered user. The introduced amendments are either accepted or rejected by the editors — according to Wikipedia’s policies and guidelines. The idea is to help Wikipedia evolve to become the go-to online encyclopedia.
Although the use of wikis is not a replica of the iterative design of your project where you have more control over changes, it’s a clear illustration of what the incremental process looks like.
As for more specific case studies of iterative design, the Nielsen Norman Group (NN/g) used rapid iterative prototyping to redesign their homepage.
The first stage consisted of re-analyzing the audience they had in the past (thanks to many-stage usability testing) and a number of qualitative surveys to understand customer reactions to the website and the whole brand. The results of this analysis helped NN/g define their major design objectives, like showing more credibility, creating great aesthetic appeal, and keeping clear pathways to primary offerings.
During the second phase of the homepage redesign, the company used Moqups to build multiple high-fidelity visual prototypes. Those mockups passed three rounds of repetitive testing and new users on both desktop and mobile devices.
With each new round, the NN/g’s team was getting relevant user feedback that was categorized into themes like architecture, layout, and visual style. Based on the received feedback, the designers were able to prioritize the features and make the corresponding tweaks on the homepage.
As a result, such an iterative approach allowed NN/g to explore interesting design options without wasting time on early coding. Moreover, the company managed to maximize user feedback and make live enhancements during usability testing.
Enjoying the benefits of iterative design
The NN/g’s case study shows that the cyclic process of designing a product bears its fruit. Iterative design allows you to vastly improve product versioning, increase its quality, as well as easily adapt to changing user and market requirements while succeeding in building truly user-centric products. This model will also help you ensure outstanding usability, leading to a steady client base growth, strong customer loyalty, and ultimately more money in the bank.
On top of that, the incremental approach to design will help secure smooth communication and collaboration between team members, active customer involvement, and better visibility for stakeholders.
Designers are increasingly opting for the iterative design model because it lets them create and test ideas faster than ever. The concepts approved by users on early stages can continue their way toward a successful market release. And those that fail to gain traction can be rapidly abandoned, minimizing the cost of the project. As a result, by putting user experience at the crux, iterative design helps you magnify chances for the overall success of your solution.
This is a guest post by Yana Yelina. Yana is a technology writer at Oxagile, a custom software development company based in New York. Yana’s articles have been featured on Creative Bloq, UXMatters, UX Planet, and more. Yana is passionate about the untapped potential of technology and explores perks it can bring businesses of every kind. You can reach the author at email@example.com or on Twitter, LinkedIn and Medium.