Design thinking meets agile development in Design Factory Project

Design thinking and agile development are two methodologies that have gained popularity in recent years. While design thinking focuses on understanding and solving complex problems from a human-centered perspective, agile development emphasizes flexibility, collaboration, and iterative development. When these two approaches are combined, the result is a powerful framework for creating innovative and effective solutions to complex challenges. This article introduces the framework combining these two approaches in Design Factory Project course during the year 2022 and proposes some further improvements for the next course implementation.

Design thinking and agile development

Design thinking is a human-centered approach to problem-solving that puts people at the center of the design process. According to Brown (2008), design thinking is “a discipline that uses the designer’s sensibility and methods to match people’s needs with what is technologically feasible and what a viable business strategy can convert into customer value and market opportunity.” The design thinking process typically consists of five stages: empathize, define, ideate, prototype, and test (Jussila et al., 2022). During the empathize stage, designers seek to understand the people they are designing for, including their needs, goals, and challenges. In the define stage, designers synthesize their research and insights to identify the core problem they are trying to solve. In the ideate stage, designers generate a wide range of possible solutions to the problem. In the prototype stage, designers create low-fidelity prototypes of their solutions to test with users. Finally, in the test stage, designers gather feedback from users to refine their solutions.

Agile development, on the other hand, is a methodology for software development that emphasizes flexibility, collaboration, and iterative development. According to the Manifesto for Agile Software Development (Beck et al., 2001), agile development values “individuals and interactions, working software, customer collaboration, and responding to change.” Agile development consists of several practices, including iterative development, continuous integration, and test-driven development. In iterative development, the software is developed in small, incremental cycles, with each cycle delivering a working version of the software.

Design thinking and agile development share several key principles. Both approaches emphasize collaboration, iteration, and feedback. They both prioritize the end user and seek to create solutions that meet their needs. And they both value flexibility and adaptability, recognizing that the best solutions may emerge through an iterative process of experimentation and refinement.

Design thinking and agile development in Design Factory Project

Design Factory Project that combined design thinking and agile development was first run in 2022. The aims of the project were to learn skills needed in world of work while also producing useful solutions for the companies participating in the project. The learning objectives for the students included that after completing the project, the student is able to:

• work on practical IT-related development projects
• communicate in customer projects and apply software testing in practice
• design user interfaces based on customer requirements/preferences
• apply principles of design thinking in practice.

Applying principles of design thinking begins with understanding the motivation of design thinking. The motivation for design thinking is the need to create ideas and find solutions, which are as desirable, feasible, viable and sustainable as possible for certain groups of users (Lindberg et al., 2011; Lahdenperä et al., 2022). The design intends to offer a very concrete solution to a complex problem that is typically ambiguous and not easy to comprehend (Lindberg et al., 2011).

When working on IT development projects, the customers are often not IT experts themselves and hence are not skilled in describing software requirements. Furthermore, the customers may not have clear preferences about the software and knowledge of existing or similar solutions in the market. People in design have developed problem-solving skills that allow them to deal with such kinds of problems successfully (Lindberg et al., 2011). These skills are often not taught in curricula of the established sciences, such as computer science. In the Design Factory Project at Häme University of Applied Sciences (HAMK) the aim is to develop problem exploration and problem-solving skills while working on a practical IT development project applying agile development methodology (Figure 1).

The project starts with an emphasis on design thinking, understanding the customers’ needs, goals, challenges, and the core problem to be solved. The project team ideates a solution to the core problem, develops a prototype and tests the prototype with the customer.

The design thinking process is followed by three agile software development sprints (in the figure sprints 1–3) each lasting two weeks, where the software is iteratively developed. As we use the scrum method each software development sprint ends with a sprint review, where the team presents their work to stakeholders and receives feedback (Schwaber & Sutherland, 2011). In each sprint, requirements and features are analyzed, planned, designed, and potentially shippable product increment is built. Launching a piece or set of working software that is made available to users in a live or production environment is a goal, but it is not a requirement of the scrum method that every product increment produced by a sprint is released. Scrum is a term that originates from rugby, where it refers to a method of restarting play that involves players packing closely together. It was first used in the product development context by Takeuchi & Nonaka (1986) in their seminal article titled ‘The New New Product Development Game’, see Figure 2. It was later picked up by Schwaber (1997) who named a new agile development method as scrum.

Type C represents scrum in Figure 2, which illustrates highly overlapping phases of product development. In software development, it is natural to have overlaps in the phases as each phase builds on the existing design and code of earlier phases (Schwaber, 1997). In practice, this means also that even in the very end there might be a need to revise code that was written in the very beginning.

When design thinking met agile development

Moving from theory to practice is always not that easy. In the first Design Factory Project implementation not all the students understood the role of design thinking in software development.  Perhaps, some students simply understood design thinking as a way to collect user requirements for software development. However, design thinking goes beyond ascertaining, describing, and documenting user requirements. The empathize phase of design thinking especially focuses on understanding user needs, goals and the context of the software that is going to be used. Taking a design perspective to software development means that you develop a solution to a problem that is worth solving from the user’s perspective (cf. Lindberg et al., 2011).

The solution should be desirable for the user, for example, in a way that it makes the user’s and not necessarily the software developers’ life easier. When this motivation and aim of design thinking is not fully understood, the software development projects can lead to results that are satisfying from the software developer’s perspective but do not meet the needs or goals of the user. This was the case in some of the student projects.

In the course assessment criteria, it was outlined that students develop a prototype that addresses the feasibility, desirability, viability, and sustainability of the software. The feasibility and (economic) viability dimensions were relatively well addressed by the student teams in the first implementation. Desirability was challenging for some students’ teams, whereas some teams were able to deliver prototypes that exceeded users’ expectations. The sustainability of software proved to be the most challenging for the student teams. This may be due to the lack of theoretical understanding of software sustainability and perhaps also because sustainability has not received much attention in the software industry in general (Noman et al., 2022). This will be addressed for the next Design Factory Project implementation by introducing the students to a framework for sustainable software development presented in the next chapter.

Towards sustainable software development

According to Penzenstadler & Femmer (2013) achieving sustainable software development is a challenge that must consider five distinct dimensions: environmental sustainability, social sustainability, economic sustainability, technical sustainability, and individual sustainability. Paech et al. (2019) have developed a checklist for needs for each dimension they consider useful to have at hand when developing an IT system:

1. Environmental:
   • Positive influence on climate change
   • Reduce resource consumption
   • Reduce waste
2. Social:
   • Good trust and communication between people
   • Good social indicators: e.g. employment (full-time work, women’s employment, working time arrangements, job opportunities, etc.)
3. Economical:
   • Little cost
   • High revenue
   • High customer satisfaction
4. Technical:
   • Easy maintenance of the system
   • Easy evolution of the system
   • Easy resilience
5. Individual (such as users of the system):
   • High trust in the system (e.g., safety and privacy)
   • Equal access to the system by users
   • Fair treatment of users by the system

This checklist is not exhaustive but gives an indication of sustainability needs that can be addressed in software development. While all the items may not be relevant for every project, they give an indication of what can be covered in empathizing with the users of the software and ideating the solution. Penzenstadler & Femmer (2013) and Paech et al. (2019) are included as recommended reading for the students for future course implementations and also for the industry. To give a practical example, most companies are very interested in the economic sustainability of the software. They desire the software to e.g., generate more sales, increase revenue, improve profitability, or reduce costs of the company.

Many companies perceive that software is not valuable for them if it is not economically sustainable. The importance of environmental sustainability is also increasing in importance inside companies and in the public debate. Expanding the concept of the “bottom line” used in business to refer to profit, the triple bottom line measures the performance of business success using three “lines”: economic, social and environmental (Souri et al., 2022). Environmental needs can be addressed in software development by creating solutions that have a positive impact on climate change, reduce resource consumption and reduce waste. In the first Design Factory Project implementation there were two software development challenges that explicitly included the environmental sustainability dimension, however, in both cases environmental sustainability was rather superficially addressed by students and the focus was more on delivering working software – technical dimension of sustainability or feasibility in design thinking terminology.

One reason why working software, technical sustainability and feasibility of the solution were emphasized over other sustainability dimensions in the Design Factory Project was the limited time of the software development project. Delivering working software that is technically sustainable is by itself a challenging task to accomplish in an eight-week long course that includes only three two-week long sprints, where the software is actually developed. Another reason may be that terminology of design thinking and agile development is somewhat overlapping, but on the other hand, also guide in different directions. For instance, from the design dimensions of feasibility, desirability, viability and sustainability in design thinking, only feasibility is clearly pointed out in the Manifesto for Agile Software Development (Beck et al., 2001) as ‘working software over comprehensive documentation’. Considering the challenges in combining design thinking and agile development and the recent developments in sustainable software development there is a need to refresh the original Agile Manifesto accordingly. Hence, we propose a new manifesto for Sustainable Agile Software Development.

We are uncovering better ways of developing sustainable software by doing it. Through this work we have come to value:

• sustainability over exploitation of humans, society and the environment
• empathizing user needs and goals over developers’ personal needs and goals
• working software over comprehensive documentation
• individuals and interactions over processes and tools
• customer collaboration over contract negotiation
• adapting to change over following a plan
• that is, we value items on the left more with the steering principle that sustainable software development is preferred over exploitation of others.

Looking forward to future Design Factory Project implementations

Armed with a better theoretical and conceptual understanding of sustainable software development and the connections between design thinking and agile development, we look forward to future Design Factory Project implementations. With the introduction of a new manifesto for Sustainable Agile Software Development, we imagine we can better communicate the combined design thinking and agile development framework for our students and the companies participating in the projects.

For the developers, there are two areas of sustainability to be considered: the production and the use of the developed systems. Production sustainability involves the constant production of software features over time (S.A.S.U In Imago, n.d.). In the Design Factory Projects, the backlog items serve this purpose. Although the development includes only three sprints, the students try to divide the features evenly into the sprints. In this way, the production time is efficiently used during the project. This also should make the work of developers more predictable.

At the beginning of the Design Factory Project, the students need to select a development framework for their project. The framework should give them enough support for the relatively short project. They may select a framework from the first-year studies (they are second-year students now) or pick a framework that the supervisors recommend. In the latter case, they need to add learning as an issue in the product backlog, meaning that they have less development time in this case. On the other hand, they will learn a new system.

During the software development, the students need to understand the clients and their processes. Sometimes the clients have an idea of the system but with a bit more investigation there can emerge more needs for development.

Reviews and retrospectives are an important part of the development process. The reviews are done together with the client and/or the product owner. These are important events for the students’ learning. They get to know what the client thinks of their work and how should this work continue. Since the sprints are only two weeks long, they probably have not done many things that are not aligned with the client’s needs. Part of the idea of production sustainability is to avoid developing extra features (cf. Poppendieck, 2011) that are not required by the client and adapting the development based on client feedback. Also, by interacting with the client, the students learn how to make short and efficient presentations.

In the retrospectives, the students concentrate on their working methods. One of them is efficiency which is directly related to sustainability. How have they succeeded and how should they continue? In the retrospective development enhancements are discussed and decided. The decisions must be such that everyone can live with them.

By educating the future experts in the world of work, we aim to make a positive influence on climate change and in creating a more sustainable future for the present and future generations. Creating a more sustainable future begins with a better understanding of sustainability dimensions (cf. Paech et al., 2019) of software development and then making concrete actions that advance towards better environmental, social, economic, technical, and individual sustainability. By marrying design thinking with agile development, we can better address users’ goals and needs, and develop software prototypes that are desirable, feasible, viable and sustainable from the user’s perspective. We hope that the ideas proposed about Sustainable Agile Software Development can also benefit the software industry and software professionals that are implementing sustainable development practices in their organizations.