We've been working for several years with Kanban process, and there's quite a bit of experience about it that we've shared (see the posts tagged with "kanban"). I've contemplated things around Kanban recently, and here's another interesting perspective. It might help make more sense of the Kanban method as a method for managing knowledge work, and software development work, in particular.
If we look into the 6 core Kanban practices, as identified by David J. Anderson in his fundamental book "Kanban — Successful Evolutionary Change for your Technology Business", the first practice is "visualize". While the other 5 practices (Limit WIP, manage flow, make policies explicit, implement feedback loops, improve collaboratively) are very important, the visualization practice is the key to all of them. Taking a flashback into how Kanban evolved historically, first it was a system "to control the logistical chain from a production point of view". Seems like Kanban as a method for software development differs from Kanban as a scheduling system for the material production in the following 2 things (mainly): non-linearity of the production process, and diversity of concepts and workflows.
I can imagine what the first sparkle that inspired software development folks about Kanban was. Some of us have this special relationship with the concept of "deadlines", and probably Kanban — on a purely human, maybe even subconscious, level — has been seen as an opportunity to break away from deadlines and estimates. Well, might be that Kanban came later than Scrum due to the fact that people got tired of the time-boxed iterations. And there it goes, a trendy new method for software development, that says: no time-boxing! Do your work at your own pace, and don't worry about deadlines!
That's the most obvious advantage that laid on the surface, and that's why software folks were so glad to switch to Kanban, intrinsically. The Kanban movement started back in '09-10, and the 5 Wrong Reasons to Apply Kanban and 5 Right Reasons to Apply Kanban posts in our blog are the evergreens that can provide some practical advice even now (especially as they resonate with the current NoEstimates movement).
Now, if the flow and no estimates aspect is a woo in Kanban as copy-pasted from the material logistics model, we're having a bumpy issue with the visualization core practice. The easiest way to go would be to copy-paste the visual production flow from logistics, as a stock of parts in the warehouse (the backlog) reduces, and then sequentially goes through the In Progress and Done states:
Looks as easy as a pie, right? But, remember, software development is a knowledge work. While some part of it, such as work items (user stories, tasks and bugs) can indeed go through this simplistic flow sequentially, there's a bunch of non-material related concepts and dependencies that those work items carry along with them. They are the non-linear "sticky fish" that might hinder the movements of this big whale called "software production'. Visualizing this knowledge work is not something confined solely to workflow and limiting WIP. Working with Kanban as a method implies visualizing various concepts about processes. Kanban is ultimately a "signboard". One straightforward Kanban board often lacks all those multiple perspectives that we need to monitor processes and to make them explicit. Obviously, a part of this limitation can well be addressed by swimlanes, when Kanban is not a board with just columns, but a grid of switchable columns+swimlanes. It's quite hard to get such a level of visualization on a physical board, too cumbersome to maintain. Fixed swimlanes on an electronic board (or, even switchable swimlanes but with some limitations) would not be enough. Kanban in the context of knowledge work requires unlimited columns+swimlanes combinations, with a plethora of custom 2D data grids. And we need to switch them fast, in a few clicks. Well, we can use tags to add another optional dimension for work items, but sometimes tags are not enough.
What we need from our Kanban boards for software development projects would look like this:
Here's the list of possible properties ("the sticky fish") that can go along with a user story:
- Iteration: if you see the upcoming iterations, you can move the stories to the grid cells, and create an iteration plan.
- Release: same as above, for a release.
- State: this would be a classical Kanban board.
- Priority: user stories can be prioritized similarly to how the states are changed.
- Effort: same as above, but for effort.
- Feature: that would be a story map backlog.
- Person: a work-by-person grid.
- Project: user stories broken down by projects.
- Team: user stories broken down by teams.
- Tags: even more flexibility.
- Custom fields: same as above.
That's the diversity of 2D visualizations that we could have with just one swimlane. But it's not only about swimlanes. Both the horizontal and vertical lanes could be tuned in the same fashion, unveiling thousands of custom 2D views.
So, what we would have here is not just one Kanban. It's a "Multiban" — many boards on one screen, where boards are switchable 2D data grids, and the data itself remains intact. Another example of such a data view is this:
Imagine this freedom. With such unlimited ability to visualize anything, the Kanban method would make much more sense. Any concepts, any perspective that you need could be visualized. If we have the first visualization core practice for Kanban handled that well, we would be able to take advantage of the 5 other Kanban core practices, mentioned above, and utilize Kanban as a process to manage software production (the knowledge work) more fully. That's what we are coming up with in the next version of our project management tool, and in this post I tried to provide some "behind the scenes" reasons for that.
Subscribe to the latest updates
Сheck out latest blog posts: Show all
a sales representative
Get a live
Let one of our product specialists create your account
and shape Targetprocess for your company needs.