Monday, June 18, 2018

Yesterday’s weather – it’s only an approximation!

Very recently (yesterday to be precise) I published one of my shortest blogposts ever.

What happened? I used an estimation technique from the days of eXtreme Programming called “yesterdays weather.”

The basic idea is that it is rather probable – though not certain – that the future will resemble the past. I started writing regularly for this blog in 2013 and published a post every two weeks except for a time last year when I explicitly decided to let it rest for a while.
So it was a sound expectation that I would continue to publish every two weeks. On Sunday afternoons (European time).
Or so I thought. To add insult to injury I did not only violate agile principles (adjust the plan when the circumstances change), I also violated lean principles.
How so? Well, Of course I don't write all my pieces on Sunday afternoons, but instead on the days in between Sundays and set the the publishing date to Sunday afternoon. And fiddling with the publishing date in blogger (my blogging platform of choice - for now) is quite tedious. So I decided to increase the batch-size and create some inventory of already scheduled blogposts that I would ’only‘ have fill with the contents from my local drive.

Except that it didn't work out like that. I did not create the content in time, and all of the sudden the inventory became a liability. Since I didn't respond to the changed situation and the plan got carried out by bloggers scheduler, this actually went out to the market. Luckily it was only a “lorem ipsum” type of blogpost and not a vital product feature marked “to be defined before production” that went live...

Well, this blogpost from yesterday definitely reminded me, that the lean avoidance of overproduction (one of the seven wastes in Muda#Over-production)) really is a virtue... and that even though past experience is a strong indicator for tomorrows events, we still need to check the current circumstances on a regular basis.

till next time
  Michael Mahlberg

P.S.: To quote George Bernhard Shaw:
“The only man I know who behaves sensibly is my tailor; he takes my measurements anew each time he sees me. The rest go on with their old measurements and expect me to fit them.”

Sunday, June 03, 2018

How technical is lean and agile?

A huge amount of discussions around lean and agile today is about management methods, personal interaction, coaching approaches, team interactions and so on.

And while I completely agree with the notion that “soft skills are the really hard skills” and are absolutely necessary, I still think that some technical excellence is crucial (remember the second page of the agile manifesto, principle 9?).

Many of the things that are present in successful agile teams and that people nowadays try to ‘inject’ into not-yet-quite-as-agile teams could be either cause or effect.

Let’s take the value of trust for example – perhaps people in highly skilled teams trust each other more because each of the team members brings some technical excellence to the table. Or perhaps people show their degree of excellence (including it's boundaries) because of the high level of trust. It could be either way around. Neither of that might be the case if the team is not self selected but made up out of “those who currently don’t have any other project”. Or let's look at sustainable pace – perhaps people in highly skilled teams are able to work with a sustainable pace because the know there limits and know that if the work beyond those limits the quality of their work suffers. And so on.

But back to the question of the technical aspect. Nowadays I often see teams where refactoring is looked upon as a separate activity (In XP-Times it was Red-Green-Refactor every couple of minutes), where people are neither free to choose their own IDE (e.g. because of company standards) nor willing (e.g. because they don't know any other IDEs) and where the command line is considered dangerous.

That’s not how the game was played when the term agile was coined - If you want to be able to quickly react to changes you need technical expertise. And technical excellence. Invest in it. Without technical excellence all the agile management practices might bring some improvement, but in the end those improved situation will be brittle unless serious attention is paid to technical excellence.

Just my two cents for today...

till next time
  Michael Mahlberg

Sunday, May 20, 2018

Kanban metrics made easy - the other kind of pirate metrics.

You may have heard of pirate-metrics in the realm of startups and customer behavior because Acquisition, Activation, Retention, Revenue and Referral gives us the acronym AARRR! which to some sounds somewhat piratey.

But that is not the kind of pirate metrics we’re talking about here. This is about a simple, quick and easy way to gather flow-data by just ‘carving a mark in the tally for every prize won [or in this case: For every day spent].’

The basic idea – as presented for example by Benjamin Mitchell in his Talk at the LKCE 2012, see slide 31 – is to just mark cards with a “tag” for each day that it spends in a certain column. For extremely narrow cadences this timeframe might be even smaller (e.g. half days). Basically it just means you

  1. assign “signs” to the columns (e.g. R = Ready, A = Acceptance test definition, S = Story Preparation, I = Implementation, P = Post processing) (remember to put the 'signs' on the board as well so that everybody can look up the meaning of the tags immediately) and
  2. at defined intervals have somebody go over the board and 'tag' all cards according to their current column.

  3. Use the information gathered by this in Kaizen events, retrospectives and the standup meeting.

Sample Pirate Tags

Sample pirate tags

Sample of pirate tags created in half-day intervals on a (hypothetical and hopefully unrealistic) story card, that spent half a day in ready, one day (two half days) in the definition of acceptance criteria, half a day in story preparation, half a day in implementation and two-and-a-half days in post-processing.

Just a thought: Perhaps you don't need fancy software after all,to start getting quantitative feedback on your work...

till next time
  Michael Mahlberg

Sunday, May 06, 2018

Out of the busy-trap: Don’t call your options backlog

When Scrum was young, one of the objectives was to make sure that the development team was able to work on a fixed set of things for 30 days in a row. (At least that what Ken Schwaber and Mike Beedle wrote in one of the original Scrum Books.) And yes, back then it was 30 days.

A little history

Having 30 days without changing requirements seemed like a very long time for the context in which Scrum –todays most widespread approach to agile– was born. Therefore, a couple of elements were introduced to sustain especially that aspect. The sprint and the notion of the backlog as an artifact are two things that play vital roles in making sure that the objectives for the 30 days really stay fixed.

The sprint has a few attributes that make negotiation between business and development much easier - like a duration, a goal and the whole notion of the fixed subset from the product backlog.

The backlog - especially the product backlog, which used to be quite different from the sprint backlog - contains an ordered list of things that the business (which actually is paying for the music) would like to have. But unless it is in the sprint it is not fixed or committed.

Enter: semantic diffusion

Nowadays many people seem to interpret the backlog as a list of all the things that must be done. And I think must should almost always be questioned. Even the word backlog gives the wrong impression about the requirements – if everything turns out right, the 'backlog-items' are not a burden for the dev team but instead they are options to generate value for the whole organization.

The value stream starts way before the sprint-planning(s)

If we look at the whole value chain from idea-conception to delivery, invoicing and payment, it becomes difficult to extend the concept of a sprint to the ever enlarging group of people. Which is fine, because the sprint was never meant for big groups.
Looking at larger groups of people creating value together, it becomes much more feasible to synchronize those groups via independent cadences and optimize the flow through the whole chain. And once we start looking at the artifact formerly known as ‘backlog’ it sometimes shows that, up to a certain point in time, those backlog-items are merely options – so let's treat them like that (as I wrote a couple of weeks ago.

Naming is essential

And since words have effects, why don't we start calling these things by their names? “We have to decide which options we select” set a different tone from “let’s look at how much of our backlog we can master.”

Make your life easier – treat options as options and only committed items as ‘backlog.’ And perhaps after a while you might be able to drop the term backlog altogether.

till next time
  Michael Mahlberg

P.S.: I find it very helpful to keep in mind that even though the Scrum terminology is almost ubiquitous today, there are only very few teams or projects really implementing Scrum. Product teams who have to deal with support issues, project teams who don't have control over the Product, product owners who only have 2 hours per sprint for their team, scrum masters who serve 5 teams at a time – the list goes on and on.
Given these constraints it pays off to review what we want to achieve if we use lean and agile practices and employ those which actually fit the situation.

Sunday, April 22, 2018

The official way to define a sprint goal...

... doesn’t exist of course.

But please:

“We'll do stories 5712, 3211, 7621 and 3123” has never been a sensible commitment. That’s not why we have sprint goals.

The Scrum Guide states “The Sprint Goal gives the Development Team some flexibility [...]” and “The Sprint Goal can be any other coherence that causes the Development Team to work together rather than on separate initiatives.”

So, if you ask me

“At the end of this iteration department Y will be able to sell product X via channel C” sounds much more like a useful sprint goal. And much more in alignment with the original ideas of Scrum.

IMHO, one of the most important things about the sprint goal is that little word ‘coherence’ - a clear sprint goal helps in setting priorities, aligning team efforts, and communicating with stakeholders.

Therefore, I suggest to use more than a collection of stories to define the sprint goal.

till next time
  Michael Mahlberg

P.S.: Using numbers to drive a business is considered harmful by many people – to quote W. Edwards Deming Quotes

People with targets and jobs dependent upon meeting them will probably meet the targets - even if they have to destroy the enterprise to do it.

Perhaps sprint goals made up of (story) numbers are also a bad idea.

Sunday, April 08, 2018

Do I really have to? On Options and Commitments

Aside from the whole sprint-commitment thing, there is another commitment-issue I tend to have.

People often misunderstand options for commitments

And it can be very liberating to get rid of that confusion.

“I can’t go to that lecture, I already have a ticket for the cinema.” Is the cinema ticket an option or a commitment?

“I can’t go to that conference I’ve already booked flights for those dates.” Are those plane tickets options or commitments?

In their excellent book “Commitment“ Chris Matts and Olav Maassen look into this question in depth, but for now let’s just look at one very important take away from pondering the above questions.

#1: If something is an option or an obligation (a commitment) depends on whether you're buying or selling. The tickets in both cases are options for the person who bought them but commitments for the sellers. The cinema is obliged to show the movie, but I as a buyer have merely bought an option. I can exercise it or i can choose to let it expire. I am not obliged to go to the cinema, I have only bought an option to go there.

#2: Options have a value (and a price) (Almost straight from the book) Different options have different prices. Depending on my perceived value of the option I might be willing to pay the price or not. The option to fly somewhere might be more expensive that option for the movie, but still the question is what I am willing to pay. I am not obliged to take the plane. Thinking about it in that manner means that I did not pay for the flight (if I did I probably would pay when I enter or leave the plane, like with a bus ticket) I paid for the option to take that plane.

To me this way of thinking is quite liberating. Just make sure you know on which side of an option you are. People tend to loose a lot of faith if they were sold options and the other side doesn’t keep their commitment.

till next time
  Michael Mahlberg

P.S.: You can find a draft version of my take on real options on this blog including pointers to the whole background in Chris Matts’ and Olav Maassens’ excellent book and some online resources.

Monday, March 26, 2018

What is a commitment anyway?

Or: The difference between “having committed to something” and “being committed to something.”

This is not about the old story of the chicken and the pig who want to open a restaurant. Even though Ken Schwaber used this adage to illustrate the difference between commitment and involvement in the early days of Scrum, it is no longer part of the canon.

The version history of the scrum guide makes that quite explicit:

“Development Teams do not commit to completing the work planned during a Sprint Planning Meeting. The Development Team creates a forecast of work it believes will be done, but that forecast will change as more becomes known throughout the Sprint.”

Still I see the term “commitment of the team” quite often. In publications and in ‘real life.’

I have to confess, I am even guilty of using it myself from time to time.

Like with many things in the world, the question is how we use them. In this case it is the question of how we use the term – and the concept – commitment?

There is a fine line, but a very important distinction in who does the committing. A while back I heard some General in a movie say that he “committed 20 troops” to some task. In yet another movie a team member explained the success of his team with the fact that “the whole team was committed to the cause.” So does that mean that the 20 people the General committed to the task will feel commitment to the task and thus succeed? Probably not.

And yet the statement “The team is committed to the sprint goal” is syntactically the same wether the team has committed to the sprint goal (e.g. each team member bought into it) or has been committed to the sprint goal (e.g. some higher authority spoke on behalf of the team without their consent).

till next time
  Michael Mahlberg

P.S.: But then again you might want to consider exchanging iteration based approaches with a flow-based concept and cadences and then you might consider “Department Y will be able to sell product X via channel C” as an idea for a MMF (Minimum Marketable Feature(set))

Monday, March 12, 2018

This is not an Epic

This is a rant...

In a “recent” post Mike Cohn outlines some of the misunderstandings around the the terms «epic», «user story» and «theme».

This article is actually only “kind of” brand new - it is from 2011.

But thanks to the prevalence of Tools and Process over Individuals and Interactions that has been brought to us by tools like Jira for more than ten years now, it seems to me that it is a good idea to look at a few key points again.

For example Mike says:

There's no magic threshold at which we call a particular story an epic. It just means "big user story."

So, sorry folks: an epic does not group a bunch of requirements that do not deliver value on their own together. According to Mike’s old post an epic simply is a story that “[one] didn't get the chance to break […] down into stories that are […] small enough […].”

That’s why it is such a good idea (at least IMHO) to do whatever you like with that “Epic” thingy in Jira – use it to mark other stories, use it as a theme (see Mike’s post for a short explanation of that) use it to signal states if you don’t have a Jira admin in your team etc.

But whatever you choose to do, don’t do functional decomposition by making your epic an enumeration of sub-functions that only deliver value if they are all implemented together.

...end of rant.

till next time
  Michael Mahlberg

Sunday, February 25, 2018

What happens left of the Scrum-board?

In the early days of Agile, Agile was very much about customer collaboration and concepts like the on-site customer were at the core of Agile. Nowadays, most on-site customers (actually a term from eXtreme Programming) are some derivative of Scrum’s Product Owners and most instances I have seen are far from the role Ken Schwaber and Mike Beedle described in their seminal work on Scrum in 2002.

Things have changed over the years, and nowadays a product owner (PO) in many places, especially at enterprise scale, is someone who devotes ‘a couple of hours’ each week to support ‘some team’. And even though this is definitely an anti-pattern from my point of view, it still is a reality we have to deal with.

The Agile Manifesto states quite clearly that “Business people and developers must work together daily throughout the project.” (4th principle) and one the biggest benefits of agile approaches in my experience is that they enable projects to start developing (and delivering!) before “all” the requirements are discovered. A huge part of this approach has to do with the fact that the whole team works on requirement discovery and the honing of the product vision.

But those teams are rare.

And while process-frameworks like Scrum – and the secondary literature around it – provide a lot of helpful guidance on how to deliver the solution there is very little said about the process of requirements discovery.

So I would like to challenge you to a little experiment.

  • Have a board “left of the board”
    • Instead of just having a backlog and backlog refinement meetings where requirements magically appear try to build a board for this part of your process as well!
    • Have just a few columns like “idea”, “described”, “accepted”, and “ready for planning” – whatever fits the real way of work at your place.
    • And here is another idea: Unlike on the Scrum board, perhaps here it is not necessary for all items to reach the stage - perhaps it is good if some ‘die’ on their way to the iteration planning.
    • And then observe... What happens on this board?
      • Do items ‘starve’ in some states?
      • Are there items with different speeds?
      • how many items ’make it’ to the next stage?

Who knows - you might learn a thing or two...

till next time
  Michael Mahlberg

P.S.: Inspired by Discovery Kanban of course... ;-)

Sunday, February 11, 2018

Why I hate "Inspect and Adapt"

Because more often than not, people don’t.

They way I grew up with agile, one of the basic tenets of all agile approaches was the notion that there is no prescribed ‘right’ process, but you have to do what it right at this point in time. There even was a lengthy discussion whether the approach should be called ‘agile’ or ‘adaptive’ when the agile manifesto was created.

Now I see people ‘doing agile’ all around in manners I sometimes fail to understand. And I hear complaints that the agile stuff doesn’t really work. And more often than not, the explanation I get is along the lines of “But agile says ‘inspect and adapt’ and we adapted.”

IMHO one of the best answers to that was written by Ron Jeffries and is called We tried baseball and it Didn’t work.

And what I see quite often when I hear that teams ‘adapted’ the approach they try to use, is exactly that – they adapt without doing the inspection of the real thing first. Go ahead - read it! :)

So if you want to use the inspect and adapt approach, please make sure that you have something to inspect before you adapt it.

till next time
  Michael Mahlberg

Sunday, January 28, 2018

How to single-handedly run a change initiative

That’s actually quite simple - you don’t!

A common way to facilitate change is by having change agents, and that actually seems to be exactly what is needed to make change happen. Yet the role of these change agents can vary tremendously – from someone requoting the initiative’s vision statement to everyone who wants to listen, to an agent of the workforce to seek out the best possible solution for the future.

Don’t get me wrong, I do love the idea of the “change agent” per se. I just found out that the name has so many meanings that it becomes either meaningless or extremely context-dependent. For my work – helping organizations adapting new ideas – I found that a change approach with a clear direction is quite helpful and very of a very small number (sometimes 1) of external consultants or coaches is brought in to facilitate this change.

Even though we would like as many people as possible to take an active part in the formulation of the new direction, most of the time that change needs some external insights that are not available from inside the system. As Jerry Weinberg would say: “The Fish is always the last one to see the water.”

So the kind of change agent we need in this case would be one who is amplifing the external influence and is the kernel of the internal change. Still not someone left to his own devices, but rather someone who acts in both directions as a focal point for the change. Multiplying the view from the outside and channeling the (numerous) questions that will arise from the inside. And while they will need to question the outside source often in the beginning, as time passes they will gain more and more knowledge – as will the whole organization – and will be able to drive more and more of the change from the inside.

There is a word in German that we use to call people who amplify the impact of others, we call them "Multiplikatoren" which would roughly translate to “Multipliers” in English. Due to an unexpected chain of event we ended up with the old English word “Multiplicator” to describe the role in a recent project.

I kind of like the word by now - the use of uncontemporary language makes it obvious that we don’t really mean “multiplier” in a mathematical sense and it still conveys the basic idea.

And IMHO having this kind of change agent is one of the key success factors for change inititives - lean, agile or else.

till next time
  Michael Mahlberg

Sunday, January 14, 2018

Getting to higher performing teams – controlling circumstances or training people?

Do you make jobs easier to do, or do you help people to become more capable?

Effectiveness and efficiency often come in conflict when a goal has to be reached and deciders start to feel pressure. But as Peter Drucker famously said:

“It is fundamentally the confusion between effectiveness and efficiency that stands between doing the right things and doing things right. There is surely nothing quite so useless as doing with great efficiency what should not be done at all.”

But even if we are able to look at obstacles through this lens, and focus on the effective things, there is still the question of how to best do the really necessary things.
In today’s fast paced VUCA-World (Volatile, Uncertain, Complex, Ambiguous) most of the things we try to accomplish imply some kind of “gaining knowledge”. And that is where we can see a huge difference between players who are in the game for the long run, and those who are more focused on quick gains.

Let’s assume we have a new complex piece of equipment - be it software, hardware or something else. Learning to work with this new asset requires learning and education. And this is where we come back to the original question - “Do you make jobs easier to do, or do you help people to become more capable?”

The more efficient approach – and probably even the more effective approach – would be to train a few people to operate the equipment, and let them create procedures for the rest of the staff on how to use it. (Think e.g. “creating build scripts for others” in a software engineering context)

But here comes the kicker: as Jerry Weinberg once said “The more adapted we are, the less adaptable we are.” Being less adaptable means being less capable of responding to change.

So having these highly optimized processes makes the jobs of the other people easier (sometimes much easier) – but it takes away from the capability of the organization as a whole. A different approach would be to teach all the people affected how to operate the new equipment, and just have the specialist handle the initial (and perhaps subsequently necessary) research and education. The latter approach would result in a much more capable organization. Of course, after the organization has learned how to best use the new equipment it can still be – and often is – a smart decision to have specialists who know the equipment even better than the rest.

‘till next time
  Michael Mahlberg

P.S.: To give credit where credit is due: David Anderson mentioned the concept of “controlling circumstances vs training people” while we were working on the KMM (Kanban Maturity Model) – I just picked it up and tried to translate it to my own working environment

Sunday, December 31, 2017

Think “executable process visualization” instead of “task-board”

A lot of the boards I see in offices nowadays are called Kanban-boards, even though they are actually more task-boards. And while often that is okay there are some advantages that we’re missing out on when we settle for task-boards.

Why exactly do we do Kanban boards?

There is a multitude of reasons to introduce Kanban boards, but one of the main goals might still be to visualize the workflow. On the other hand visualizing the workflow can hardly be a means in itself. One of the ends the visualization can help to achieve is clarity. Clarity about what we’re really doing. Clarity about the state we’re in. Clarity about the state the work is in. The ‘last workflow you’ll ever need’ (todo-doing-done) doesn’t really provide much help towards this end.

Accept reality

Modeling the real workflow does help. While preparing a talk, a friend and colleague of mine, came up with what I think is a great metaphor. He called the Kanban board an ”executable process visualisation.”

And once we start to think about the board as an “executable process visualisation” this metaphor turns out to be quite helpful in detecting differences between our model and reality. Let’s assume we have some kind of daily standup and talk about the work items on the board. Now, as soon as we find we have to explain that the ticket (the work item’s representation) is still in the same place, but work has progressed to a different state, this is a strong indication that our model does not quite reflect reality. On the other hand, if we move our ticket, but the work item actually still is in the same state, this might indicate an overly complex model that needs to be simplified to reflect reality.

Talk about the way you work

The great thing about having an “executable process visualization” is that talking about the model becomes much closer to talking about the work and vice versa. “But I thought that would be the first thing to do” becomes a question of “In which column does it happen? Can we make that explicit?”

This way the visualization becomes a powerful tool to enable substantial discussions and continue evolving the way you work from there.

till next time
  Michael Mahlberg

Sunday, December 17, 2017

It’s a pull system – not “work on whatever you like”

In some circles, the term “Pull-System” has become a synonym for “My boss doesn’t tell me what to do, I can decide myself.” For me this completely ignores the fact that the term refers to a system and it’s properties, not to the way people in that system can behave.

Let’s assume a simple workflow consisting of four states:

| Ordered | Design | Accept | Done |
|         |        |        |      |
|         |        |        |      |
|         |        |        |      |
|         |        |        |      |

When we push items into the system they will pile up in the state before the bottleneck in the system. This might look like this:

| Ordered | Design | Accept | Done |
|         |        |        |      |
|  [ ]    |  [ ]   |  [ ]   |  [ ] |
|  [ ]    |  [ ]   |  [ ]   |  [ ] |
|  [ ]    |  [ ]   |        |  [ ] |
|         |  [ ]   |        |  [ ] |
|         |  [ ]   |        |  [ ] |
|         |  [ ]   |        |      |
|         |  [ ]   |        |      |

In this case “Accept” seems to be the bottleneck. So whatever you do the system will not be faster than the speed of the “Accept” column. No amount of “pushing” work into the system will make it faster. On the contrary - the more work piles up in the “Design” column, the longer it will take for new items to get through the system.

We don’t know yet how much work is completed, so lets make that visible by putting an “x” on completed items

| Ordered | Design | Accept | Done |
|         |        |        |      |
|  [x]    |  [ ]   |  [ ]   |  [ ] |
|  [x]    |  [ ]   |  [ ]   |  [ ] |
|  [x]    |  [x]   |        |  [ ] |
|         |  [x]   |        |  [ ] |
|         |  [x]   |        |  [ ] |
|         |  [x]   |        |      |
|         |  [x]   |        |      |

Looks like 5 items in the “Design” column are just waiting to be processed. (Items in the “Ordered” column are always done, in the example there is no doing in the “Ordered” column). Pushing another Item into this system will only increase the amount of work not done - like this:

| Ordered | Design | Accept | Done |
|         |        |        |      |
|  [x]    |  [ ]   |  [ ]   |  [ ] |
|  [x]    |  [ ]   |  [ ]   |  [ ] |
|  [x]    |  [x]   |        |  [ ] |
|  [x]    |  [x]   |        |  [ ] |
|  [x]    |  [x]   |        |  [ ] |
|  [x]    |  [x]   |        |      |
|         |  [x]   |        |      |

One simple way to convert this system to a pull system would be to limit the number of items per column - for example like this. (We’ll ignore how to come up with these numbers for the moment that would be the topic for another post)

| Ordered | Design | Accept | Done |
|   (3)   |  (3)   |   (2)  |      |
|         |        |        |      |
|         |        |        |      |
|         |        |        |      |

Having these limits on the columns, the system could never exceed the following situation – Non-withstanding the question whether the work items are done or not:

| Ordered | Design | Accept | Done |
|   (3)   |  (3)   |   (2)  |      |
|         |        |        |      |   
|  [ ]    |  [ ]   |  [ ]   |  [ ] |
|  [ ]    |  [ ]   |  [ ]   |  [ ] |
|  [ ]    |  [ ]   |        |  [ ] |
|         |        |        |  [ ] |
|         |        |        |  [ ] |
|         |        |        |  [ ] |

Filling this system with done work and moving excepted work into the next done column we might find the following situation

| Ordered | Design | Accept | Done |
|   (3)   |  (3)   |   (2)  |      |
|         |        |        |      |   
|  [x]    |  [ ]   |  [ ]   |  [x] |
|  [x]    |  [x]   |  [ ]   |  [x] |
|  [x]    |  [x]   |        |  [x] |
|         |        |        |  [x] |
|         |        |        |  [x] |
|         |        |        |  [x] |

And even though it is not yet visible to the naked eye this system already is a pull system if we add the simple rule that as soon as there is less work in a column than allowed by the limit we fill the column up to that limit.

Step one:

| Ordered | Design | Accept | Done |
|   (3)   |  (3)   |   (2)  |      |
|         |        |        |      |   
|  [x]    |  [ ]   |  [ ]   |  [x] |
|  [x]    |  [x]   |  [x] ---> [x] |
|  [x]    |  [x]   |        |  [x] |
|         |        |        |  [x] |
|         |        |        |  [x] |
|         |        |        |  [x] |

Step two:

| Ordered | Design | Accept | Done |
|   (3)   |  (3)   |   (2)  |      |
|         |        |        |      |   
|  [x]    |  [ ]   |  [ ]   |  [x] |
|  [x]    |  [x] ---> Pull  |  [x] |
|  [x]    |  [x]   |        |  [x] |
|         |        |        |  [x] |
|         |        |        |  [x] |
|         |        |        |  [x] |
|         |        |        |  [x] |

Step three:

| Ordered | Design | Accept | Done |
|   (3)   |  (3)   |   (2)  |      |
|         |        |        |      |   
|  [x] --->  [ ]   |  [ ]   |  [x] |
|  [x]    |  [x]   |  [ ]   |  [x] |
|  [x]    |  Pull  |        |  [x] |
|         |        |        |  [x] |
|         |        |        |  [x] |
|         |        |        |  [x] |
|         |        |        |  [x] |

Step four:

| Ordered | Design | Accept | Done |
|   (3)   |  (3)   |   (2)  |      |
|         |        |        |      |   
|  [x]    |  [ ]   |  [ ]   |  [x] |
|  [x]    |  [x]   |  [ ]   |  [x] |
|  Pull   |  [ ]   |        |  [x] |
|         |        |        |  [x] |
|         |        |        |  [x] |
|         |        |        |  [x] |
|         |        |        |  [x] |

which leaves the system in the state where there is an open pull request to pull more orders from outside the system.

Looking at pull systems this way shows that the term "pull" does not imply that in each pull system individuals can randomly choose what they want to do next, but describes one of the properties of the system itself. The level of autonomy –and how much each person is able to work on the stuff they would like to work on– can also be a property of the system, but it is a different property.

Having "pull" brings numerous advantages: better predictability, a better balance between throughput and utilization, and a more sustainable workload.

till next time
  Michael Mahlberg

P.S.: Of course this topic is way more complicated than outlined here and the relationship between limiting WIP and pull is not quite as one-dimensional as pointed out by Donald Reinertsen himself on Twitter. There is also a nice write-up on the topic from FactoryPhysics when it comes to the more intricate details of this matter.