As part of the LeSS trainer application, I was asked to give a graphical representation of LeSS. Here’s the result showing my view of LeSS:
A series of choices
LeSS is a series of choices for large-scale product development. We could make any choice if we are not clear about the optimizing goal. The choices made by LeSS are optimized for agility and adaptiveness. Among others, two choices stand out:
To get the informed consent about adopting LeSS, i.e. making a series of choices, we should explore and see the system dynamics behind those choices. This is why systems thinking is critical in understanding LeSS.
Systems thinking sounds great, thus, it could be claimed to be relevant anywhere. LeSS applies it concretely to evaluate the choices you make. What is the system optimizing goal? What are your choices? What are the causes behind them? What are the consequences? Are they consistent with your system optimizing goal?
I am often asked to compare LeSS with SAFe and other frameworks. I don’t have an answer, but would like to offer an exercise of system modeling on the different choices those frameworks offer. We evaluate those by applying systems thinking.
When a team gets big, we split it into two. How? Typically by dividing into components or sub-components. Why do we split this way? What are the consequences? What are the alternatives? Often, we did not think it through. That is the typical manifestation of fast thinking. However, those choices are so important that they deserve slow thinking. System modeling helps us do slow thinking, and critical thinking.
If you practice systems thinking on your choices, you are free to do experiments that may not be consistent with LeSS. Eventually, you “own” what you do, rather than “rent” ideas from others. Less copying, more learning.
Systems thinking is the cornerstone (i.e. the fifth discipline) for a learning organization. LeSS opens up the stairway to a learning organization in the field of product development. By experimenting and practicing the five disciplines, we move toward the learning organization, while LeSS is a starting point in the journey.
This is my view of LeSS.
P.S. I had to ask my daughter for help in doing this graphical representation. I noticed a small detail afterwards. There are two paths to the house representing the learning organization. One is through the back door, which is the shorter route; the other is through the front door, which is the longer route. They happen to be a good representation of fast thinking and slow thinking.
In this article, we shall investigate why the learning and development of multi-functional specialists in Scrum is the core of organizational Agility and value optimization. Many Development Teams are not collaborating as real teams, but as a collection of narrow specialists focused on “their” tasks (QA, Backend, iOS, Android, etc). This leads to an ever-increasing number of explicit and implicit backlogs, “dependencies”, more Work-In-Progress (WIP), queues, and unsatisfactory lead times. How does it affect organizational Agility and what to do about it?
Making People Busy is Not the Goal
Recently I observed a few teams in a large service company during an extended enterprise Go See effort. I attended various Scrum Events, followed teams collaborating daily, noticed how they dealt with conflicts, and much more. We have done it for a very sound reason - to uncover the underlying system structures and come up with deep interventions. What immediately caught my attention was the focus on resource utilization during Sprint Planning. Some of the phrases that caught my attention:
“Do we have enough work for the designer in this Sprint?”
“Seems like testers are already filled up with work.”
“Can we pull another item for our iOS developer to make her busy?”
The fundamental issue in complex environments is that work is never distributed evenly for a cross-functional team in a Sprint. Over the years, my observation has been that many teams do not respect the order of the Product Backlog because it means facing a painful skill gap.
Respecting the Product Backlog order means facing a skill gap!
When the Scrum Team keeps the goal of making people busy, it has multiple implicit backlogs, not one. The typical phrase that you can hear is, “I will do this feature because I am familiar with X technology.” The Product Owner is forced to change the order of the Product Backlog to make people busy in Sprint. Thus, the team doesn’t work on the most critical features from a customer perspective and sub-optimizes the value delivery. Let’s take a look at this from a Systems Thinking perspective (see Figure 1).
We obtained the first balancing loop “B1: Making people busy”. The more perceived skill gap to develop the most critical features from a customer’s perspective, the more team stress, the more pressure to increase the number of implicit backlogs (“these are my features, those are yours”). That makes developers locally efficient at the cost of sub-optimizing the whole.
Developers are efficient at the cost of sub-optimizing the whole!
Pay attention to the mental models:
“I don’t know this stuff. I’m not a ‘XXX’ developer.”
“It’s the best and most efficient when everyone is busy and doing ‘his/her work’”
This dynamic doesn’t happen at a single team level only. When the knowledge gap becomes really large, then new teams with separate backlogs emerge. Let’s investigate this dynamic further.
More Backlogs Implies More Work-In-Progress (WIP)
One company of a friend of mine started as a small startup a few years ago. Five people were sitting in the same room, working on one product. They worked as a real Scrum Team swarming all day long. They were nimble and agile in those days. Everyone was engaged in the most crucial work, regardless of the primary specialization. What happened after several years? As the company grew, the number of backlogs increased dramatically. They ended up with 13 “Product Backlogs”: iOS Backlog, Android Backlog, UI/UX backlog, and many more. Homogeneous teams were composed of narrow specialists that worked very efficiently from their perspective. The average Work-In-Progress (WIP) of the whole system increased significantly because developers were focused on starting and finishing their own work in their local backlogs. This amplified the lead time and caused organizational stress. The product organization wasn’t able to deliver value to the market early. Management reacted to this stress in a predictable way; they asked people to work harder. This led to even more backlogs, more Work-In-Progress (WIP), and more organizational stress. The above mentioned dynamic is shown in Figure 2:
Pay attention to the mental model:
“People don’t work hard enough.”
The system diagram illustrates how focusing on making people busy impacts the speed of delivering value early in the long-term. More backlogs also mean more dependencies which also impacts value delivery. Let’s investigate this in the next section.
More Backlogs Implies Dependencies and Reduced Value
When an organization introduces more backlogs, the teams become less cross-functional. This inevitably leads to dependencies (shown in Figure 3).
The organization starts managing dependencies instead of eliminating them. The more dependencies, the smaller the probability that an end-to-end customer-centric feature will be “Done” in a Sprint. Dependencies affect the lead time, which in turn introduces a new form of organizational stress. Furthermore, teams working from multiple backlogs do not even realize that they are not working on the most critical pieces from a customer’s perspective.
Multiple teams working from multiple backlogs do not realize that they are not working on the most critical pieces from a customer’s perspective!
Why? Let me illustrate this concept with a short story. In 2019 I started working with a product group that was developing a complex banking solution. When I joined them, they already had three cross-functional feature teams working from three separate backlogs. I asked the “Product Owners” and the “Chief Product Owner” to create a single Product Backlog instead. You can see the result below:
It was not evident that work was not distributed evenly until they examined it in one queue. The colors of the stickies represent different parts of the product from the customer’s perspective. Having three backlogs meant that teams were sub-optimizing the whole while working on less critical features. If we look at the resulting system diagram, we can see three reinforcing loops R2, R3, R4 that create a “Fixes That Backfire” archetype with B1 (shown in Figure 5):
The central theme of the pattern “Fixes That Backfire” is that people make a reasonable attempt to remedy an unwanted situation. Still, after the ‘fix’, the problem comes back – sometimes in a different form – often more prominently than before. Doing more of the same actions just worsens the situation. More backlogs lead to bigger problem, longer lead time, and more organizational stress.
Now let’s see how to redesign the system to optimize value delivery instead of making people busy.
Optimizing Value Implies One Backlog and Multi-Functional Learning
As I mentioned before, the fundamental problem in a complex environment is uneven distribution of work.
Scrum (n): A framework within which people can address complex adaptive problems, while productively and creatively delivering products of the highest possible value. – The Scrum Guide
You can consider optimizing value strategy in the context of two steps:
Create a single customer-centric Product Backlog that reflects the most important features from the customer’s perspective. Of course, those features are our speculations of what we think is the most valuable.
Ask the team(s) to respect, in general, the order of the customer-centric Product Backlog.
Unfortunately, working from a single queue of requirements creates a painful gap in knowledge. The bigger the skill gap, the bigger the need for developers to help others to acquire new skills. But this strategy pays off after some time and leads to the development of multi-functional specialists and Agility. Look at Figure 6:
Pay attention to the mental models:
“We need to respect the order of the Product Backlog.”
“People may learn and acquire new skills over time’”
“Agility requires multilearning.”
The essence of Scrum is a small team of people. The individual team is highly flexible and adaptive. – The Scrum Guide
Frankly, there is nothing new in the concept of multi-functional specialists and cross-functional learning. The origins of Scrum can be found in “The New New Product Development Game” paper, with multilearning being one of the main characteristics of effective teams. Multi-functional specialists were introduced in Toyota a long time ago:
In 1947, we arranged machines in parallel lines or in an L shape and tried having one worker operate three or four machines along the processing route. We encountered strong resistance among the production workers, however, even though there was no increase in work or hours. Our craftsmen did not like the new arrangement that required them to function as multi-skilled operators. They did not like changing from “one operator, one machine” to a system of “one operator, many machines in different processes.” – Taiichi Ohno, The Toyota Production System, 1988
I often hear the argument: “We understand the idea behind that. But still, a deep specialist will be more effective and knowledgeable than a cross-trained one”. And I agree with the argument. But we do not train people to create an efficient resource. Instead, we create a team capable of dealing with bottlenecks by themselves.
We do not train people to create an efficient resource. Instead, we create a team capable of dealing with bottlenecks by themselves!
Remember, when the system is heavily loaded, even a small change in capacity can lead to a significant difference in cycle time. In “Managing the Design Factory” Donald G. Reinertsen writes:
This ability of autonomous teams to align resources to bottlenecks is extremely important because it minimizes queues in the development process. Since these bottlenecks can shift rapidly and unpredictably during a program, the flexibility of team members to work outside of speciality is a critical tool for dealing with such bottlenecks. – D. G. Reinertsen
Dealing with a Culture of Narrow Specialists
Unfortunately, many teams prefer applying fixes and follow the resource utilization strategy. This approach is not a good idea if we want to optimize the whole. The quick fix of increasing the number of backlogs has a side effect that weakens the system’s natural ability to implement a more fundamental correction. When a Scrum Team adopts the resource utilization strategy and keeps doing it for some time, it creates a culture of narrow specialists. It takes a lot of effort, leadership support, and patience to overcome the resistance to change from the team, and to apply the fundamental solution instead. If we look at the final system diagram, we can see the reinforcing loop R6 that corresponds to the culture of narrow specialists:
Pay attention to the mental model:
“This is weird. Multi-functional people do not exist. It’s a myth”.
Therefore, with the help of system diagrams, we investigated the implications of learning disability in teams. Quick fixes have long-term consequences. The act of increasing the number of explicit or implicit backlogs spawns lots of problems: more Work-In-Progress, more queues, longer lead times, organizational stress, less delivered value. The fundamental solution is multi-functional learning.
Multi-Functional Learning is the Heart of Agility!
How to Enable Learning and Increase Agility?
There are many options for dealing with the situation when the Scrum Team(s) are used to work in the “make people busy” mode. Here are some of them:
Point out the tendency of the Scrum Team to focus on resource utilization instead of increasing Agility.
Conduct a system modeling workshop and let people have their insights regarding the “making everyone busy” strategy and the consequences associated with it. Use the system diagrams presented in this article for inspiration.
Create an awareness that people are working on less critical stuff from the customer’s perspective by creating a single queue of requirements. When possible, use the “cold turkey” strategy and move to a single Product Backlog overnight.
Gradually reduce the number of backlogs over time if there is a painful knowledge gap.
Point out that, in Scrum, the Product Backlog is ordered. You can use a simple rule that in general, the items at the top should be “Done” before the team proceeds to less important ones.
Establish a Perfection Vision that would take precedence over responding to the pressure of local optimization.
Use the Competency Matrix for inspecting and adapting the team’s cross-functionality. Update it regularly.
Create an agreement on how the team(s) would deal with the knowledge gap. For instance, it could consist of several points: a) help your teammates; b) remove technical debt; c) learn something valuable; d) start new work (last and worst option).
Try implementing the pattern “Swarming: One-Piece Continuous Flow.” The best Development Teams I have collaborated with, worked using three modes: pair-programming, mob-programming, and swarming continuously.
Try to change HR-practices to enable the development of multi-functional specialists in an organization.
In the next article, we shall dive deeper into tips and tricks for enabling multi-functional learning and increasing Agility.
In complex environments, work is never distributed evenly in Sprints. When developers are working on customer-centric Product Backlog Items, they experience a knowledge gap. There are two primary responses to this challenge. The first is to follow the path of resource utilization and to increase the number of implicit or explicit backlogs. Developers become individually more efficient, but at the cost of sub-optimizing the whole system. The solution is to respect the order of one Product Backlog by helping others and embracing multi-functional learning. Over time this strategy creates a flexible team. You train people to deal with bottlenecks. The culture of narrow specialists stays in the way of multi-functional learning. There are many ways to fight this culture and to preserve the long-term strategy. Getting teams to work continuously in pairing, mob-programming and swarming modes is one of the most effective approaches for this.
More with LeSS: Simplifying Organizations with 7 Design Principles
Why adopt agile or LeSS? Unfortunately, many organizations aim to increase individual or team productivity, activity, outputs, velocity, or resource utilization without realizing this usually leads to lower overall value delivery, longer cycle times for customer features, and less adaptiveness. LeSS does not focus on local optimizations such as increasing individual productivity, but on optimizing an organization for maximizing customer value delivery and organizational agility (adaptiveness)—the ease, speed with which an organization of people can change direction based on learning.
How to achieve agile, flexible, adaptable organizations? By creating simpler organizations!
Complicated organizations with many roles, processes, departments, and artifacts are slow to adapt to changes. Simple organizations have the potential to adapt quickly. In the LeSS community we refer to this as descaling organizational complexity. It is the essence of one of the LeSS principles, the More with LeSS principle.
How can we design simpler, agile organizations? We use the following organizational design principles to descale into LeSS organizations:
From Specialist Roles to Teams
From Resource-Thinking to People-Thinking
From Organizing around Technology to Organizing around Customer Value
From Independent Teams to Continuous Cross-team Cooperation
From Coordinate to Integrate to Coordination through Integration
From Projects to Products
From Many Small Products to a Few Broad Products
1. From Specialist Roles to Teams
Traditional organizations have single-specialized roles and elaborate processes on how these roles ought to interact. Individuals are responsible for their individual specialization. They are hired for that and might spend their entire life in that area of specialization. When all individuals perform their defined role, the organizational performance is maximized, in theory. Adaptiveness is likely to be low.
LeSS organizations have teams that have a shared responsibility for achieving a customer-centric goal, by self-managing—they themselves decide how they work and who does what. Team members are not stuck in the false dichotomy of being a generalist or a single-specialist. People naturally have preferences, yet they are not limited to a single specialization. Many specialist roles, such as tester or interaction designer or business analyst, cease to exist as these responsibilities become team responsibilities. Broad responsibility and self-management increase adaptiveness.
2. From Resource-Thinking to People-Thinking
Traditional organizations manage people as resources, assuming the skills of individuals are relatively fixed. They are structured to maximize the utilization of these resources against the goal of increasing individual productivity. This requires significant management effort to resolve these complicated resource allocations.
LeSS organizations manage people as people and assume that the greatest skills of individuals are acquiring and developing skills. LeSS organizations are structured to purposely cause a mismatch between existing skills and knowledge and those needed, for the benefit of increasing adaptiveness. This requires people to learn, which causes both joy and discomfort… but all the complicated resource management disappears.
3. From Organizing around Technology to Organizing around Customer Value
Traditional organizations structure their organization around their technology. Many people identify themselves with their technology specialization and organizing around this seems to maximize their individual productivity. Delivering customer value often requires more than one technology and that causes additional coordination effort and reduced adaptiveness.
LeSS organizations structure their organizations around customer value. Deep understanding of customers is essential for solving their problems using technology. Bringing teams close to customers by organizing them around customer value increases this understanding and leads to greater adaptiveness and more customer value.
4. From Independent Teams to Continuous Cross-team Cooperation
Traditional organizations prefer independent teams that can focus on their part of the product. These teams avoid continuous interruptions by specifying well-defined interfaces to which other teams must adhere to. Change, review, and approval processes avoid frequent changes to these interfaces. Often independence is achieved by hiding and delaying genuine dependencies. This isolation of teams reduces organizational flexibility.
LeSS organizations prefer multiple teams with shared work. These teams continuously cooperate to contribute to one consistent product. They function like one larger team, even though each team has their goal and own identity. Change, review, and approval can be greatly simplified or even disappear.
5. From Coordinate to Integrate to Coordination through Integration
Traditional organizations coordinate to integrate the output of many teams. Because the teams deliver their outputs asynchronously, the coordination responsibility is external to the team, leading to coordination roles (such as project and release managers) and coordination events. Coordination conflicts are common, leading to re-evaluating and shifting priorities.
LeSS organizations have teams that continuously integrate their work. Through continuous integration the teams discover opportunities for cross-team collaboration—a surprising and powerful idea. Because of the synchronous nature of cross-team integration—the teams have shared work right now at the same time—the coordination responsibility can be integrated into the team. External-to-team coordination roles disappear.
6. From Projects to Products
Traditional organizations manage development as projects or programs—big projects. Projects have clear start and end dates, clear scope. People are allocated to them for a predetermined amount of time. Budgets are decided by the expected value of the predetermined scope. This leaves little room for responding to changes. Myriad and varying projects cause complicated project portfolio management to synchronize the re-allocation of resources to projects.
LeSS organizations manage development as products. Products have a clear purpose but no fixed end or scope. People are allocated to them for an undetermined amount of time. Budgets are decided by potential value without tying it directly to a specific scope. This leaves lots of room for responding to change. A product is continuously developed and therefore a regular rhythm of re-allocating the people to products will suffice. Complicated project portfolio management disappears.
7. From Many Small Products to a Few Broad Products
Traditional organizations prefer managing small technology-based products such as services, components, applications, or platforms. But no such small product is an island and they need to interact and be integrated together to deliver customer benefits. This leads to complicated cross-product management structures for coordinating, prioritizing, and budgeting.
LeSS organizations prefer managing broad customer-centric products. The services, components, applications, and platforms belong to one product with one Product Backlog and one Product Owner. Teams create customer-centric features and work across these components. Complicated portfolio management disappears, and complicated cross-product management structures disappear or become significantly simpler.
Each organizational design choice requires a significant shift in organizational thinking and they have a large impact on people, teams, organization structure, and management. These changes aren’t always easy but they lead to simpler, adaptable, purposeful, and more fun organizations that deliver higher value.
This is a story from a colleague who was providing technical coaching at a client.
He was one of the technical coaches working with 40 Scrum Teams to improve on their technical, development practices and bring them on a par with 21st century standards.
At one of these sessions, the technical coaches provided training, mentoring and coaching about modern development concepts like test-driven development (TDD) and acceptance-level TDD (ATDD). One of the involved developers went to his desk, opened his drawer, pulled out his working contract, pointed at it, and said: “It does not say ‘testing’ in here.”
Clearly, that developer was heavily relying on his paper contract. If it didn’t state to wash his hands after he went to the toilet, maybe he wouldn’t have done so. Who knows?
But, seriously. Does it help if an idle team member points out that something is not his or her job, while the work needs to get done, and all the other people involved are too busy to do it? Not really.
Taking a closer look at companies large and small, we see a particular pattern. In smaller companies, it seems to be more like an accepted behavior to take overwork, even though it may not be part of your job description. In larger companies though, people are more hesitant to do so as the likelihood of stepping onto someone else’s toes might cause problems, not to mention that it often doesn’t help them advance their career.
Regardless, we don’t think the latter attitude is helpful to solve the complex problems we typically intend to solve with Scrum.
As humans, we are born with little skills. One of the core things the human brain is capable of learning new things, continuously and life-long. We learned to crawl, to step up, and to eventually walk and run. This freed us from the perceived problems when we grew up. Just because something is not your job should not keep you from learning the necessary skills to perform the work if it has to be done.
What if that work does not have to be done? Well, why then do it at all?
As humans, we learn all our lives long. That’s what distinguishes us from other species. Use that one thing that makes you human to contribute to your team’s efforts, meanwhile also developing yourself.
“That’s not my job” really is a pretty cheap excuse for not doing the related work. Don’t go there as it undermines team morale and your self-development.
At the time of this writing, Jira is probably the most widely used digital tool in Scrum and LeSS adoptions. Unfortunately, using Jira commonly leads to some predictable dysfunctions. Some of these are:
Scrum confusion and tool-owned processes
Micro-management due to integration of Product and Sprint Backlog
No shared team responsibility due to poor Sprint Backlog
Scrum confusion and tool-owned processes
Many companies start “enterprise-wide” Scrum adoption with mandating Jira. People learn Scrum through Jira, or so they think. However, Jira was never a Scrum tool. It is an issue tracking tool with many ideas integrated into it, such as Scrum and many… not-Scrum. Teams end up adopting ideas that they think, or were told, are included in Scrum.
The overall result is anti-Scrum. How? Scrum has a minimum of prescriptions as it implements empirical process control. Team practices are not prescribed or fixed but are adopted and adapted as context changes. Scrum implies team-owned processes rather than tool-owned processes.
Micro-management due to integration of Product and Sprint Backlog
Jira integrates the Product and Sprint backlog. This might seem like a good idea but in practice, it is not. It leads to confusion about their purpose.
The Product Backlog contains items that represent product features or improvement work. The Product Owner uses the Product Backlog for tracking product progress, deciding features to create next, and for making scope/time/cost trade-offs.
The Sprint Backlog is a plan from the Team on how they are going to attempt to achieve the goal of the Sprint. It is valid for one Sprint – it is created at the start of the Sprint, never earlier, and ceases to exist at the end of the Sprint. The Team keeps it up-to-date all the time. It enables them to take a shared responsibility and manage all the in-Sprint work.
Integrating the Sprint Backlog and the Product Backlog easily leads to the Product Owner and management starting to track in-Sprint progress. By doing so, they take over the responsibility of the Team to manage their own progress during the Sprint. The temptation to interrupt the Team during their Sprint is often irresistible. And this will change Scrum from a framework for supporting self-managing teams to a micro-management framework.
No shared team responsibility due to poor Sprint Backlog
Good teams avoid having half-done items at the end of the Sprint. They do so by truly taking a shared responsibility and by working one (or a few) items at the time. They achieve this through fine-grained task splitting so that each team member can pick up tasks related to the same item at the same time.
Creating tasks in Jira is slow. This might be because Jira itself is slow – most of my experiences with Jira were self-hosted installations (due to cloud restrictions) and they were all slow. Or it might be because tasks are created in Sprint Planning with one person typing. Whatever the slowness reason, all teams I’ve observed minimized their Jira typing time by avoiding small tasks.
Large tasks lead to less shared work, which leads to less shared team responsibility, which leads to a less effective team. How do you know this might be happening? Half-done items at the end of the Sprint and the Team talking about ‘spill-over’ or ‘carry-over’ work.
Key point: The phrases ‘carry-over’ and ‘spill-over’ are not Scrum. They’re signs of dysfunctional Scrum.
We are stuck with Jira, now what?
How to use Jira so that it causes the least amount of harm? My recommendations are:
Never use Jira for Sprint Backlogs
When using Jira for a Product Backlog, simplify it. Make it work like a spreadsheet.
Avoid any complicated features and avoid workflows. Out-of-the-box Jira is already too complicated.