Sunday, May 16, 2021

The difference between acceptance criteria and the definition of done

When it comes to building things, we often want to know when it's really done. Two terms have gained popularity over the last couple of years within the realms of software development and other areas that use spillover ideas from the agile movement. These two concepts are acceptance criteria and the definition of done. Unfortunately those concepts are often mixed up which leads to subpar results.

The distinction can be pretty short: the definition of done (DoD) is a property of a process-step, while acceptance criteria are properties of a request for a capability. However, the question remains: why does it matter?

Let’s clarify some terms

I intentionally used the uncommon way to refer to a requirement as “a request for a capability“ to avoid notions such as story, requirement, feature, epic etc. Sometimes just saying what we actually mean instead of using an overused metaphor can make things much clearer. For now I will call “requests for a capability” simply work items, since that term has –at least up until now– very few connotations.

Where does the definition of done come from, and what does it mean?

To be perfectly honest I don't exactly know where the phrase came from. (I'll come back to Scrum in the postscriptum below) I've heard jokes about “If it works on your machine, you're about 80% done” and “do you mean done, or do you mean done done“ since the 80s. So obviously it's not really a new phenomenon that it's hard to tell when something really is done.

The term became more formalized, especially in the Scrum community between 2005 and 2011, when “Definition of done” became a top-level topic with it’s own heading in the scrum-guide. In this context the definition of done is the sum of all quality requirements a work item has to fullfil to be considered “done.”

If we look at it from a process perspective, this is a policy all work items have to comply with before they can move from “working on it” to “done.”

where the DoD applies

Who brought us acceptance criteria, and why?

Again, the origins are lost in the depth of time. At least to me. But the first experiences I had with them as a part of agile software development were back in my earlier XP-days, around the turn of the century.

At that time it was “common practice” (at the places I was around) to put requirements on cards. And when the time came to find the answer to “how would you know that this item was done” with the onsite customer, we just flipped over the card and jotted his acceptance criteria on the back of the card.

Those acceptance criteria hardly ever included anything technical, let alone any requirements regarding the documentation or in which source code repository it should reside. Those things were captured by our working agreements. In a section that nowadays would be called definition of done.

The acceptance criteria usually were things the customer would be able to do with the system once the requirement had been implemented. Someting like: “I can see the list of all unbooked rooms in an area when I search by zip code“ as one acceptance criterion for a card called “find available rooms” in a booking system.

Remember that these were the days of real on-site customers in a high trust environment and stories were written according to the CCC idea of Card – Conversation – Confirmation. Therefore it was quite okay to have such a vague acceptance criterion, where there was no up-front definition of what a “search by zip-code” actually means or how the “unbooked rooms” state had to be determined.

Nowadays these acceptance criteria are sometimes formulated as BDD or ATDD style scenarios and examples, wich allows for very concrete and specific acceptance criteria (but without enforcing them).

Now, what is the difference between acceptance criteria and the definition of done?

After we defined the terms, the terse explanation from above “the definition of done (DoD) is a property of a process-step while acceptance criteria are properties of a request for a capability” might actually make sense.

So, the «defintion of done» is a rule that applies to all the work items in the system and is a policy on a very specific edge between two columns on a board, namely the edge separating the “done” column from the one right before it. In contrast, «acceptance criteria» give the answer to the question “what functionality does the system have to provide to consider this work-item to conform to the customers expectations?”

And so, both are necessary and neither is a replacement for the other. Acceptance critery go with work items, and the definition of done goes with the system.

till next time
  Michael Mahlberg

P.S. In most real life settings, processes tend to have more policies than just the definition of done.

And some of them describe the expections at process boundaries. If you use the Kanban method to model these processes you would naturally make these policies explicit as well, like I described in an earlier post.

P.P.S.: Scrum didn't start of with the now prominent Definition of Done as a first class citizen.

In the original books, that used to be literally required reading for aspiring scrum masters in 2005 –Agile Software Development With Scrum[ASD] and Agile Project Management with Scrum [APM]– there is “Done” on the same level as “Burndown”,“Iteration”,“Chicken” and “Pig" [APM, p141] and no notion of "Definition of Done" in either of the books.

Even in the Scrum Guide from 2010 –one year before the DoD moved up and got its own headline– there are paragraphs like

If everyone doesn’t know what the definition of “done” is, the other two legs of empirical process control don’t work. When someone describes something as done, everyone must understand what done means.

But still not yet quite the now seemingly well established term “Definition of Done” that we see today.

Sunday, March 14, 2021

Options can be expensive -- not only at the stock market

What do you actually get, when you buy a cinema ticket? (In those ancient times when cinemas were still a thing)

You buy yourself an option. The right --but not the obligation-- to execute an operation at a later time. In this case the right to watch a certain movie at a certain time.

The cinema, on the other hand, sells a commitment. They are (to a degree) obliged to actually show that specific movie at the stipulated time. If we look at it like this, it is a considerable investment the cinema promises, in exchange for those couple of bucks your option costs.

And while it is often thought to be helpful to think in options, it is also almost always important to make sure that you're on the right side of that transaction.

Where's the problem with options?

What does that mean for our day-to-day actions? If we hand out options too freely, we quickly end up in a quagmire of "maybes" that is hard to get out of. As I mentioned in an earlier post, the whole thinking around real options in the way Olav Maassen and Chris Matts describe in their book "Commitment", is quite fascinating and well worth a read. But for today let's just look at one thing we don't do often enough, when we use options in our personal lives.

We tend to offer options without an expiry date. And that can leave us with a huge amount of commitments, and very few options left for ourselves. One of the prime offenders here is doodle (or similar meeting planners) and the way they are often used these days. Just the other day I got a doodle poll for 58 30-minute slots stretched over two weeks. Scheduled in about six months from now. And the closing date for these options was meant to be set three <sic> months in the future. So worst case, I would have committed to keep 29 hours blocked for three months. Which would have left me unable to actually plan anything for those weeks in the next three months.

Of course doodle only makes this visible – it happens all the time. Look at this scenario:

  • We could go on vacation either at the beginning of the summer break or at the end

  • I could renovate the shelter either in the beginning of the summer break or towards the end

  • Our kids could go on their "no parents camping weekend" either in the beginning of the summer break or at the end

For as long as you don't decide the first one of these, those options create a deadlock.

And the situation makes it almost impossible to actually decide anything related to the summer break as well, for that matter.

Set an expiration date to ease the pain

The solution is simple, really. But it takes some uncommon behavior to apply it. Let's look at the way the stock market handles options. Options at the stock market have a window of execution and an expiry date. Once that date has passed the option can no longer be converted. Merely adding this expiry date, already mitigates the risk of too many open ended options even for the side which holds the commitment end of it.

A lot of options that we encounter have this attribute of an expiration date in one way or another: When we get a quote for some repair work for our house, car or even bicycle, it usually says "valid until." The same is true for business offers, medical quotes, and almost everything we consider as "business."

Amending the options we hand out with expiration dates, even if it is not in a formal business setting, may feel a little strange at first. But it makes life so much easier. Whether it's toward a colleague, a significant other, friends or even yourself. Reducing the amount of open options also reduces the number of times you have to say "I don't know yet, I might have another engagement."

till next time
  Michael Mahlberg

Sunday, February 14, 2021

How to do physical {Kanban|Task|Scrum} boards virtually

As I’ve mentioned earlier most of the time it is a good idea to start visualization with a physical board. And very often it is a good idea to stick with that. For all the reasons that make it worthwhile to start with it.

One of the biggest advantages of a physical board is the one thing that command and control organizations perceive as it’s biggest drawback: A physical board knows nothing about the process.

The fact that the physical board knows nothing about the process forces the people who use it, to actually know about their working agreements. And to negotiate them. And to make them explicit in some way. Well, at least if the want to remember the gist of their long discussion from Friday afternoon on Wednesday morning.

As my esteemed colleague Simon Kühn put it all those years back: The intelligence is in front of the board.

But we’re all working remote now

Now, that we‘re not in a shared office space anymore, real physical boards are hard to do, aren’t they? Well – yes and no. If you look at the important advantages of physical boards, they are easy to replicate with today’s electronic white board solutions.

Whether you use use google drawings, miro, or conceptboard –to name just the ones I’m familiar with– is mostly a question of taste and, more importantly, legal and company policy considerations.

Using a simple collaborative whiteboard enables people to have most of the advantages they can have from physical board, while retaining the advantages of remote work.

What are the big advantages of a physical board?

A physical board can easily be changed by everyone. Just pick up a marker and draw something on it. The same is true for electronic whiteboards. In both cases it is a good idea to also have a talk with your colleagues to make sure they are okay with the additional (or removed) thing you did to the board.

One could say “individuals and interaction over workflows (process) embedded somewhere in a ticket system (tool)” – just to reiterate the first value pair from the Manifesto for Agile Software Development as an argument for “physical” boards.

Physical boards have extremely quick iterations. Trying out whether a new policy makes sense takes just a pen, a sticky note, a quick discussion and a couple of days (sometimes only hours) to see if it works. Conversely, with ticket systems even proposing a change to the admins often takes weeks and needs a predefined concept and sign-off. Not exactly agile. But with electronic whiteboards you can do just the same things you would do on a physical board. Which is why they provide tremendously quick feedback loops.

And as Boyd’s law of iteration says: speed of iteration beats quality of iteration.

If you decide to add a new status on a physical board or add new meta-information on a ticket, you don’t have to migrate all the old tickets. And you don’t have to coordinate that meta-information with the names of the meta-information of all other projects in the organization. Another huge an advantage of physical boards over ticket systems. And you can achieve the exact same independence with electronic white boards.

But where do the details go?

When I have these discussion in real life, I usually get a couple of questions about the details. Let’s look at two of them.

Q: On a physical board I used to write my acceptance-criteria on the back of the card. I can’t do that with an electronic whiteboard.

A: True, but then again you can put a link on the card on the electronic whiteboard and that can point to almost any place you like. For example a wiki-page that contains that additional information.

Q: But if I use a dedicated bug tracker (the origin of Jira) or any other ticket system I have all those nifty fields for details.

A: But do you need them on the card? Wouldn‘t they better be put on a documentation page?

My general advise here: put only meta-data on the card and all the other information in appropriate systems like a wiki. This also gives you the opportunity to put the information where it belongs in the long run, instead of putting it on the perishable ticket. On the page related to the ticket you can just link to or include that central information.

But what about metrics?

One of the things that gets lost with the ”physical” board is the automated transcription of relevant data for statistics. And I have to admit that this is a real disadvantage. With an electronic whiteboard you could either write a little plugin that tracks the movement of the cards or do a very strict separation of concerns and use different tools for different topics.

A word of caution – writing that little tool for the electronic whiteboard might not be that easy, after all. And even if you were going to do that eventually, it would be a good idea to start by collecting the metrics manually.

Either way: if you start with the metrics that you really need now and create your own tools for those –based on spreadsheets or databases, after all you’re in the software development business— you have a huge advantage over the metrics provided out of the box by many tools: you actually know, what the data means.

And some of the most important metrics are actually easy to evaluate and some of them even easier to capture.

Just give electronic whiteboards a try – if you adhere to the same ideas and first principles that guide your usage of a physical whiteboard you should reap almost all of the same benefits and get a couple of helpful things like links on the cards and enough space for dozens of people to stand in front of the board on top.

till next time
  Michael Mahlberg

Saturday, January 30, 2021

The benefits of continuous blocker clustering

If you manage your work by using some kind of visualization, the chances are high that you also visualize your blockages.

One of the most common visualizations is some kind of task board that represents the subsequent stages work items go through. Assuming you have such a board it can be quite helpful to visually mark which of those work items are currently blocked. This enables the whole team or organization (depending on the scope of your board) to see where work is stuck and to do something about it.

Usually (in the physical world ) these markers had the form of post-it notes in a different color and denoting the reason for the blockage. If you add just a little bit additional information, these blockers can be utilized to identify typical hindrances in the flow. Information you might want to gather are a reference to the original work item this blocker was attached to, the time(stamp) the blockage occurred and the time(stamp) it was solved.

In the Kanban community there is a practice known as “blocker clustering” where all involved parties come together at specific points in time and cluster these blockers according to things that stand out once you try to sort them and categorize them.

Blocker clusters can be either things like “Waiting for department «X»” or “Problems with system «Y»” or something completely different like “discovered missing information from phase «Z»” – that really very much depends on your individual environment. And usually these blocker clusters change over time. And so the should.

Now, here’s an idea: why only do this at certain intervals? Just as pair-programming in software development could also be called continuous code-review, the practice of blocker clustering could be done each time a blocker is resolved.

Granted, this wouldn’t make the big blocker clustering superfluous. After all that is where all concerned parties can decide whether they want to treat the resulting blocker clusters as special case variation –where one-off events caused the blockage– or common cause variation, where the blockage is caused by things that happen “all the time”.

The distinction between these two kinds of variation in the flow is important. One of them, the special case variation, hast to be handled on a case by case basis, whereas the other one is a great opportunity for structural improvements in the way you work.

And this is where continuous blocker clustering really can make a difference. Instead of waiting for the big blocker clustering, people come together and decide into which blocker cluster the blocker goes as soon as it is finished. This doesn’t have to happen in a separate meeting.

After all, the blocker (and the way it got solved) would be announced in the next board walk anyway. Which is also a good place to have this discussion.

And once you do continuous blocker clustering, you can have additional agreements like for example: If there are more than five new blockers in a category you can immediately (or at least very shortly afterwards) come together to discuss whether you want to treat this as a new common cause variation and whether you see a chance to improve your way of working together to address this new common cause. The number five is just an arbitraty number, depending on things like number of people involved, throughput etc. your numbers will differ.

You could also have an agreement to hold such a meeting whenever you have collected five blockers that you couldn’t categorize into a blocker cluster in less than 2 minutes and were therefore grouped under “uncategorized”. (Another working agreement.) The opportunities for demand driven improvements through this approach are vast.

The same basic idea is behind the concept of signal-based Kaizen meetings, that happen whenever specific –agreed upon– circumstances trigger the need for improvement and invoke a spontaneous get-together of the involved parties. Opposed to having only improvement meetings at fixed intervals this makes for much tighter feedback loops and thus enables quicker improvement.

till next time
  Michael Mahlberg

(Special note for people who rely solely on jira: It is a bit hard to implement this is an easy way in jira, but it is possible. And also helpful. But it does include some creative use of fieldvalues, some JQL-Fu and some dedicated Jira-boards. Keep in mind that Jira-Boards are nothing more, and nothing less, than a visualized database query. There’s a lot of power in that, once you start moving beyond the pre-packed solutions.)

Sunday, August 09, 2020

Bringing Agile to non-IT work... those who don't remember history are doomed to repeat it

People tend forget that many of the agile approaches borrowed heavily from the Toyota Production System and its relatives, commonly known under the umbrella term "Lean."

These days we're experiencing an interesting development. People try to bring things they perceive as "typical agile practices" to non-IT work. For knowledge workers --a term coined by Peter Drucker in the 1960s-- this might perhaps be a valid approach. Even though I doubt it. For non-knowledge-worker work on the other hand, I would like to point out what happened here. Approaches taken from the Lean context of shop-floor management and vehicle design, related to continuous improvement and optimizing the flow of work, were translated into a very different environment -- that of software development. And even the considerable body of knowledge from other fields of expertise that is at the foundation of agile was put into a very specific context here. Actually, the so-called "agile manifesto" is called "Manifesto for Agile Software Development" and thus very specific with regards to the domain it targeted. So nowadays, when people try to "apply Agile to non-IT situations", they basically take the adaptations that have been made to non-IT approaches to make them helpful in Software Development and try to re-apply what's left of them back to non-IT work. Of course the original non-IT approaches have also evolved since the days that --just to pick an example-- Ken Schwaber and Jeff Sutherland read 1986 paper "The new new product development game" (sic!), and took parts of those ideas as a foundation of their own agile approach (Scrum). Hence it seems kind of silly to me to derive ideas for modern ways to organize non-IT work from the spin-offs from more than two decades ago instead of going directly to the source.

Of course sometimes re-applying the stuff we learned from agile software development actually works, but I think going directly to the source is a much better idea. Perhaps instead of trying to derive the helpful approaches non-knowledge-worker work from the shadows they cast unto the walls of the Agile world --to paraphrase Plato-- it might be a good idea to look at the origins and try to understand the original approaches to non-knowledge-worker work. Of course, oftentimes non-knowledge-worker work was simply called "work", back in the day. Directly adopting from approaches like Lean (from the 1950s) or New Work (which originated in the 1970s) might be an approach to improving work that avoids the 'Chinese-whispers' effect of the indirect approach via "Agile."

To end on a more positive note: the Kanban method is a great example of an approach that targets the challenges of the (non-it) knowledge worker and brings ideas from Lean and similar fields into a new context. And even though many people use the Kanban method in the realm of IT, it has many equally --if not more-- effective applications outside of IT. Maybe that's because the Kanban method avoids the triangulation via the older agile approaches and builds directly upon the common ancestors. I guess that is one of the reasons why David Anderson called the Kanban method "post-agile" even back in 2010.

till next time

  Michael Mahlberg

Sunday, May 24, 2020

Error: Customer unavailable! How do you manage flow now?

It’s Wednesday morning, you try to get an appointment with the stakeholder who is the most important customer for a work item that your team started to work on on Monday. And now you find out that they’re out of the office for the coming two weeks.

Now what?

You and your team invested 2 days already (for a 7 people team that would represent 14 person days of effort), and you all would really like to work on the topic.

After some inquiry about the requested feature it becomes clear that no one else knows what the requirements on this work item really are and now you’re faced with a tough decision: mark this card as blocked and become ‘idle’ as a team, or abandon the card (discard it) and let the customer bring up the topic later again?

There are drawbacks to both approaches –after all the situation is bad to begin with– but both follow the mantra to “accept reality” and are way better than following the wiscy approach where you start defining the result (e.g. by programming) without even knowing the requirements.

Let’s look at the implications of each approach.

For the following assume that we manage our work using ideas from the Kanban method and thus have the flow of our work visualised on a board including WIP-targets.

Option 1: put a blocker on the card if the customer is unavailable

Putting a blocker on a card is the normal way to make it visible to everyone that there seems to be no way to progress on the work represented by that card in a sensible way. At least if you apply the Kanban method. If your WIP-Target (mostly known as WIP-Limit) was already honored this creates a tremendous amount of slack for the team that worked on that card. In most cases more than you actually want and more than is wise from an economic point of view. But it reflects reality. If the relevant stakeholder is not available for an extended period of time this could be really expensive.

The important point here is that blocking the card fosters learning inside the system. People might come up with policies to make sure that the customer is actually available for before starting to work on the work item. Or they might come up with completely different ideas on how to mitigate this situation. Remember: Documentation isn’t bad per se.

Option 2: discard –or abandon– the work

On the other hand there is always the option of starting something new. In a system with a known capacity that usually means abandoning the old work – after all there are good reasons to limit the work in progress in a system. Amongst other reasons, allowing more work in has a very clear and negative impact on the lead time for the system as a whole. Discarding the work doesn’t necessarily mean that all the work already put into this item will be lost. It just means that the work item has to start its journey again from the far left side of the board and it might even take a couple of replenishment meetings (where stakeholders decide wich item to commit into the system) before work is started again. Some of the work will probably have to be redone because the world will have changed by the time work on that item again.

Here the systemic aspect is that discarding or abandoning a card fosters learning outside the system. Especially upstream, at the customer’s end. Customers might come up with the idea that it is a good idea to have more than one person who knows what the reasoning behind a requirement is. Or they might develop other smart ideas on how to handle this. Remember: there once was a whole body of knowledge called requirements engineering.

Either way: it is a chance for learning

Both approaches offer a chance to improve the system. While the former is targeted more at the system itself, the latter is target more towards the customer interface. Both are legitimate ways to “accept reality” and thus are way better than the alternative: wishful thinking and hoping you will guess the customer’s needs correctly.

till next time
  Michael Mahlberg

Sunday, April 26, 2020

Handling recurring work - some options from Lean and TPS

As someone who draws from the Kanban Method and its Lean and TPS ancestors when supporting change in organizations I regularly come across the question of “how to handle recurring work?”

And while neither the Kanban Method nor I have definite answers there are some options from Lean and TPS that can be integrated nicely into the workflow of 21st century knowledge workers.

I originally got the basic idea to adapt Kamishibai boards (see below) from @LukasDonSchmidt and I would have preferred to just link to a blogpost of his, but unfortunately I can’t find that out in the wild. Yet. (Didn’t you intend to write something, Lukas?)

Capacity allocation and recurring work

Assuming that you visualized your work using some kind of board and you use WIP-targets to manage flow, there is one challenge (amongst many others) that often arises. Small, recurring units of work that “need to” interrupt the flow of the big main work items. In an ideal world we might just strive for the knowledge worker’s equivalent to single-piece flow, but in the real world that is not always attainable or even feasible. To take a small business, non-IT example: the big Work Item might be an essay that needs a week to finish, and the small items could be fetching the mail and paying invoices.
One approach to handle this is to combine the concepts of different swim lanes for different work item types and capacity allocation. Let’s look at a small scale example for that.

Starting with this fictional, initial board for a very small –let’s say three person– writing agency, we see that the company has committed themselves to limit their sold “Options” ((Options for others, but things the people from our little agency committed to) to six “announced” articles and agreed to have a target number of articles they’re “writing” concurrently to two (thus allowing some work to be already in the “ready for B” column). Furthermore they agreed to have only one article at a time in the “copy edit” stage and one in the “delivery” stage. The “done” column in the example is unlimited (∞) and the invoicing process seems not to be part of this board.

But is this kind of work really the only thing that has to be done in this small company? Of course not.

Let’s take invoicing for example. Even if we assume that writing the invoice and sending it out is part of “delivery” then there still is the little thing of checking if all open invoice get paid some time. And most probably there are also invoices coming in that need to be paid. So there a many small things that need to be done and that we might want to visualize if they are important enough to justify the effort.

Taking the approach of capacity allocation a first solution might look like this:

The idea here is to simply start by allocating part of the day to the big chunks and reserving a smaller part for all the small chunks. Those small chunks might be things like fetching the mail, checking the payment of invoices or paying their own bills.

Following the original ideas behind the Kanban Method principle of “visualize work”, this whole setup is rather buggy. The description of the columns doesn't match with the actual work that's performed in that column, and probably the whole workflow is quite different for those smaller pieces of work.

So let's take another page from the Kanban method and let's have a look at what we actually do now (start with what you do now ) for those small items that we work on we find that we don't have a general workflow but instead the workflow for each card follows the steps of “pick a card”, “understand card”, “perform task”, and “reschedule card as necessary.” And even though this might be the actual workflow, for such small tasks it would not make much sense to separate “understand card” and “perform task” – especially since they happen repeatedly.

So, a more realistic model might only include columns like “options”, “doing”, and “ready to reschedule.”

Picture of a two swimlane board with different workflows for Standard and repeating work

In this picture we now have a Kanban board with two swim lanes. Each lane with its own work item type and both with separate work in progress targets.

Even though this board would actually work (and in many cases I've seen boards like this being really helpful) the actual workflow here is so generic that it doesn't really pull its weight to have a separate board for this.

Depending on details of the cadences (i.e. the rhythms in which work happens) and how much time each item takes to complete, the aforementioned challenge might also be addressed via the lean concept of Heijunka (workload levelling) in the way I mentioned in my earlier post.

Enter kamishibai…

Luckily, the Kanban board is not the only thing that made its way over from TPS into other applications of lean thinking. One of the important parts of the Kanban Method –and probably the most visible one– is the first principle: “Visualize (the work and the workflow).” Using visual representations for things important for the job to be done is a key tenet of visual management. Which in itself is a key component of lean production. Like other things from lean (e.g. 5S), visual management has to be adapted to knowledge work to reap its benefits in this realm as well. Kamishibai boards, which are sometimes used for recurring audits, can be used quite nicely to manage recurring tasks with low complexity like the ones described in the example above.

A simple kamishibai-board just consists of a place to put cards with different colored sides (e.g. red/green). Having a card with the green side up means it’s done, having it with the red side up means it is not yet done. Also, you have an indication of the cadences (the Rhythms in which you want to repeat the tasks) and the very moments those cadences start. Each time a cadence start you simply turn all the cards in that area to show the red side.

Now each time you intend to work on the recurring tasks, you just go to the board, pick a red one, do it and place it back again with the green side up.

Picture of a very simple Kamishibai-Board

In this example the mail has been fetched (green card), the receivables have been checked (green card) and the invoices have yet to be paid. All daily tasks will be turned to red at 9 o’clock and all weekly cards will be turned to red on Sundays at 9pm.

Do you have to do actual board design for this?

Certainly, even board with almost no explicit design like the one pictured above will already be sufficient for many situations. That doesn't mean that there are no approaches to designing such a board that can be helpful. First off let's start with the areas. In the example above we concentrated on weekly and daily recurring tasks – that might be completely different in your situation. Whatever the cadence of your recurring tasks is: make an area for that. For example, daily weekly and monthly or biweekly or any other cadence you actually need. A helpful practice here is to note down the point in time when cards should be turned back to “undone” next to the cadence name, so that everyone knows when the cards need to be turned back and the organization doesn’t become dependent on the knowledge of one single person who acts as a “keeper of the board.”

If you have more than just a few recurring tasks, it becomes a good idea to hang the board on the wall instead of wasting precious horizontal flat surface otherwise known as desk space. something metallic with magnets to hold the cards is a good idea here. Or you might to want to invest in professional T card holders as they are used for example in manufacturing (or just build them yourselves…).

Picture of a DIY T-Card-Holder

What about the cards?

Even with a simple board there are a lot of things you can do with the cards. By the way: a simple way to create cards with two sides of different color is to just stick two post-its together, back to back… Or to take a white card and mark the top off in the colors of your choosing. Lots of room for DIY ideas here.


Is it really worthwhile to talk about the colors? Can’t we choose whatever looks fine? E.g. blue for undone and yellow for done? Or whatever our mood suggests? Yes that would be an option and it would even work. But with visual workplace management we want to make things easy to recognize with as little mental load as possible. So I suggest to stick with color codes that fit with everyday expectation, and Green for “done” seems to be pretty universal while “to be done” works with any color that’s far enough away from green like Orange, Red, Purple and the like.

What to put on the card

Apart from a short description of the task, it turned out to be a good idea to also put some additional information on the card. Two of the most important improvements or adaptations for knowledge work are sizing and tracking.

Assumption is the mother of all screw-ups

One helpful piece of information to add to the card is the time it should take to complete the task. Also, to make it more plausible that the work gets done reliably, it is a good idea to note down how long it actually took. A good practice here is to write the expected time on the “to be done side” and the time it actually took on the “done” side. And make sure to adjust the time it should take in accordance with those numbers. At least each time you have to replace the card because there is no more space for more records. Then we’re not talking about estimations anymore but about actual data from measurements.

Card sizing (kind of a hack actually)

If you have a dedicated amount of time to take care of your recurring tasks, it is a good idea to have a rough idea how many of those you're going to handle in any one session. One way to visualize this is to just have different sizes for the cards reflecting their average effort (doesn’t work with the T-Card approach, btw). This way, you can easily see how much of your time slot for recurring work will be filled up by the cards just by having a space at your own work area reflecting the time you allocate for these recurring tasks by it’s size.
You still should try to have a healthy mix of cards from different cadences e.g. daily and weekly, so that you don't have to do all the weekly stuff at the end of the week (or whatever the largest cadence is – could well be quarter in many enterprises).

Kamishibai – a little more complex

Even though simple recurring tasks do not merit the creation of a board that reflects their workflow, some recurring tasks can become quite complex. For those we can combine the whole idea of kamishibai with some insights from the checklist manifesto. The aforementioned task of checking invoices or receivables may actually turn out to be a bit more complicated than it might seem at first glance. Especially when the business is prospering and the client base grows. It might look like fetch the list of open receivables, add invoices we wrote since the last time we checked our receivables, fetch bank statements, cross out invoices where we got the money from our list of receivables, update last-check-date on the list of open receivables. As we can see, this workflow is in no way a process of knowledge gathering but actually just a collection of steps to be performed. Therefore, it wouldn't be natural inside the Kanban method to have a column for each of the steps. Furthermore, this process is very specific to this one recurring task. So, what's more natural than to put it directly on the kamishibai card? This way you might end up with kamishibai cards with things like cadences written on them, with an “Effort”, with little checklists and with any additional information helpful in the specific context of that task. Quite enough to handle most simple recurring tasks. Should the tasks become so complex that they warrant their own workflow the quest for an appropriate solution starts again of course.

The right approach?

Is it more appropriate to takle recurring tasks based on the kamishibai ideas? Well - it depends. It depends on the maturity of the people using the boards, it depends on the type of the recurring tasks –the approach lined out here assumes that the recurring tasks are small–, it depends on the complexity of the recurring tasks –having checklists on the task-cards makes it easier for people to swarm on recurring tasks- etc.
In my personal opinion one of the biggest advantages is that the approach helps in separating “value items” or “products” from items that are mere “tasks“ and are neither visible to the customer nor appreciated in themselves.

This illustration shows the approaches “use Kanban boards for everything” (one way) and “Kanban boards for value stream work and kamishibai boards for recurring tasks” (another way) can be used to represent the exact same situation.

A multi-process Kanban board broken down into value-stream Kanban board and kamishibai board

Both the light blue and the yellow scenarios represent the same situation. With regard to the recurring tasks: Two cards to do, one card in progress and one card “done” (at least done until the next cycle starts).

The second scenario uses a kamishibai representation for the recurring tasks. The recurring cards that were in the “committed” state on the kanban board of scenario “one way” became “undone” (red) cards on the kamishibai board in the scenario “another way.” An additional advantage is that the different cadence for both cards –one occurs weekly, the other one each day– is immediately visible. The “in progress“ card from the Kanban representation is not visible in this instance of a kamishibai board because the person working on it has taken it along e.g. to use the checklist on it. The card from the “done” column became a green (“done“) card in the kamishibai version. Again with the advantage that the cadence of that card is obvious.

Try kamishibai

Before you try to handle all work alike, maybe give the approach of kamishibai for recurring work a chance – it might help more than you think.

till next time
   Michael Mahlberg

Sunday, December 22, 2019

Don't get hung up on ‘Business Agility’ too much

To quote a currently very popular insight:

“As long as you don’t have your Business Layer under control, it doesn’t matter how agile your teams are.”

And YES, there is some truth in that. But it can turn out to be a logical fallacy.

And that is where I have my beef with the lure of ‘Business Agility’, because a lot of people think, that it is enough to focus on that level now. Not in my experience.

Having the awareness is –as the mathematicians would probably say– necessary but not sufficient.

An organisation is a system of interconnected systems (or services to use the terminology from the Kanban method) and if these underlying systems don’t work then all the ‘business level coordination awareness’ in the world won’t change much about the delivery capability of your organisation.

You can invest as much as you want into power steering (Servolenkung in German) and slip control – as long as your car is sliding sideways on an ice slope with slicks for tyres it actually pays to invest into better tyres before you start fiddling with the higher level elements.

As long as your business analysts don’t know how to quantify a business value, your engineers don’t know how to reliably ship the product, your sales people don’t know about the capabilities of your delivery services (sometimes a.k.a. development teams), or –in short– your teams are still at a low ‘agile’ maturity you won’t be able to steer the business.

The bottom line is:

As long, as your team level maturity is too low, you can improve the business level as much as you want – it won’t make a difference.


The maturity of an organization has to be evolved as a whole. The evolution at team-level, business level and strategic level has to go hand in hand

till next time
  Michael Mahlberg

P.S.: But if you focus on Business Agility alone at least some people in the organization will feel good. For about six to twelve release-cycles. Because –in my experience– that’s how long it usually takes the organization to come to this realization. [That can be up to three years btw...]

Sunday, December 01, 2019

Let MoSCoW help you with facilitation and workshop design ;-)

Interactivity vs. Schedule

When designing a workshop –or any session– you facilitate one crucial aspect is timing. But timing gets complicated when you have lots of interactive parts in the session in question. And we know from research about training and oftentimes also from personal experience, that interactive elements are essential to successful sessions, so there is a serious incentive to include interactive stuff. The same holds true for other kinds of meetings as well – from design sessions to board meetings.

Balancing being on time an interactivity with MoSCoW

There is an old idea, made popular in the early days of agile by its extensive use in DSDM called MoSCoW. The capital letters in MoSCoW stand for Must Should Could Won’t and the «o»s are just there to make it sound nice. Without looking into the original priotization method too deeply, thinking about the design of a session in therm of MoSCoW categories helps a lot in balancing timeliness and interactivity. Especially if you combine the MoSCoW thinking with the concept of Heijunka or work (load) leveling.

Designing the session

In most sessions, especially in teaching, it is not a good idea to have all the musts at the beginning – because of the way people learn a schedule should not be a backlog where you put all the important stuff up front and the rest at the end anyway. The approach that I have seen to be usefull to a lot of facilitators, is to make shure that your schedule consists of a well balanced mix of must, should and could elements. What ‘well balanced’ means depends on the circumstances of course. Assuming we’re in a training situation and we know only very little about your audience, we might want to include more ‘could’ elements than we do when we’re working in a well known setting. This is the Heijunka part – heijunka literally means ‘leveling’, but in the context of lean the meaning is extended to something like ‘smart leveling.’

BTW: In meetings that need to have decisions at the end, one of the must items –come to decisions– needs to be at the end. So it’s a very good idea to have discardable parts in the schedule even if the sessions you’re facilitating is not a training.

Applying triage as you go

Now while we run the session we don‘t want to constantly check the clock to see if we’re either too fast or too slow. Quite to the contrary. We do look at the time often, but we use our projected agenda (including the MoSCoW classifications) to adjust as we go. When we’re ahead of the time (e.g. because the audience is faster than expeted) we can transport a bit more information and include the could element that we put in our internal agenda. Should we be slower than planned we cut one of the should elements. By using this approach it is way easier to keep the value for the participants high for the whole session. (As opposed to lumping all the unimportant stuff at the end, so that we also could skip it – as we would do it in a prioritized backlog apporach.]

Just give it a try...

till next time
  Michael Mahlberg

Sunday, September 08, 2019

Is that “start with what you do now”-principle from kanban still ‘true’?

One of the pillars of the Kanban method is the principle “Start with what you do now.”

Looking at it historically, this was especially related to the fact that there is no need for any additional roles, meetings, or titles when introducing the Kanban method. In the early days that was such a stark contrast to other process improvement approaches that you still can find the foundational principle “Initially, respect current roles, responsibilities & job titles” on some Kanban method websites. Today this message has become part of the “Start with what you do now”-principle (as the second bullet point).

Over the years the body of knowledge in the realm of Kanban has grown and with some of the “newer” ideas there are a number of aspects that seem to contradict this very notion.

One of the more prominent ideas in this respect is the whole landscape of “Discovery Kanban”, “Customer Kanban”, and “Upstream Kanban.” Basically this is the idea to not only manage the delivery of work through a Kanban system, but also manage and organize the discovery of options with a Kanban system. Conceptually this has been described by Patrick Steyaert and it has been incorporated in the Kanban method as can be found e.g. in the related book Essential Upstream Kanban.

Yet, many companies don’t actually have a managed options discovery process – so where does this leave us with regards to the "start with what you do now"-principle? One possible starting point is David Anderson’s example for combining discovery and delivery kanban. This is a little different from the approach Patrick is describing, and most probably not exactly how the items “on the left“ of your delivery Kanban system flow now. (That is of course regardless of whether you call them “ideas“, “options”, “feature requests”, “demands”, or anything else.) But in my experience it is a very feasible way to get to “(finding out and) starting with what you do now.” As in so many cases, even though there might not be any formal discovery process, once you start looking into the details of the existing items and their history you might find that there is an informal process to be uncovered. It might more or less conform to the concepts lined out in the system descibed by David J Anderson, or not. Even if it doesn’t, just by having a board conforming to those concepts, trying to fit the (existing or assumed) items on it and facilitating the discussions around it, there is a good chance that you either uncover the real process or already evolve the process to something a little bit more fit for purpose.

Still, you actually started with what you did then – no new roles, no new processes. Not initially at least. Probably some processes evolved from having the discussions about the relative position of items on the board and how to get them there. And that is already the Kanban method at work as a change-management approach.

till next time
  Michael Mahlberg

P.S.: Thanks to Tim for bringing up this issue about “start with what you do now.” Nice catch.

Sunday, August 11, 2019

Which change-management approach is required to implement Kanban?

Well, there's the thing: the way I understand it, the Kanban method is not an end in itself – it is quite the other way round. Kanban is the change-management approach.

As lined out in the book that defined the method «I [David] subtitled this book, “Successful Evolutionary Change for Your Technology Business.” I did this to underscore the point that the main reason for adopting Kanban is change management. Everything else is secondary.» (emphasis added)

Over time the Kanban Method has evolved, and with the current material there are quite a few additional actionable tools available which hugely extend the original book. But for me, the core is still the same. You use the Kanban method to enable change – simultaneously giving people control over the processes (the process control or service delivery part) and enabling evolutionary change by making formerly intangible things visible and negotiable (the –evolutionary– change management part)

Of course, there is STATIK, the Systems Thinking Approach To Introducing Kanban, but once again, this is not an end in itself. And it only is an approach to introduce the Kanban method. All the organizational change that comes after that is not driven by STATIK, but by the Kanban method itself.

So, I guess what I'm trying to say is "Don't ask what you have to do for the Kanban method, ask what the Kanban method can do for you."

till next time
  Michael Mahlberg

Monday, July 15, 2019

Why are there no product owners in Kanban?

Or perhaps the better question would be: Are there no product owners in the Kanban method?

It is actually a question I hear more often lately – especially since I started to publicly rant against the misnomer that “product owner” has become.

The question doesn’t make too much sense

As I mentioned earlier it does not make too much sense to directly compare the Kanban method and Scrum because they exist on different levels. Same is true for their lingo.

The Kanban method neither promotes or prescribes roles

There is no formal definition of any role. (cf. Essential Kanban Condensed, p. 33) The aim of the Kanban method is to help create systems that can evolve, following an agreed upon –and in itself evolving– set of explicit policies. That being said, there are roles that the Kanban community has observed as emerging in many Kanban scenarios, but those are not prescriptive. (And of course, there’s more to the Kanban method than explicit policies – bear with me for the sake of the role argument with regard to the product owner)

Are there any product owners? Anywhere?

The first principle I ever heard when I learned about the Kanban Method was “Start with what you are doing now.” I'm personally quite fond of the statement “Accept reality.”

Accept reality

However you put it – the role that is described as a product owner in the original scrum literature (imho that would be Schwaber, 1995 or Schwaber, 2003) is very hard to find out in the fields. As a story goes which makes its round in Germany right now, some famous product development guru (if someone could point me to the source I would be happy to quote the original source) asked a room full of conference attendees how many of them were “product owners.” Almost everyone raised a hand. The next question was “Who could end their product tomorrow?” No one lifted a hand. Thus the stated conclusion was “So – we don’t have any product owners in the room.”
This might sound a bit harsh, but it points to a quite valid aspect of working together IMHO: the question of our understanding of that role.

What is a product owner?

In today’s reality, there are many people who are called product owners, but who aren’t really product owners in the original sense. That’s not as bad as it sounds. At least many people have a rough idea of what a product owner could be. The trouble is that there are many different interpretations of the role. Unfortunately only very few of them are coherent with the original definition. Given that the process descriptions out there use the term as it is interpreted in their context, problems arise when business analysts, subject matter experts, product managers, requirements engineers and other people working on the conceptual development of products are all collated into the umbrella term “product owner.” If you hold people accountable for ordering work items who are specialized in requirements analysis or if you try to get the conceptual sign-off for a new decision table implementation from someone who’s area of competence is customer management it is highly probable that you will be disappointed. “You” in this case can be anyone – from the CEO to the customer to yourself. I have witnessed huge disaggreements about the competencies of the different product owners (note the plural) that work together with a team. A lot of these arguments vanished when we dropped the name “product owner” and used terms appropriate for the real expectations and competencies. But then the process models had to be adapted to these new names. Which, in itself, is not necessarily a catastrophe, but –more often than not– only the end of an illusion. Those descriptions had to be adapted because they didn’t fit “anymore.“ Actually, they never had, but with the new wording, the discrepancies became visible. And all of a sudden, a model of the real –living– workflow became visible.

The Kanban method makes these things explicit by default

Amongst other things the Kanban method encompasses 6 practices –Visualize [work and workflow], Limit work in progress, Manage flow, Make policies explicit, Implement feedback loops and Improve Collaboratively, Evolve Experimentally.
By applying only two of them – “Visualizing” the real workflow and “making [the real ] policies explicit” – you already can find out if there are product owners in your actual workflow. And by applying the other practices and policies you can evolve (step by step) your technology business to an organization that is fitter for purpose than it is today. But that would fill a whole book. Or several. :-)

till next time
  Michael Mahlberg

Monday, May 27, 2019

We need more "Wax on - wax off"

(Thanks to Falk for brining up Mr. Miyagi here)

If you have never seen – or heard of – the 80ies movie “The Karate Kid“ the phrase “Wax on - wax off” probably won't mean much to you. Fair warning: spoilers ahead!

Amongst other things that happen in the movie, the relevant part here is that Daniel learns karate from Mr. Miyagi, the handyman for the family's apartment. Without delving too deep into the story, in the beginning, Daniel is demanding from Mr. Miyagi that he wants to learn kicking and punching, but Mr. Miyagi stalls him for quite a while giving him seemingly unrelated tasks to do in very specific manners. For example, Daniel has to shine a considerable amount of classic cars following a very explicit process, using one hand to apply the wax (wax on) and the other to polish (wax off) in precise circles. After a number of chores Daniel gets unhappy with being Mr. Miyagi's “slave” and Mr. Miyagi demonstrates that all those “chores” actually built capabilities which Daniel didn't have before and all the “techniques” he learned, like “paint the fence”, “sand the floor” or “wax on – wax off” could actually – once they where mastered – be quite powerful and effective tools (e.g. defensive karate techniques and blocks) that Daniel would use throughout his further Karate training and his tournaments.

Side Note: Of course there are clips on youtube depicting the "building the muscle memory" part of the story as well as for the part where “the learnings are applied.”

How does this relate to agile?

To me, it seems we have a lot of focus on advanced agile topics and managing agile teams (and I‘m not even talking about scaling agile) and less and less on the basics of working in an agile manner. But from my experience, it is paramount to have the basics at your disposal all the time. Even with all the “Agile Mindset” in the world a racing car team (like Wikispeed, who actually apply lean and agile approaches to building race cars) would not have much success if their team members weren’t highly skilled in their respective crafts. You can’t pick a random person from the street and just expect them to be proficient with a Torque wrench or a Gas metal arc welder.

IMHO honing the basic skills would do many agile initiatives good. Speaking from my personal experience, even if it seems tedious and even if it is not the sexy “punching and kicking” - every now and then it does help a lot to focus more on “wax on – wax off.”

till next time
  Michael Mahlberg

Sunday, May 05, 2019

Scaling ≠ at scale – Remember: «at scale» means something different than «scaled»!

It might be because I'm not a native speaker, but there is something about "scaling agile" or "scaled agile" that really has been bothering me these last couple of years.

As I wrote before in my recollection of events agile was described as something that works well for small teams.
IMHO at least two of the principles, namely "face-to-face communication" and "architectures, requirements and designs from self-organizion" are extremely hard to do in larger groups – unless you add additional constraints like structures (aka hierarchy) or special roles outside each individual group of people or team (aka specialists).

So what are we talking about, when we talk about Agile at scale? At scale means (according to to have something that is "at the required size to solve the problem." Scaling on the other hand means "a linear transformation that enlarges or diminishes objects."

What does that mean for scaling agile approaches?

Do we really want to scale e.g. the number of people involved in solving one specific problem? Because, actually the communication overhead does not scale linearly – it 'scales' according to Metcalfe's law and thus communication quickly becomes inefficient. (With 5 people there are only 10 unique ways of communication, with 12 people the number is already 66)

Therefore: Why do we keep talking about "scaling agile?"

I think we should talk about "appropriate solutions at scale" and strive for them. That might include approaches from the lean and agile communities, some implementation of the Kanban Method to facilitate the change and many other ideas that are appropriate for the actual challenges at hand. When we truly live in a volatile, uncertain, complex and ambiguous world, than maybe the solutions for big and complex organizations can also only evolve over time according to each specific organization.

till next time
  Michael Mahlberg

Sunday, April 14, 2019

When implementing Kanban, don't underestimate step 8 of STATIK

When you first start of with Kanban, you might hear that there is a very clear cut way to introduce it – it is called STATIK, the Systems Thinking Approach To Introducing Kanban.

For me this is not always the way to go, but it definitely is a way you should know. As long as you don't think that you can introduce the Kanban method with a half day (or one day) STATIK-Workshop.

Let's look at STATIK briefly: The way David Anderson describes it on his linked-in post STATIK consists of 9 steps. (There are other descriptions as well, most notably Mike Burrows' version from the Book "Kanban from the inside")

  • Step 0: Identify Services
    [For each service]
    • Step 1: Understand what makes the service fit for purpose for the customer
    • Step 2: Understand sources of dissatisfaction with the current system
    • Step 3: Analyze demand
    • Step 4: Analyze capability
    • Step 5: Model workflow
    • Step 6: Discover classes of service
    • Step 7: Design the kanban system
    • Step 8: Socialize the design and negotiate implementation

(I just quoted the summary, the full description is available in David's above mentioned post on LinkedIn )

Starting with step 1 through 7

While it is true that you could hold a STATIK Workshop for the steps one to seven in a really short amount of time, I have never seen the Kanban method implemented this way. I have seen quite a lot of Kanban systems implemented this way. But that's not quite the same – defining a system that reflects a certain point in time is different from embodying a method that fosters ongoing change.

Why I think step 8 is the most important one

Remember – as the titel of the defining book says - it is an approach to change: "Successful Evolutionary Change for Your Technology Business". And I have yet to see a system with human actors that can be changed in a day. Especially because the goal is not to change it only once, but to enable it to continue to do so in an evolutionary manner.
Therefore I think that step 8 is the most underrated Step of STATIK and would strongly suggest to use the result of steps 1 to 7 (a hypothesis the current system) only as a starting point for the work that starts with step 8 – implementing an approach to collaboratively strive for improvement through evolutionary change.

till next time
  Michael Mahlberg

P.S.: For some inspiration on steps 1 to 7 you might also want to look intoAlexei Zheglov's Posts on the approach and the Canvas/A3.