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, so they can provide feedback and the team can continuously iterate towards the desired solution.
Empathizing with your end users over time engages you in a continuous dialog with them to provide solutions. Fundamental needs might not change, but how we address them does. Iterating and prototyping from empathy lets us connect and evolve with our users.
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?
Many believe that prototypes serve a temporary purpose and are ultimately meant to be replaced by something better. As part of the design thinking process, you are driven towards action: to create, to test, and to refine solutions that best meet your end users’ needs. View everything as a prototype. If testing proves an approach to be unsuccessful, don’t be afraid of trying something else. Speed is crucial so that minimal time and money is spent on an unsuccessful solution. Rapid prototyping advocates for the creation mockups that can validated—and if needed discarded—quickly as you build towards delivered software. 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 platformbrings 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, it’s main focus is on the design thinking principleof 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.
Written for the Mendix Blog