Learn what goes into an iterative design and how designing app and software projects (and more) by iteration can make the design process more fluid.

Designing software such as a mobile app is a hugely rewarding and satisfying project to undertake. However, when we’re first starting out, it’s super-easy to jump right to the end, thinking about this all-singing, all-dancing wonder app that has bells and whistles and widgets and features for days.

Nobody is going to knock you for thinking big and aiming high. The problem though is that when you get down to making it, you suddenly realize that all of those features actually equate to a colossal amount of complexity. And then you get to thinking about how it all fits together, and before you know it, this little bundle of joy you were going to bring into the world with a fanfare and a marching band has become more trouble than it’s worth. You abandon the project, the band goes home, and you head to a bar.

So what if we told you that you can have your cake and eat it? You see, software design doesn’t need to be like that. Here’s how.


What is Iterative Design?

If you are designing iteratively, you are creating version after version of your sketch, app, website, or any other creative project. Each generation of your design builds on the previous one as you fix bugs, add features, and hone in on your core concept. Instead of a finalized ideal, each iteration stands as an improvement over previous versions and a springboard for the next.

Iterative design might use prototypes, user testing, or focus groups to test the functionality and quality of a project. The designer will take the information they gather from these tests to then alter, improve, and refine the existing design. Let’s look at a real-world example.


What Does Iterative Design Look Like?

Before Facebook purchased it, Instagram was a relatively small project started by two friends in 2010. At its conception, it was only available on iOS and would only present pictures in perfect squares. Hashtags, highlights, Stories, and IGTV didn’t exist and came many, many years later.

Given its mass appeal, we often forget that Instagram, much like every other app, started life very humbly. It only blossomed with additional features and improvements over time.

Instagram as an Example of Iterative Design
Instagram has changed considerably through the years since its inception in 2010. Each iteration has brought new features and an updated and improved user experience.

Edit, edit, edit

Think about the app you want to build and ask yourself this: what is the single essential thing that it does? If you’re building an email client, it’s a safe is sending and replying to email. If you’re creating the next Instagram, chances are sharing images is where it’s at. Or, if it’s a puzzle game, interacting with and completing the game is your highest concern.

We call this the “minimum viable product” (MVP). This is the version of your product that you can take to market with the fewest features possible.

Now you may be saying: but hang on, this is opposite of what I want to create, and you’d be right. You see, the beauty of designing this way is that you don’t have to figure out how the whole thing works straight out of the gate. You also get something out to market much more quickly than if you wait to build every feature and component. Sure, it doesn’t have everything you hope to include in the future, but hanging around until everything is ready is a recipe for disaster. Many software projects never see the light of day because we want to include everything but the kitchen sink…so we never finish the thing at all.


So how does it work?

Iteration, by definition, is the process of incrementally improving something, such as software, by methodically working your way through a list of features until they’re all implemented.

Unlike traditional design methodologies that are linear and have clearly defined start and end points, iteration acts like a cycle. Working iteratively, you take each group of features and feed them into the process, and after one set of features works its way through each step, you then take the next group and do the same thing. This way, you slowly build up a more and more comprehensive set of features within your app that have all passed the same series of steps. This ensures each feature is well-tested, built to last, and holds a clear place within your app.

The Cycle of Iterative Design
Iteration is a continuous cycle of incremental improvements

Creating an Iterative Design

There are a few steps to keep in mind for each iteration of your design. Revisit these stages as often as you need.

Ideate

The first step is to generate as many ideas for the feature as possible. Think about the feature from the customer’s viewpoint: how will they benefit the most from this feature? What design considerations should you follow to make it happen in a way that makes sense to the customer?

Generate Ideas for Iterative Development
Iterations vastly increase the ability to generate ideas. Image via Ksyu Deniska.

Prototype

Once you’ve nailed down the key elements of the new feature, prototype it to see if it will work in practice. This step allows you to iron out any complexity or polish any edges without committing a huge swath of time to building the feature for real.

Build

Now you’re clear that the feature is good to go, build it out as an update to your product.

Analyze

Once the update has been pushed to the public, conduct analysis to gauge how customers are reacting to it. Surveys, focus groups, and interviews are great ways of generating feedback and garnering opinion on how you can improve it in the future.


Developing Your Design

It can be hard to work out where to start when you switch to designing iteratively. Here’s some ideas for those initial runs through the cycle:

Core Functionality

Getting your core functionality nailed is the first and most important milestone. This is the thing that holds everything together, and in the future it will be the foundation you build everything else within the product on. So, take the time to make sure this functionality is rock solid.

Prototypes and user testing will be your best tools here. User testing can expose non-functional code, broken links, or even things as simple as unappealing color combinations. Then, you can use the feedback from testing to improve your product’s functionality for the next iteration.

Core Functionality is Key for Iterative Designing
Whatever changes you make, keep your project’s functionality first and foremost. Image via Visual Generation.

User Journey

As soon as you have any kind of functionality in your app, you also have the ability for users to get lost. We’ve all used apps where we’ve ended up somewhere we didn’t mean to be. The experience can be jarring and off-putting. Avoid this by mapping out your preferred user journey, and build that into your primary functionality and any functionality that comes after.

Branding

Next up, you probably want to think about the attitude of your app and the story that it tells. What does it look like? How does it make users feel? What’s it’s angle? Branding helps to shape your product into a cohesive experience that tells them that this you made this product.

Beyond the Basics

Once you have these core elements in place, you can start to implement additional features you’d like the app to have. This could be an extension of the core functionality you’ve already built or a set of supporting but separate features that extends the usability of the software. As you build out more and more features within your app, you may also wish to revisit the core functionality, the user journey, and the branding, to ensure they continue to meet the needs of your customers. That’s the beauty of iteration — nothing is ever done, and everything can always improve.


Iterative Design in Action

iOS, the operating system that runs iPhone and iPad, has been in constant iteration since its launch in 2007. Originally, the main focus was to create a system that would support phone calls and text messages via a touchscreen. But over time phones morphed and evolved so much that calling people is no longer the primary feature of iOS. Apple now releases an updated version of the operating system every year. What started out as a simple concept is now a multi-billion dollar business.

Apple iOS as an Example of Iterative Design
iOS has seen material upgrades to every aspect of the operating system. The springboard, or homepage started with a rigid and unmovable set of apps. Later, the ability to delete and move them was added. Finally, force touching (holding down on an app icon) now reveals additional functionality and features without even opening the app.

Takeaways

Designing iteratively may take a little getting used to. However, its fluid and cyclical approach has many benefits:

  • Releasing your design in small chunks ensures you get to market sooner than if you waited to fully develop every feature and nuance.
  • Running each feature through the process cycle means greater points for discussion and feedback, and there is more space for left field ideas that could very well become key facets of the final product.
  • Customers appreciate this approach as it allows them to be more involved and gives them the confidence that things are constantly moving.
  • Constant iteration dispenses with the feeling that you are on a never-ending track to nowhere, which is great for your sanity!

Uncover tips and techniques for designing websites and more with these articles: