The Three Key Phases to Successful Iteration
Tags: tech, agile, appdev
Published: 2021-06-21 13:15:43

---
title: The Three Key Phases to Successful Iteration
published: true
description: Modern software is about being agile. To be agile, you have to iterate. To iterate successfully, you must understand these three things.
tags: 
  - tech
  - agile
  - appdev
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/mndams6yyt72ha340mk9.jpg
---

Iteration is important.

I'll say it again. **Iteration is important.**

It's something I talk about regularly because, well, it's worth repeating. 

Software is never done. Requirements change over time, your understanding of the business problem will change, and your application will be enhanced as you add new features. As you build more, you'll revisit existing functionality and make it better. You'll realize *this isn't actually what the customer wants* and tailor a better UX.

You'll get into a new tech stack and want to refactor your solution. The list goes on and on with the many opportunities you will have to iterate on your solution. 

I've written about [why you should iterate](https://www.readysetcloud.io/blog/allen.helton/itturat-ituratte-iterat-iterate-iterate-65199c4d5d53) in a prior post. Today we're going to talk about *how to be successful with iteration*.

What does that even mean? Iteration sounds pretty obvious, right? Doing something over and over again is iteration. While technically this is true, it's not going to yield you the results you or your company wants in the long run.

Successful iteration is broken down into three phases:

1. Do it.
2. Do it right.
3. Do it better.

Seems simple enough. Let's dive into each of these phases to understand what they mean.

## Do It
Also known as the *let's see if this works* approach, the first phase to successful iteration is about getting it done. Any startup will tell you the most important aspect of building a new product is your **time to market**. The longer it takes, the more opportunities your competition has to beat you to your customers.

This is an experimental phase. It isn't necessarily the way it *should* be done in a production environment, but you need to get feedback on whether or not you're building the right thing.

Do it quick, do it dirty, get feedback.

Before we continue any further, I feel obligated to remind you that you [should never use proof of concepts in production](https://www.readysetcloud.io/blog/allen.helton/4-reasons-you-should-never-use-proof-of-concepts-in-prod). If you have a test environment for your customers, this is the perfect opportunity to use it. If you don't, be strategic in how you develop in this phase.

The *do it* phase is not about putting a proof of concept into production. It's about **safely** satisfying a business process in as short amount of time as possible. 

Getting feedback early and often is crucial to building the right thing. Don't wait until the end to share it with your customers. That's [how waterfall development works](https://www.readysetcloud.io/blog/allen.helton/will-waterfall-development-ever-die-probably-not-6ab4589e061), and while it isn't wrong - it should be used sparingly.

This phase is about learning and discovery. Take a few reps to get a feel for the ins and outs of what you're building. It's ok to start over a few times. Starting from scratch is never a total loss. 

Keep in mind that while you might not have working software if you restart, you've gained valuable knowledge for the future.

## Do It Right
So you've successfully satisfied the business problem and gotten your new software out in front of a client. Bonus points, they liked it! 

Now it's time to make it official. Build up your new feature/product with production quality best practices. Incorporate [automated tests](https://www.readysetcloud.io/blog/allen.helton/dynamic-test-generation-with-oas) around your APIs. Make sure it adheres to your coding best practices and standard patterns.

If you're incorporating a new tech stack, start documenting the new best practices. You're establishing a new way of doing things and you want to make sure the next time someone builds a new feature, they follow the same path you did.

*Doing it right* might involve complete refactoring your first phase. You might have skipped a few steps or cut a few corners to get that market exposure ASAP. That is ok. 

What you did was build a better understanding of how it was supposed to work. Be it your new tech stack or a new business process, you've practiced and furthered your comprehension of the subject. Take your lessons learned and apply them to the best practices you already have in place. 

This is your opportunity to turn your proof of concept into a high-quality piece of software.

You will spend significantly more time in this phase than the prior. You've gotten your feature to market and customers are using it. Now it's your turn to enhance it and make it more stable. Build it up to accommodate the feedback you've been given. Time to market isn't a factor here anymore. It's already out there.

What is a factor is stability. You want to focus on high-quality production code in this phase. Utilize established patterns to make your software strong and reliable.

## Do It Better
Now that we have strong, production-quality code, it's time to make it better. Start turning your attention toward things like [enhancing performance](https://www.readysetcloud.io/blog/allen.helton/power-tuning-your-serverless-api-for-happy-customers). Now that it works and adheres to your best practices, it's time to make it shine.

This phase isn't so much about the implementation itself. **It's about making it easily maintainable for others.**

Your objective as a software engineer should always be to [work yourself out of a job](https://www.readysetcloud.io/blog/allen.helton/how-to-work-yourself-out-of-your-tech-job). Don't build software in a way that *you* are the only person that knows how to fix it. You'll never move on to bigger and better things.

Instead, add things like [proactive monitoring](https://www.readysetcloud.io/blog/allen.helton/how-to-monitor-your-serverless-application) and [automated performance testing](https://www.readysetcloud.io/blog/allen.helton/dynamically-monitoring-api-performance) so others can keep an eye on what you built and make sure it continues to operate at a high level.

*Doing it better* is all about optimization. Optimize the performance of your app. Optimize the business process. Optimize the support. **Make it better**. 

You have high-quality, working production software already. Make it faster. Give your customers the opportunity to say "wow, they just keep making this app better and better!"

Once you reach this phase, you never leave. Software is never done. You will be modifying and enhancing it until the product retires. So get comfortable, you'll be here a while.

## Conclusion
Go into your next major project with the three phase approach on your mind. Get to the market as fast as you can to gather feedback on building the right thing.

Then build it in a way that is reliable, scalable, and fits with your company's best practices. 

Once you have a strong new feature or product, continuously improve it with things like performance boosts, automated tests, and any other bells and whistles you can think of. 

Software doesn't have to be perfect the first time. But it does need to satisfy the business problem. As long as you do that, you have potentially shippable software.

Keep [delighting your customers](https://www.readysetcloud.io/blog/allen.helton/design-to-delight-raising-the-bar-on-software-design-a1eec234188b). Continuously enhancing the experience will develop strong relationships that will keep them customers for life. 

Good luck out there, and remember to keep iterating!