I love making software.

Correction: I love making great software. And the difference between the two is remarkable. The software you carry in your pocket is nothing short of amazing. You can make calls, check the weather, or buy anything you want on the internet—and that’s just a small fraction of everything a smartphone can do. But in the end, it’s all software that drives that experience.

Software is like a story. It takes you on a journey through various pages and interactions until you reach your goal. And the difference between ordinary software and great software is that with great software the journey is frictionless. Your eyes are presented with visuals and your brain will immediately know how to engage and proceed. It’s effortless. Repeated, its adoption happens unconsciously as it becomes second nature. Great software shapes your behavior, and in a way, becomes a part of who you are!

As a software engineer (which is a self-serving synonym for “designer,” “programmer,” or “developer”) making software is the job. We build products both with our minds and our hands. We focus deeply on technical issues but are constantly stepping back to assess the bigger picture. We work in isolation on the difficult and proudly tell our peers how we overcame those difficulties to elevate them. We are a collective of nerds moving mountains with our minds.

I’ll admit that might be a bit of an exaggeration, but in the world of software, anything is possible. And in all those possibilities are endless ways to solve problems. That’s the mindset of a software developer. Our layer starts in the conceptual and ends in the actual. The defining trait of an engineer is that we start the conversion with “What is the goal?” and end the conversation with “How does this look?”

But that’s not what motivates me to look at code 8 hours a day, 261 calendar days per year (Thanks, Google, for that stat). What motivates me is the thought of crafting a software experience so darn good you don’t even know it makes your life better. And being around people that have the same drive certainly helps too.

Take a peek behind the scenes

So how is great software made? And more to the point, what are the fundamental aspects or special ingredients in making that software outstanding? With an abundance of mobile apps and web experiences we use on a daily basis, the process of developing extraordinary software in those spaces should be well documented, even formulaic, like other media. Great music generally has a narrow range of tempos and length of time (3-4 minutes). Great books and movies often rely on the “hero’s journey” to describe the clichéd story arch. So why does software development not fit a mold too?

It’s a process. It takes iteration. Design, evaluate, revise, and hopefully move forward. Sometimes you’ll fail and go back to the drawing board. And that’s not figurative. We developers have literal whiteboards we go back to!

The best analogy to describe the process of making great software is the way that cars are made. The process of making the vehicle you and your loved ones rely on began with an idea. It likely started on paper by concept artists, was designed in 3D modeling software, and was eventually sculpted using actual clay to be focus tested in the real world. This is known as the concepting phase of development.

From there, various designers and engineers (structural, material, mechanical, and yes, software) get involved to turn the concept of that car into something tangible. This is the engineering phase. It is in this phase that the idea becomes real. It’s the designers and engineers at this phase of development that should be credited with making your car, in my opinion. These are the minds that make it possible—not the salesperson that sold it, the marketing team that hyped it, or the executives that took credit for it. Your vehicle was made by these impassioned and analytical thinkers.

But I’ve still not answered the question of how great software is made. Stay with me, it will be worth it.

Like the automotive industry, software development has an engineering phase and similarly uses the same construct to drive and focus that process. And like the title alludes to, this crucial piece of the puzzle is known as the prototype.

So what is a prototype?

In the software development lifecycle, the prototype is the best-looking, most bug-free, up-to-date version of the software solution. It is ever-changing. It defines the events and behaviors of all the interface elements. The prototype mirrors the final solution in almost every aspect.

The single difference is that the prototype uses mock data to drive that experience as opposed to using live data. What this means is that the prototype will use fake accounts with fake balances where the final product will use real accounts and show real balances. Everything else is purposefully the same.

There are many reasons why the concept of a prototype is so powerful. The first is that it solidifies the development process itself. The prototype defines the look and feel of what the product will become. It is a blueprint to build toward and it communicates the goals across all teams and to all team members.

Next, the prototype itemizes the work into discreet parts and is used to scope the size of the project. It organizes the process so that it can be carried out efficiently like an assembly line. Additionally, it makes the development process measurable to know where the development currently is and better gauge when it will be completed.

Another important aspect of the prototype is that it makes the solution testable. For modern web products, you will need to test your solution on Chrome, Edge, Firefox, and Safari. Note that I left out Internet Explorer and that is on purpose! Even Microsoft has let it go and we should too.

How about Mac vs PC? Tablet or mobile? Will it work on your Apple products the same way it will work on Android? Is there any difference from iOS 14 down to version 10?

There are so many platforms and devices that exist today. How about the devices of tomorrow? Having a defined prototype means that your software is testable across the full spectrum of devices in the present as well as the future.

The gains are not just at the engineering level either. There are several benefits at a high level too. Having the prototype completed allows for the entire solution to be evaluated and test-driven. It allows important questions to be answered like “does the software accomplish the goal?,” “what is the user experience?,” “does it look professional?,” and more. These questions are at the heart of any high-quality software solution.

Moreover, the prototype allows for other teams to engage the rollout earlier in the development lifecycle. For example, the writing team can evaluate the prototype for typos and product descriptions. The marketing team can make videos and take screenshots for their campaigns. Even credit unions are given early access to the product to better test the software prior to full release. Having a prototype means that other teams are engaged much earlier in the software schedule and therefore the entire development process from start to finish is that much faster.

A blueprint for success 

And amazingly the benefits continue. As developers, we have found that over the lifecycle of software if you keep your prototype in sync with your live version several remarkable things happen.

The most obvious is that the prototype serves as a template and makes future enhancements that much easier. But what is not obvious is that it also aids in the maintenance as the software landscape changes. Bugs happen and that is a fact of software life! It could be a hidden bug that is finally uncovered. Perhaps the way the software is used changes from the way it was originally designed for.

More commonly new devices or parent software are updated resulting in unexpected issues. Android and iOS operating system versions are in the double digits. Chrome updates almost monthly. The point is that bugs come up often and for various reasons, but having a prototype to fall back to makes resolving those issues that much easier.

Having the prototype in sync with the production version means that almost any issue can be reproduced, debugged, and resolved, all in the prototype. For example, issues with the look and feel can generally be fixed with a styles.css update. Behavior issues can generally be resolved in one of several Javascript files. And because the prototype uses mock data, not only can we manipulate that data to resolve existing issues, but we can also evaluate future conditions. We can answer things like, “what would the interface look like on desktop if we added a running balance to account details?” or see how excessively long vendor names will display on mobile.

There are so many benefits of a prototype that it is hard to think that great software could ever be made without it. It not only improves the development cycle at the engineering level but also assists other departments in the product rollout. It transforms a process that is traditionally unorganized into an efficient assembly line. Even after deployment, the prototype is utilized to maintain and strengthen the software product over its lifetime. It is the modern construct by which great software is made. Simply put, the prototype provides a blueprint for success.