Iterate Your Way to Perfect Software

Some software developers think poorly. They say things like this:

“You’re supposed to have it all figured out before you start.”

“To save yourself from a huge, career-ending failure, you’ve got to make sure your next software development project does not fail. And that means careful, meticulous, future-proofed software planning.”

“You must predict every outcome and pitfall. Your next software development project must work perfectly right out of the box, because the consequences…well, they don’t bear thinking of.”

There’s a better way.

Control Comes From Fear

Fear is not conducive to true creativity or even productivity, but it is understandable.

Our response to fear is control. We fear that our projects might bog down and collapse if we don’t keep full control over our software development process, so we micromanage. We nitpick. We plan for every contingency.

It’s a broken and unworkable approach from the beginning. A good battle plan is key. Flexibility and responsive decision making keep us driving to other objectives.

Software development failure is often not because of poor planning or lack of diligence. It springs from…

  • Believing that more design time leads to better solutions.
  • Being too rigid.
  • Not getting centered over the problem.
  • Not leveraging the info from your target users to iterate toward the best solution.

We think the solution is actually found in iteration – in frequent, small, iterative failures that lead the steady march to victory.

It’s actually better to come to the table without every detail figured out.

Fail Fast and Keep Going

Creating software costs time and money, and can make or break your reputation and productivity.

It’s understandable to worry that your company could suffer if you get this wrong, and if you create a piece of software that misses your target, the damage to your company, budget, and reputation can be unacceptably high.

What’s the best approach? You need to fail more and fail quickly.

But there are iterative “failures” and there are catastrophic FAILURES- the kind you don’t learn from and that cause major damage. The frequent iterations and error messages that provide you with knowledge and actionable insights will save you from the all-caps, expensive failures in the long run. 

Sure, you have to plan and design, but you shouldn’t think you need to have it all figured out before you start.

  • You have to define what real business success looks like.
  • You have to identify the real problems you’re trying to mitigate.
  • You must understand the target risks and rewards.
  • You need to ultimately design the right solution.

The “Fail Fast” philosophy allows you to do all those things with minimal investment and maximum success. Orville and Wilbur Wright knew this.

Unlike many modern designers and engineers, the Wright brothers were self-described tinkerers. They tried to build something that flew. And they failed – hundreds of times. 

Then they went back to the shop, strengthened what worked well, and junked what didn’t. They learned from every iteration.

The result? Sustained, powered, manned flight. Not bad for a couple of bicycle repairmen.

So how can you do this as you craft your next software tool?

Develop a sketch of a solution that’s simple and that mostly works. Then get it in front of the people who know what success looks like and get their feedback. 

What works? What doesn’t? What else would be helpful? Use that knowledge to determine the next iteration.

If your biggest risk is adoption by a specific user group, start with them. Get a quick solution in front of them and get their feedback. Make them part of the solution and target their needs head-on.

Software designed in a vacuum will never stand the test of true and real environmental conditions, so get your solution out there quickly and see if it flies. 

Then iterate.


Capsher applies fail-fast from the beginning to get you the right solution; iterating to secure victories for you in the real world. 

Capsher allies with you to target the risks on the front end. We don’t overdesign before we communicate with you and your end-users to make sure we have all the right intel and knowledge to deliver a successful solution.

Then we iterate to validate.

Our product consultants are well-versed and experienced in locking in on the correct target, defining real-world success parameters, and mitigating risks from the start. Our iterations and small failures are designed to occur often and are manageable and minimal.

Ultimately, being willing to fail fast along the way will mitigate the risk of failing catastrophically at the end. Call Capsher. We’ll team up with you to help you fast-fail your way to a victory; a software solution that really works.