In 2009, Tim Brown published his now famous book “Change by Design”. His idea: Design strategies and techniques can be used at every level of business. In 2018, Design Thinking has become a methodology and is used for innovative activities by project teams around the world.
We explore: How can design thinking help you when you are building new products? What strategies can you use? And how can you integrate Design Thinking into agile software development?
What is design thinking?
Design thinking is about taking skills and strategies out of the design world into other areas of the business world. Brown writes:
“Design thinking takes the next step, which is to put these tools into the hands of people who may have never thought of themselves as designers and apply them to a vastly greater range of problems.”
According to Brown, Design Thinking consists of “overlapping spaces, rather than a sequence of orderly steps.” These spaces are – as outlined by Brown:
“Inspiration: the problem or opportunity that motivates the search for solutions
Ideation: the process of generating, developing, and testing ideas, and
Implementation: the path that leads from the project room to the market”
In a paper titled “Design Thinking: A Fruitful Concept for IT Development”, Thomas Lindberg et. al write about how designers find solutions that are closer to everyday life by thinking for example about what “a backache reducing office chair” should look like. Design Thinking, however, refers outside of its own discipline and is looking to “taking on a general role of coordinating disciplines, stakeholders, and the manifold environmental matters within product development processes.”
Agile vs. Design Thinking
Software development is an area that is driving innovation for many different aspects of our lives. Agile methodologies and scrum processes have changed how teams work together and have enabled faster decisions, quicker releases, and early prototyping and testing. This has been necessary to operate in a market where 1) ressources are expensive and 2) conditions are changing rapidly.
If you compare agile methodologies with Design Thinking, you might think that the latter one is already present in software development processes.
Regarding parallels between these two, Lindberg names “user-centricity”, “iterative learning and development processes” and “extensive team communication” to underscore strong similarities.
However, he also sees crucial differences between the two: The focal point of design thinking, according to Lindberg, is to put divergent options on the table and prototype. Iterative prototyping is at the core of design thinking. Agile, on the other hands, focuses on the question on what to do next.
How to use Design Thinking for software development projects?
With obvious differences being present between Agile and Design Thinking, Lindberg also introduces new solutions on how to actually introduce Design Thinking into software development.
Important for his approach are three key aspects that he sees as the foundation of Design Thinking. They are:
- exploring the problem space: What problem does the user have? What is the broader context? What is the collaborative understanding of the situation?
- exploring the solution space: What are creative solutions to the problem?
- and the iterative alignment of both spaces: Iteration is what Agile and Design Thinking have in common, but iteration is used to a far greater extent in Design Thinking.
How can teams work on integrating these approaches into their workflows?
Lindberg et al. see a solution in introducing Design Principles as a precursor to the actual agile development process. He writes:
“a company pursuing an agile approach can start with design thinking-inspired concept development before beginning the actual agile development process.”
However, he sees one important conflict between Design Thinking and agile dev processes that is illustrated in different understandings of the role of a “prototype”:
“Design thinking prototypes have the main purpose of supporting learning about the underlying product concept. In contrast, software prototypes are generally made of the same material as the final product, and are – in the case of agile – continuously iterated into the final product.”
The prototypes of Design Thinking are intended as learning possibilities: the idea is to find a solution without running into the wrong direction for a long time, but the prototype isn’t necessarily related to the final product.
The 5 steps of the Stanford Design School
The Hassno Platner Institute of Design has outlined five steps of Design Thinking that can be applied to software development as well. They are:
Empathize: At the core of Design Thinking is empathy. This step is about understanding the customer, empathizing with their problem, watching, listening, and observing what they are struggling with. For software development this means truly understanding the problem before starting to work on the solution. This can happen, for example, in interviews with potential customers.
Define: Defining the problem is the next step. The idea is that framing is crucial when you are looking to find the right solution. How can you frame a user problem? Who are you actually designing for? Who is your user?
Ideate: The ideating stage is about generating the broadest range of possibilities. Ideation techniques are brainstorming, sketching, mindmapping, but also prototyping in order to learn and explore more about the problem and the context.
Prototype: In Design Thinking you can be building several prototypes at once that help you understand the user better. The idea is not to spend too much time on each prototype, but explore a variety of options.
Test: The last step is the testing stage. You are testing your prototypes with users and are getting feedback on them. Key here is to listen and watch as users are exploring your prototypes.
Wrapping it up.
Design Thinking is a popular concept that is used to generate creative ideas and solutions. In a time, in which every company is becoming a software company, Design Thinking can help to give dev teams a new perspective on understanding the problem and finding a solution and can be integrated into software development as a precursor to actual software development. Design Thinking raises interesting questions and introduces diversity, creative exploration, and problem solutions.