One thing I love about studying Agile and Lean methodologies is that we find things that might appear to be non-intuitive at first, but then when looking at the big picture we see that our initial thoughts were sometimes wrong.

For example, one might assume intuitively that if I can get my job done as soon as possible, its a good thing for the entire project or product, right? Well, that is not always true.

A simple way to see proof of this is with something we will call “the penny game”. You may have seen something like this already, maybe by another name or using something other than pennies. Industry experts in Agile software development, like Doug Rose, mention this exercise in documents and training material.

The penny game shows us a couple things that are important to understand:

  • Doing things in small batches can provide value to the customer quicker
  • Eliminating local efficiencies can provide value to the customer quicker

The penny game is a group activity. For the sake of this discussion, I will lay out and explain the scenario of the game in words and pictures. You will see the value described here without needing to actually play the game with a group. But feel free to play with your peers, if you want to see the “proof in the pudding”.

Before we play the game, let’s state some assumptions and parameters:

  • We want to get value (some part of the desired product/service) to the customer as soon as possible. (This should be a primary goal of most business.)
  • There are sequential dependent steps in the process to create the value.

Now, let’s setup the game:

  • For this example, we have 5 participants of the game (the number can be more or less, and greater than 1, but for this discussion I will use 5)
  • The participants sit in a circle around a table, where one participant is first (player-1), then the sequential steps in process proceed clockwise to player-2, player-3, and so on till player-5.
  • Player-5 is the last step in the process, and the output of player-5 is the value which the customer finally sees.
  • Player-1 gets six pennies, laid down on the table. They can be heads-up or tails-up, or a mixture – it does not matter.
  • Each player has a job: flip the pennies and pass the pennies on to the next player. Let’s pretend there is an imaginary customer sitting next to player-5 waiting for the flipped pennies.

The game needs to be played twice, in a slightly different manner each time, and then the outcome is compared.

First, we play the game in this way: Player-1 will flip all six pennies at a normal flipping pace (no need to rush). After all six pennies are flipped, player-1 will push all six pennies at once over to player-2. Player-2 will then repeat the same process: flip all six pennies, then push all six pennies over to player-3. This continues on with player-3, player-4, and player-5, until all of the six pennies are flipped by player-5 and finally pushed to the imaginary customer.

Now, let’s analyze how long all of this took. For the sake of simplicity, I will assume it takes on average about 2 seconds to flip each penny, so 12 seconds total to flip all six, then 2 seconds to push the pennies to the next player, and ultimately to the customer. This means that each worker (player) works for 14 seconds, and the customer receives all the pennies at 70 seconds, as shown below:

First round

Next, we will play another round but in a different way. Rather than flipping all six pennies at once, player-1 will flip only one penny, then pass that single penny onto player-2. While player-2 is flipping that single penny (then passing to player-3), player-1 will flip another penny from the remaining pennies, and pass that penny to player-2, and so on. This means that each player is only flipping one penny at a time, and that multiple players will be flipping their single pennies at the same time. What we have done here is made each batch of work smaller: one penny rather than 6.

Now, let’s analyze the outcome. As shown in the table below, each worker (player) is now working for a total of 24 seconds. However, the customer receives all of the six pennies by the time of 40 seconds, rather than 70 seconds as we saw in round one above. And, the first penny is received by the customer at 20 seconds!

Second round with small batches

Here’s another way to visualize the work and the timing:

Another way to visualize the second round

In this example of the game, by reducing the batch size by one sixth while increasing the time to complete the work of each player by ~71%, the customer receives value (the first penny) ~71% faster than before, and receives all of the pennies ~43% faster!!

Of course, everyone does not work at the same pace and in a real work environment even under best conditions there will be statistical fluctuations in working time. In real world examples, one will need to consider inventory (the amount of pennies to flip at any given time) and work in progress, as well as throughput (speed of work and capacity).

Even with this very controlled and simple example, it makes an excellent and valid point that can be used in real business value streams. Typically this exercise is used to show how small sprints in Agile software development can lead to value quicker for the customer. Can you think of a way you can apply this to your business processes?

Leave a comment