Design thinking is quickly entering the vocabulary of IT leaders. Just a few years ago,
the approach was largely confined to industrial design and product design circles. However, enterprises looking to differentiate themselves through custom software development are realising they must focus intently on user experience. Design thinking helps ensure applications provide the right user experience—and thus, the intended benefits—by fostering an iterative, user-centric approach across the entire application lifecycle.
There are a number of aspects to taking a design thinking approach to application development including being empathetic to your users, defining insights, ideation, prototyping and evaluation. In this article I’ll do a deep-dive into the concept of prototyping.
Prototyping is a key component of the design thinking process. The first phase of an application development process is to put yourself in your end-users’ shoes. Gather information about intended users and their needs through interviews and shadowing. Define the requirement and develop a functional protype to bring ideas to life and review with users, before embarking on the actual development. Prototypes serve to test ideas by giving end users and business stakeholders something tangible to react to. It’s likely that via prototyping you’ll discover that some initial concepts miss the mark. It’s important to engage the business in continuous dialog and encourage feedback so that the development team can continuously iterate towards the desired solution.
Global design consulting firm, IDEO has a saying, “If a picture is worth a thousand words, a prototype is worth a thousand meetings!” Through the process of making prototypes, a development 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.
Prototypes don’t need to be thrown away
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. Developing the prototype quickly is important to minimise the time and money 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.
Low-code application development platforms progress prototyping through to production
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; progressing them through prototyping and onwards into production.
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.
There are many large organisations that pursue an iterative approach to development. ADP, a payroll technology provider is a good example. The company’s product incubator embraces design thinking, especially the principle of empathy.. Once the team develops a deep understanding of an app’s intended users, they use a low-code platform to quickly build a working application that they test with real users and iterate based on their feedback. One recent app, Compass, was so successful that after rolling it out to 50,000 employees worldwide, ADP commercialised it, selling it externally.
Combine rapid prototyping with the ability to develop and deploy enterprise-grade apps
While prototyping tools will always have a place, particularly for wireframes, a low-code platform is an ideal solution for organisations looking to bring together the benefits of prototyping with the need for accelerated delivery timeframes. In the context of a design thinking approach, low-code platforms enable teams to quickly construct functional prototypes for validation with users. 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.
