Design Thinking Approach: Think Twice Before Building Throwaway Prototypes
Prototyping is one of the core principles of the design thinking process. It doesn’t matter how deep an understanding of an app’s intended users your team has developed in the empathy stage; most of their initial ideas for the interface, interactions, capabilities and overall user experience will miss the mark. Prototypes serve to test those ideas by giving end users and business stakeholders something tangible to react to. It’s an important step in engaging the business in continuous dialog, so they can provide feedback and the team can continuously iterate towards the desired solution.
As Alan Cooper, the father of Visual Basic and a pioneer in the field of interaction design, once said, “The value of a prototype is in the education it gives you, not in the code itself.” Through the process of making prototypes, the team is able to think deeply, ask questions, and begin to uncover the true requirements for the solution—in a way that creating abstract specification documents could never replicate.
Should all prototypes be thrown away?
That’s why many believe that prototypes serve a temporary purpose and are ultimately meant to be replaced by something better. Practices like throwaway prototyping or rapid prototyping advocate for the creation of a mockup that’s eventually discarded rather than becoming part of the final delivered software. Speed is crucial so that minimal time and money is spent on the throwaway prototype. The idea is that it’s better to focus on validating concepts and refining requirements early on, rather than investing in building software that will change significantly.
But what if you could have the best of both worlds: the ability to rapidly create a prototype to collect feedback from users, and the ability to continue refining it and have it ultimately become the production application? You’d still get the benefit of learning through prototyping, having spent minimal time and money in the process. On top of that, the time to value for the final solution would be accelerated, because you wouldn’t need to throw the prototype away and start from scratch.
Take apps from prototype to production using low-code platforms
This is the power a low-code development platform brings to the design thinking approach. Low-code platforms employ visual, WYSIWYG development techniques that are ideal for enabling small, cross-functional teams, and even individuals, to iteratively design and build applications.
In the context of design thinking, developers and even business domain experts can leverage a low-code platform to quickly construct functional prototypes for validation with users. Pulling from a variety of reusable templates, functional components, and professionally designed UI elements, they can assemble screens, and begin building the application’s logic and underlying data model, without needing to create everything from scratch. Once it’s ready for feedback, the prototype can be shared with a single click and previewed instantly across web, mobile, and tablet devices. Users can provide feedback via an embedded feedback widget, and a closed loop brings this feedback directly into the development environment, facilitating rapid iteration.
Using a low-code platform, it is certainly possible to create throwaway mockups with the same speed and ease you would experience using common prototyping tools. In fact, as noted above, many prototypes will simply miss the mark based on feedback from users. These can be discarded without a major investment of time and money, and the team can move on to the next one.
But a prototype that does resonate with users can be carried forward, forming the basis of the actual finished application. The team can extend it with complex logic, integrate it with other systems, define a fine-grained security model, and more. They can leverage built-in agile project management tools to iteratively develop the solution, continuing to solicit and adapt based on user feedback. Lastly, a cloud-native architecture with out-of-the-box high availability and failover ensures that the application can be deployed at scale.
Enabled by these capabilities, some organizations like ADP eschew prototypes altogether and build working software that they put into users’ hands as quickly as possible. While ADP’s product incubator practices design thinking, its main focus is on the design thinking principle of empathy. Once the team develops a deep understanding of an app’s intended users, they use Mendix’s low-code platform to quickly build a working application that they test with real users and iterate based on their feedback. One app, Compass, was so successful that after rolling it out to 50,000 employees worldwide, ADP recently commercialized it for customers.
Marry rapid prototyping with the ability to develop and deploy enterprise-grade apps
While prototyping tools will always have a place, particularly for low and medium fidelity wireframes, a low-code platform is an ideal solution to organizations looking to marry the benefits of prototyping with the need for accelerated delivery timeframes. In the context of a design thinking approach, such platforms enable teams to quickly construct fully functional prototypes for validation with users, with built-in feedback mechanisms to capture input on app designs. Because these prototypes can evolve all the way to robust production apps, time to value is reduced significantly because you don’t have to throw the prototype away and start building the production app from scratch.
For more on how low-code platforms support prototyping and the broader design thinking approach, download our new executive brief