Systems Thinking, Project Management, and Agile – Part 6: “Abandon All Hope,…”

[For this series, it will help to have read “System Dynamics and Causal Loop Diagrams 101.”]

“…ye who enter here.” So reads the inscription to the Gates of Hell in Dante Alighieri’s epic poem, “Divine Comedy.” Who among us hasn’t felt on occasion that stepping across the threshold to our place of employment is like passing through the gates of Dante’s Inferno? But as the poets have told us, the way to peace is to find the path through our troubles. In this article, we’ll look into just how deeply project system dynamics can adversely affect progress and even whether or not the project is successful.

But I do want to arm the reader with a couple of rays of hope. The concluding article in this series will focus on how this system model¹ can be used to good effect, how it can be used to identify problems before they grow out of control. Therein lies the path to peace. Before we get there, we need to understand several more influential feedback loops.

As the Delay to Completion becomes critical, management begins to panic. Not wanting to push the deadline out they work to influence the other three options focused on modifying the behavior of the delivery team. The end result is a team that is caught in the Work Faster, Work More, and Add People loops along with all the other associated downstream loops. The effect is compounded by the emergence of other feedback loops if teams are placed in this position for an extended period of time.

Over time, the shortcuts, hacks, and quick fixes put in place to keep the pace of progress as high as possible settle in as technical debt. They work – for now – so they don’t surface as errors for quality assurance to discover. Down the road, however, solutions hastily put in place as stop-gaps fail when later solutions require existing solutions to be more robust then they are. For example, a software method that doesn’t take advantage of multi-threading may break when a later solution needs that method to scale beyond it’s single thread capacity. The shortcut is now a defect.

If the technical debt remains in place for an extended period of time, it may be covered by several release layers. When it does flip to defect status due to some later stress, it can be much more time consuming and expensive to uncover. The original developer of the code may not be available or even if she is, it could take her quite a bit of time to become reacquainted with the code. This can be thought of as a form of dark debt and is reflected in the Errors Build Errors Loop (Figure 1, J).

As the teams struggle to keep up the pace of progress and reduce the Delay to Completion, work streams start to become out of sequence. One team has an easier time at crafting their solution while another, to which they are dependent on the output, hits a significant snag and is delayed several weeks. In order to stay busy, the first team starts work on something else while the second team finishes their work. When the second team delivers, the first team is not prepared to immediately shift back to their original work stream and so their deliverable is delayed even further. Meanwhile, a third team, that was dependent on the first team’s deliverable has now been delayed by the cumulative delay of the first two teams. Teams and individuals begin to take shortcuts as delivery of interim work products become out of sync with each other. The diminished focus and desynchronization of work streams leads to an increase in the Error Fraction, which in turn leads to a further Delay to Completion. This is the Haste Makes Out-of-Sequence Work Loop (Figure 1, K).

As the effects of the Haste Makes Out-of-Sequence Work Loop build, team begin switching back-and-forth between work streams depending on who is making the most noise for the completion of any particular deliverable. This is the Thrash and Churn Loop (Figure 2, L). Switching from stream to stream or, in worst cases, task to task, places a tremendous burden on development teams and can do more to slow progress than almost anything else I’ve encountered in team management. Not covered in this model is the type of churn that occurs when parts of the project undergo redesign after work has begun on the existing design. Long term projects are particularly susceptible to adverse impacts from redesign as the changes are often farther reaching. The drivers behind a redesign can range from trivial (a new CTO has a personal dislike for a platform vendor) to critical (a security flaw uncovered in a core technical component.)

If all the loops described to this point in the article series are allowed to run uncorrected the system is likely to crash as the project becomes one massive firefighting effort. A key indicator for when this is happening is employee morale.

The increased Fatigue, the growing burden of Work/Rework to Do, the unsatisfying Task Switching between work assignments all combine to causes a decrease in team Morale. This is the Hopelessness Loop (Figure 3, M). Teams are left with a powerless feeling of being caught on a never ending treadmill. And so, stepping across the threshold to the office is like passing through the gates of Dante’s Inferno.

The ripple effect from a decrease in Morale leads to a decrease in the Workforce as employees leave the organization in search of less stressful, more satisfying work. This is the Turnover Loop (Figure 3, N). The remaining demoralized employees are even less productive and unhappy employees make more mistakes, thus increasing the Error Fraction in the system. The downstream result is that the Delay to Completion increases yet again.

If corrective action isn’t taken the law of diminishing returns becomes evident and the system collapses. The cost overruns become prohibitive and the project is cancelled. Worst case, the organization runs out of resources (money, time, or both) and goes out of business. Those are bad things. In the concluding article to this series, we look at how this model can be used to read the current state of a project’s system dynamics and explore some ways we can intervene such that the system doesn’t run out of control.

References

¹The core of the model I use to assess team and organization health is based on the work of James Lyneis and David Ford: System Dynamics Applied to Project Management, System Dynamics Review Volume 23 Number 2/3 Summer/Fall 2007

Image by Myriams-Fotos from Pixabay

Systems Thinking, Project Management, and Agile – Part 5: It Lives! But it’s Out of Control!

[For this series, it will help to have read “System Dynamics and Causal Loop Diagrams 101.”]

In the previous article for this series, I described three options managers could consider if moving the project deadline was out of the question.

Increase employee work intensity
Call for overtime
Hire people

On the face of it, they each appeared to offer a path toward returning a drifting schedule to be on time. Now let’s look a little further down the road to see what happens when the juice is applied to each of these options in turn. If we implement any of these options, what are the likely consequences?

We know that errors in the work flow are unavoidable. If we encourage or pressure the development team to finish more work in less time (the Work Faster Loop¹, Figure 1, C) this will result in an increase in the errors along with an increase in the amount of Work Done.

This is the Haste Makes Waste Loop (Figure 1, F). In other words, the increase in Work Intensity will have a concomitant increase in the Error Fraction which means there is an increase in Errors generated. The extended consequence of pulling the Work Intensity lever is an increase in Work to Do in the form of extra Rework to Do.

OK. So Option 1 isn’t a get-out-of-jail-free card. There are strings attached. How about Option 2, call for the development team to work overtime?

By increasing Overtime, the risk of Fatigue increases sharply. This results in yet another increase in the Error Fraction (tired people make more mistakes than rested people) and a decrease in Productivity (tired people don’t work as efficiently as rested people.) Both slow down Progress and increases the amount of Rework to Do in the system. This is the Burnout Loop (Figure 2, G).

OK. So Option 2 doesn’t lead to sunshine and roses. There are dark clouds and weeds in the mix. Let’s give Option 3 a go, hire more people!

So we’ve beefed up the Workforce by hiring a bunch of people to join the team. With all those extra people in the mix we’ve also increased the overall Congestion and Communication Difficulties. The email traffic increases, everyone’s Inbox fills up faster, meeting attendee size increases along with the number of meetings. The signal to noise ratio decreases and miscommunication increases. This increases the Error Fraction, decreases Productive, and decreased Progress. End result: the Too Big to Manage Loop (Figure 3, H).

But that’s not all. By hiring extra people, we’ve activated the Expertise Dilution Loop (Figure 5, I).

All those new hires don’t come in off the street ready to go. They decrease the depth of Experience available to focus on making progress. Experienced employees have to slow down and assist new employees in understanding the technical systems, the architecture, and development standards. New employees will need some period of time to become familiar with the work environment, project objectives, who’s who, and where the coffee is.

As they work to understand and gain experience with the systems, new hires will necessarily make mistakes and increase the Error Fraction. While there are more workers available to focus on the product backlog, the available expertise is spread much more thinly and is collectively less experienced until such time the new workers are up to speed with what needs to be done and how. So the errors go up and Productivity goes down. The down stream effect is often a further increase in the Delay to Completion. As the saying goes, throwing more people at the problem more often than not makes the problem worse.

OK. So no unicorns and rainbows here either. More like a lot of warthogs and rain.

Looks like the first level effects were negated by the second level consequences. That’s bad enough, but the third level consequences can be even worse in that they are often much longer lasting and much more difficult to resolve. We’ll look at those in the next article in this series.

References

Image by Gerd Altmann from Pixabay

Systems Thinking, Project Management, and Agile – Part 4: Welcome to the Labyrinth

[For this series, it will help to have read “System Dynamics and Causal Loop Diagrams 101.”]

The capable product owners I know have at least an intuitive understanding that the challenge of guiding a project through to completion is more than a bit like Theseus on his way to defeat the Minotaur. The great product owners have a much more present awareness of the labyrinth before them. Depending on the project, the team, and the work environment, the product backlog just might be the easy piece. It’s more knowable then the myriad of ways a system can work against project success.

The purpose of this series of articles is to shine light on those wily ways of the system, to make more known what capable product owners intuit, to help you become a great product owner.¹

In the previous article, we covered how a project can end up with a growing delay before completion. The obvious fix was to push out the deadline, thus erasing the delay (The Shift Deadline Loop, Figure 1, B.) Management has a strong dislike for this and often avoids changing deadlines even when faced with minimal consequences. It’s more likely there are other factors that make the consequences significantly greater. Perhaps there are budget constraints or a delivery date that is tied to a major event like the launch of a suite of related products or a conference.

So if management is faced with an unmovable deadline, the Delay to Completion must be resolved by some other means.

With more work to do and less time to do it, there is now a Talent Resource Deficit. X number of employees working 40 hours a week will no longer get the work done on time. Management’s next set of options lie with changing the behaviors of the development team. We’ll consider three of these options.

The first option is to put pressure on the development team to focus on work more during the time they are working. Maybe this involves tightening the work hours people are expected to be available. Or restricting remote work so team members are in close proximity for longer periods of the day in the hope of shorting the delays inherent in remote communication and problem solving. Or working to eliminate distractions in the workplace. There are many possibilities here.

This is the Work Faster Loop (Figure 2, C) – complete more work in less time. If the development team is more focused, the thinking goes, Productivity will increase and in turn drive an increase in Progress. More Progress leads to less Work to Do which leads to less Total Known Remaining Work which leads to less Time Required to Complete Work and a decrease in the Delay to Completion. Eventually, the Talent Resource Deficit is reduced and the development team can relax a bit.

This looks great in principle. Will get to the messy reality in a future article, but for now, we just need to understand how management typically thinks things should work.

The second option is to ask the development team work Overtime.

Officially, management asks. Unofficially, it isn’t presented as an option. If the development team is putting in more hours, the thinking goes, then the amount of Effort being applied to the work stream increases. As with an increase in Work Intensity, this works its way through the system to reduce the Delay to Completion and ultimately, the development team will no longer need to put in extra hours. This is the Work More Loop (Figure 3, D).

The third option is to simply hire more people to work on the development team.

By deciding to Hire Talent, management will increase the Workforce and once again increase the Effort aimed at increasing progress. As with the increase in Work Intensity and Overtime, this eventually manifests as a decrease in the Delay to Completion. This is the Add People Loop (Figure 4, E).

There you have it. Schedule slipping? Flip one or more of the following switches…

Extend the deadline
Increase employee work intensity
Call for overtime
Hire people

…and in short order the system will be back in balance and the project on schedule. Problem solved.

Not so fast there, young Theseus. Remember, there’s a Minotaur on the hunt for you somewhere in this labyrinth. In the next article of this series we’ll begin looking a some of the ways this simplistic machine thinking can go sideways…fast.

References

Image by Daniel Roberts from Pixabay

Systems Thinking, Project Management, and Agile – Part 3: Let the Interactions Begin!

[For this series, it will help to have read “System Dynamics and Causal Loop Diagrams 101.”]

In the previous article we learned how to read an important feature of system diagrams. Namely, the interactions – the direction and whether or not the effect of the interaction was direct or indirect. With that understanding in hand, we can begin to look at real-life interactions. Well, real in the sense they are reflections of real-world interactions. These are interactions that take place outside the Work Loop but nonetheless affect the performance of the Work Loop.

By the time we’re done building out the model, you’ll be aware of just how many brake and gas peddles there on in this project management automobile (building on the metaphor used in the previous post for this series!)

Revisiting the Work Loop¹ (indicated by the icon)…

We see there are several things that can interact with progress: How productive an individual or team is and how much effort they apply to their work. The green open-head arrow indicates that the relationship between each of these interactions and progress is direct. An increase in Productivity, applied Effort, or both will increase progress. Decrease Productivity or applied Effort and progress slows down.

That seems straightforward. But it isn’t all good news. Being more productive and applying more effort will also generate an unknown increase in Errors. Consequently, the amount of Undiscovered Rework will also increase.

This means that more effort needs to be applied toward discovering the Undiscovered Rework, so the relationship between Undiscovered Rework and the effort to actually discover the rework is direct (the green open-head arrow.) An increase in the amount of Undiscovered Rework results in an increase in the effort needed to actually discover all the hidden rework.

There is an inverse relationship in the mix here, too (the red closed-head arrow.) As the time it takes to discover defects and bugs increases, the rate of rework discovery decreases. This is particularly true with dark debt issues and defects that have been hidden in the system for months or even years. Finding gnarly bugs often takes a lot of time and effort. UI typos and misaligned text box labels, not so much.

So far, so good. But what affect does the additional work from the Rework to Do bucket have on the project schedule?

The system as it stands can only handle so much throughput. (Later in the article series we’ll cover ways to influence this throughput.) Adding Rework to Do to the flow of overall work that needs to be done will also slow down the rate at which original Work to Do gets to Work Done.

If project life is good the amount of Work to Do and Rework to Do decreases so that the amount of total Known Remaining Work decreases. If the amount of Work to Do and Rework to Do are increasing, the amount of total Known Remaining Work increases and project life is bad. (Figure 3)

There could be any number of causes driving the project down the bad road, hopefully only for a short while. Since we don’t know what we don’t know, after work begins on a project discoveries are made about additional work simply by working on known work. It could also be that additional work is added to the project intentionally. Perhaps marketing has discovered a feature that could place the end product in a stronger position or an existing feature needs to be strengthened to help close a sale or a planned approach turns out to be technically unfeasible or…the list is endless.

With the increase in the amount of Known Remaining Work, and all other aspects of the project remaining unchanged, at the very least the Time Required to Complete Work will increase. This in turn pushes out the projected delivery date and therefore increases the Delay to Completion. It’s at this point management starts getting grumpy.

Call out any project management methodology devised by man and it’s a safe bet that it drives toward establishing a predictable completion or delivery date. Agile methodologies are no different. Delivery dates are the interface between work teams and management. When faced with the news that a scheduled delivery date is at risk, management has two basic choices available to them. Either change the delivery date to match the performance of the delivery team or change the behavior of the delivery team such that the originally scheduled delivery date can be met. (A blend of the two is certainly possible but not particularly common in practice.)

The most obvious choice is to make changes that directly impact the Delay to Completion. That is, change the delivery date to accommodate the delivery team’s performance.

This introduces our first feedback loop – the Shift Deadline Loop (Figure 4, B.)

Let’s say the amount of Total Known Remaining Work has increased such that the Delay to Completion has grown to four months. If the decision is made to push the Deadline out by four months the effect is to increase the amount of Time Remaining which in turn decreases the Delay to Completion to zero. (Savvy Agile team members recognize that the shelf life of a zero completion delay is something less than 24 hours.)

But remember, schedule delays make management and other stakeholders grumpy. They’re loath to choose this path unless it is forced upon them by having exhausted all other options. And those options usually involve putting pressure on the system at other points.

If management chooses to follow the path of changing the delivery team’s behavior, the effects can be as far reaching as they can be significant. Depending on the choices made, the effects could be either very good or very bad. Very good results are hard. Very bad results are easy and therefore much more common. We will begin to explore these in the next article for this series.

References

Image by Gerd Altmann from Pixabay

Systems Thinking, Project Management, and Agile – Part 2: Work, Work, Work…

[For this series, it will help to have read “System Dynamics and Causal Loop Diagrams 101.”]

…work, work, work. It’s what we do.

“I have to go to work.”

“What do you do for work?”

“OK, team. Let’s get to work.”

“Where do you work?

“Is that working for you?”

“That’ll never work.”

“Let’s work together.”

“Time to roll up our sleeves and get to work.”

The notion of work is so pervasive it underpins my belief that Agile principles and practices can be applied to a variety of human endeavors beyond the narrow focus on software development. In fact, the case can be made that Agile principles and practices have been around for millennia and only very recently were codified for a software development context. Agile simply feels more natural, more aligned with how humans think and interact to solve problems. From the way we explore and learn as children to the way we solve problems at home as adults, it’s much easier to recognize Agile patterns than waterfall patterns. In spite of this, when we go to work we’re subject to the behaviors and measures of machines and Taylorism.

It doesn’t have to be that way. Agile has been shown to more effective at increasing productivity and decreasing costs in contexts beyond software. So why isn’t it practiced everywhere all the time?

I can think of a couple of broad generalizations that answer this question. First, Agile isn’t a panacea. Nothing is. To paraphrase Winston Churchill, Agile is the worst form of project management, except for all the others. Second, in the light of Conway’s Law and Shalloway’s Corollary, the systemic monster pushing back on change is a formidable one.

I have no aspirations of making Agile a panacea and will never claim it to be one. But until something more promising comes along, I can work to improve the practices for applying Agile values and principles. As for the systemic monster, that’s what this series of articles are about.

Monsters are scary because we don’t know them, we can’t see them, they’re hidden from us, they’re “out there, somewhere.” We’ll begin the process of understanding the systemic workplace monster by shining a light on work. What is it? How do we define it?

With each new day, in one form or another, we face a newly filled box of Work to Do. On the far side of the day, there is an empty box of Work Done.

In a perfect world, by the end of the day, Work to Do is empty and Work Done is full.

This transition doesn’t happen by itself. Magic won’t get work moved to done. There’s effort involved. More effort means more progress. Less effort, less progress. On Agile software projects, Work to Do is described in the product backlog and Work Done manifests as a deliverable product or service.

Typically, there is some form of measure on progress toward the goal of getting work to done. In scrum, this might be story points completed or business value delivered.

But we don’t live in a perfect world. Whatever the endeavor, errors and mistakes are part of the work effort. Instructions were unclear or incomplete, time constraints caused the work to be rushed, the person doing the work was apathetic or otherwise unfocused – there are thousands of reasons for why some of the work fails to meet expectations.

Since our efforts to complete work are always less than perfect by some percentage, part of the effort that creates progress is also an effort that generates errors. Anyone managing a project – especially a technical project – should expect that there is a box of Undiscovered Rework hiding somewhere. How big that box is or how fast it’s filling are unknown. All we know at this point is the box of Undiscovered Rework exists. In software development, the contents of this box are referred to as defects or bugs.

We know the box of Undiscovered Rework is there somewhere. So now we need a deliberate effort aimed at discovering that rework. This is the job of quality assurance and testing professionals. Their efforts at rework discovery bring the defects and errors to light so that they can be documented and added to the flow of Work to Do.

This is the work loop.¹ Human interactions and behaviors aimed at achieving some larger goal provide the energy for driving this loop. The quality of those interactions determine how fast work moves through this loop.

In subsequent posts, we’ll begin to explore several specific human interactions and behaviors the can either support or inhibit the flow of work through this loop. Be sure to read “System Dynamics and Causal Loop Diagrams 101” to prepare for the rest of the articles in the series.

Before you go, however, read through the following phrases and make a mental note of those that resonate with you – either because you have heard them before or perhaps because you have uttered them yourself while working on a project.

“We’re not moving the delivery date.”
“We’ll just have to work harder.”
“The team will have to put in more time until we’re caught up.”
“We’ll need more people on the project.”
“The team will have to work faster.”
“We’re to the point of exhaustion.”
“I’m losing track of all the pieces.”
“There’s no time for training.”
“Where did those errors come from?”
“We’re waiting on another team.”
“Another person quit the company?!?!”
“I don’t care. I get done what I get done when I get it done.”

References

Photo by Elisa Ventur on Unsplash

Agile Haiku #8

Minimum, you say.
And viable, it must be.
And stand on it’s own?

Systems Thinking, Project Management, and Agile – Part 1: The Revenge of Frankenagile

[For this series, it will help to havve read “System Dynamics and Causal Loop Diagrams 101.”]

The ubiquitous employee handbook is filled with rules, regulations, and descriptions of how employees are expected to behave. The larger the organization, the thicker the handbook. Handbooks and associated policies like this have been described as “corporate scar tissue.” Someone somewhere at sometime made a serious mistake, whether intentional or not, and so a policy was created to prevent that something from ever happening again. The same effect can be seen with many consumer products that have lengthy warning labels and manual pages stating things not too far from “This toaster is not suitable as a flotation device in the event of a boating accident.”

In an effort to prevent a re-occurrence, the policies effectively limit – much like physical scar tissue – the ability of people within the organization to adapt, improvise, and innovate. They limit an employee’s range of motion within the organization’s solution space. The goal is to save the organization from human error and create the perfect business machine. But in the end, excessive policies condemn the organization to a slow but certain death.

Anyone who has worked within a large organization recognizes this. For some, it’s a comfort. Knowing the rules. Knowing where the fences are. And knowing where to place blame. The less ambiguity around how a situation can be interpreted the better. For others, maybe after an attempt to change things, the environment becomes too stifling and they leave for greener, wider pastures.

Given enough time, the policies become the document of record for the organization’s culture. Any attempts to change the way work gets done within an organization that has deep scar tissue will have to confront Shalloway’s Corollary:

When development groups change how their development staff are organized, their current application architecture will work against them.

I’ve learned this corollary is not limited to software companies. In every case I’ve experienced, whether in a software company or not, the system will push back. Hard. Every Agile practitioner needs to know and respect this. Riding into work on a unicorn with a bag of rainbows and pixie dust is a gig that will not end well. At best, the organization will have made an incomplete effort at implementing Agile and “Frankenagile” will be roaming the halls – a collection of project management methodological parts that by themselves served a valuable purpose in a larger or different context, but have been stitched together to form a monster in Agile name only.

In a small company, particularly if it is working to create a software product, the monster may be small. So performing corrective surgery, while still a lot of work, is quite possible in a relatively short amount of time. For larger organizations, particularly those with deep roots in traditional project management, it can be a scary sized beast indeed. Something not to be trifled with, rather something that needs a well thought out strategy and plan of action.

It is the latter scenario I’d like to address in this series of posts (this being Part 1, the introduction) over the next several weeks. I’ll present is a method I’ve used quite successfully over the past 13+ years for assessing the extent to which Conway’s Law and Shalloway’s Corollary are in play. It is a method for determining both team and organization health within the larger management context. The extent to which Agile can be successfully implemented in an organization is dependent on how aware management, the Agile coach, and scrum masters are of the system dynamics driving organizational behavior.

Next post in the series: Assessing and Tracking Team Performance – Part 2: Work, Work, Work…

Photo by freestocks on Unsplash

Improving the Signal to Noise Ratio – Revisited

Additional thoughts about signals and noise that have been rattling around in my brain since first posting on this topic.

At the risk of becoming too ethereal about all this, before there is signal and before there is noise, there is data. Cold, harsh, cruelly indifferent data. It is after raw data encounters some sort of filter or boundary, something that triggers a calculation to evaluate what that data means or whether it is relevant to whomever is on the other side of the filter, that it begins to be characterized as “signal” or “noise.”

Since we’re talking about humans in this series of posts, that filter is an amazingly complex system built from both physiological and psychological elements. The small amount of physical data that hits our senses and actually makes it to our brains is then filtered by beliefs, values, biases, attitudes, emotions, and those pesky unicorns that can’t seem to stop talking while I’m trying to think! It’s after all this processing that data has now been sorted according to “signal” (what’s relevant) and “noise” (what’s irrelevant) for any particular individual. Our individual systems of filters impart value judgments on the data such that each of us, essentially, creates “signal” and “noise” from the raw data.

That’s a long winded way to say:

data -> [filter] -> signal, noise

Now apply this to everyone on the planet.

data -> [filter 1] -> signal 1, noise 1

data -> [filter 2] -> signal 2, noise 2

…

data -> [filter n] -> signal n, noise n

As an example, Google (itself a filter) is a useful one. Let’s assume for a moment that Google is some naturally occurring phenomenon and not a filter created by humans with their own set of filters driving what it means to create a ~~let’s be evil~~ good search engine. To retrieve 1,000,000 pieces of information, my friend, Bob, entered search criteria of interest to him, i.e. “filter 1.” Maybe he searched for “healthy keto diet recipes”. Scanning those search results, I determine (using my “filter 2”) 100% of the search results are useless because my filter is “how do i force the noisy unicorns in my head to shut the hell up”. The Venn diagram of those two search results is likely to show a vanishingly small set of relationships between the two. (Disclaimer: I have no knowledge of the carbohydrate content of unicorns nor how tasty they may be when served with capers and a lemon dill sauce.)

Google may return 1,000,000 search results. But only a small subset is viewable at a time. What of the rest of the result set that I know nothing about? Is it signal? Is it noise? Is it just data that has yet to be subjected to anyone’s system of filters? Because Google found stuff, does that make it signal? Accepting all 1,000,000 search results as signal seems to require a willingness to believe that Google knows best when it comes to determining what’s important to me. This would apply to any filter not our own.

All systems for distinguishing signal from noise are imperfect and some of us on the Intertubes are seeking ways to better tune our particular systems. The system I use lets non-relevant data fall through the sieve so that the gold nuggets are easier to find. Perhaps at some future date I’ll unwittingly re-pan the same chunk of data through an experienced-refined sieve and a newly relevant gem will emerge from the dirt. But until that time, I’ll trust my filters, let the dirt go as noise, and lurch forward.

Photo by Nathan Dumlao on Unsplash

Story Points and Fuzzy Bunnies

The scrum framework is forever tied to the language of sports in general and rugby in particular. We organize our project work around goals, sprints, points, and daily scrums. An unfortunate consequence of organizing projects around a sports metaphor is that the language of gaming ends up driving behavior. For example, people have a natural inclination to associate the idea of story points to a measure of success rather than an indicator of the effort required to complete the story. The more points you have, the more successful you are. This is reflected in an actual quote from a retrospective on things a team did well:

We completed the highest number of points in this sprint than in any other sprint so far.

This was a team that lost sight of the fact they were the only team on the field. They were certain to be the winning team. They were also destine to be he losing team. They were focused on story point acceleration rather than a constant, predictable velocity.

More and more I’m finding less and less value in using story points as an indicator for level of effort estimation. If Atlassian made it easy to change the label on JIRA’s story point field, I’d change it to “Fuzzy Bunnies” just to drive this idea home. You don’t want more and more fuzzy bunnies, you want no more than the number you can commit to taking care of in a certain span of time typically referred to as a “sprint.” A team that decides to take on the care and feeding of 50 fuzzy bunnies over the next two weeks but has demonstrated – sprint after sprint – they can only keep 25 alive is going to lose a lot of fuzzy bunnies over the course of the project.

It is difficult for people new to scrum or Agile to grasp the purpose behind an abstract idea like story points. Consequently, they are unskilled in how to use them as a measure of performance and improvement. Developing this skill can take considerable time and effort. The care and feeding of fuzzy bunnies, however, they get. Particularly with teams that include non-technical domains of expertise, such as content development or learning strategy.

A note here for scrum masters. Unless you want to exchange your scrum master stripes for a saddle and spurs, be wary of your team turning story pointing into an animal farm. Sizing story cards to match the exact size and temperament from all manner of animals would be just as cumbersome as the sporting method of story points. So, watch where you throw your rope, Agile cowboys and cowgirls.

Image by Simona Robová from Pixabay

Agile Metrics – Time (Part 3 of 3)

In Part 1 of this series, we set the frame for how to use time as a metric for assessing Agile team and project health. In Part 2, we looked at shifts in the cross-over point between burn-down and burn-up charts. In Part 3, we’ll look at other asymmetries and anomalies that can appear in time burn-down/burn-up charts and explore the issues the teams may be struggling with under these circumstances.

Figure 1 shows a burn-up that by the end of the sprint significantly exceeded the starting value for the original estimate.

There isn’t much mystery around a chart like this. The time needed to complete the work was significantly underestimated. The mystery is in the why and what that led to this situation.

Where there unexpected technical challenges?
Were the stories poorly defined?
Were the acceptance criteria unclear?
Were the sprint goals, objectives, or minimum viable product definition unclear?

Depending on the tools used to capture team metrics, it can be helpful to look at individual performances. What’s the differential between story points and estimated time vs actual time for each team member? Hardly every useful as a disciplinary tool, this type of analysis can be invaluable for knowing who needs professional development and in what areas.

In this case, there were several technical challenges related to new elements of the underlying architecture and the team put in extra hours to resolve them. Even so, they were unable to complete all the work they committed to in the sprint. The the scrum master and product owner need to monitor this so it isn’t a recurrent event or they risk team burnout and morale erosion if left unchecked. There are likely some unstated dependencies or skill deficiencies that need to be put on the table for discussion during the retrospective.

Figure 2 shows, among other things, unexpected jumps in the burn-down chart. There is clearly a significant amount of thrashing evident in the burn-down (which stubbornly refuses to actually burn down.)

Questions to explore:

Are cards being brought into the sprint after the sprint has started and why?
Are original time estimates being changed on cards after the sprint has started?
Is there a stakeholder in the grass, meddling with the team’s commitment?
Was a team member added to the team and cards brought into the sprint to accommodate the increased bandwidth?
Whatever is causing the thrashing, is the team (delivery team members, scrum master, and product owner) aware of the changes?

Scope change during a sprint is a very undesirable practice. Not just because it goes against the scrum framework, but more so because it almost always has an adverse effect on team morale and focus. If there is an addition to the team, better to set that person to work helping teammates complete the work already defined in the sprint and assign them cards in the next sprint.

If team members are adjusting original time estimates for “accuracy” or whatever reason they may provide, this is little more than gaming the system. It does more harm than good, assuming management is Agile savvy and not intent on using Agile metrics for punitive purposes. On occasion I’ve had to hide the original time estimate entry field from the view of delivery team members and place it under the control of the product owner – out of sight, out of mind. It’s less a concern to me that time estimates are “wrong,” particularly if time estimate accuracy is showing improvement over time or the delta is a somewhat consistent value. I can work with an delivery team member’s time estimates that are 30% off if they are consistently 30% off.

In the case of Figure 2 it was the team’s second sprint and at the retrospective the elephant was called out from hiding: The design was far from stable. The decision was made to set aside scrum in favor of using Kanban until the numerous design issues could be resolved.

Figure 3 shows a burn-down chart that doesn’t go to zero by the end of the sprint.

The team missed their commit and quite a few cards rolled to the next sprint. Since the issue emerged late in the sprint there was little corrective action that could be taken. The answers were left to discovery during the retrospective. In this case, one of the factors was the failure to move development efforts into QA until late in the sprint. This is an all too common issue in cases where the sprint commitments were not fully satisfied. For this team the QA issue was exacerbated by the team simply taking on more than they thought they could commit to completing. The solution was to reduce the amount of work the team committed to in subsequent sprints until a stable sprint velocity emerged.

Conclusion

For a two week sprint on a project that is 5-6 sprints in, I usually don’t bother looking at time burn-down/burn-up charts for the first 3-4 days. Early trends can be misleading, but by the time a third of the sprint has been completed this metric will usually start to show trends that suggest any emergent problems. For new projects or for newly formed teams I typically don’t look at intra-sprint time metrics until much later in the project life cycle as there are usually plenty of other obvious and more pressing issues to work through.

I’ll conclude by reiterating my caution that these metrics are yard sticks, not micrometers. It is tempting to read too much into pretty graphs that have precise scales. Rather, the expert Agilest will let the metrics, whatever they are, speak for themselves and work to limit the impact of any personal cognitive biases.

In this series we’ve explored several ways to interpret the signals available to us in estimated time burn-down and actual time burn-up charts. There are numerous others scenarios that can reveal important information from such burn-down/burn-up charts and I would be very interested in hearing about your experiences with using this particular metric in Agile environments.