Pawel Brodzinski on Leadership in Technology

Whatever it takes to lead a team, build a product, and run a business

Tag: WIP

  • Slack Time

    It often comes to me as a surprise that people misunderstand different concepts or definitions that we use in our writings or presentations. Actually, it shouldn’t. I have to remind myself over and over again that I do exactly the same thing – I start playing with different ideas and only eventually learn that I misused or misunderstood some definitions.

    Anyway, the context that brought me to these thoughts is slack time. When talking about WIP (Work In Progress) limits we often mention slack time and usually even (vaguely) point what slack time is for. However, basing on different conversations I’m having, people rarely get what slack time is when they first hear about it.

    How Slack Time Works

    Let’s start with basics. Imagine a very simple development process: we have backlog which we draw features from, then development and testing and after that we are done. For my convenience I split development stage into two sub-columns: ongoing and done, so we know which task is still under development and which can be pulled to testing.

    As you might notice we also have WIP limits that will trigger slack time in our process.

    In ideal situation a quality engineer would pull tasks from development done sub-column as soon as anything pops there and even if it won’t happen immediately we have a buffer for one feature in development (two developers and WIP limit of 3 in the column). I have a surprise for you: we don’t live in ideal world and ideal situations happen pretty rarely.

    There are two scenarios possible here. One is that developers won’t be able to feed quality engineer with features at rate high enough to keep him busy.

    In this situation quality engineer is idle. He just face slack time. He can’t pull another task from queue because it is empty so he needs to find a different task. He may try to help developers with their work (if possible) but he may also learn something new using slack time to sharpen his saw. He can also use this time to automate some of his work (and believe me: vast majority apps I saw would benefit heavily from automating some tests) so that the whole process is more effective in future.

    Another situation, and the one that is more interesting, would happen when the quality engineer is a bottleneck. It means that he can’t deal with features built by developers at the same rate they are flowing through development.

    In this case one of developers who just finished working on a feature has slack time. It is possible that another will soon finish his feature as well and both will be in the same situation. And again, they can use slack time, e.g. to do some refactoring or learn something new or help quality engineer doing his work. However, probably most valuable and at the same moment most desirable thing to do would be finding a way to improve the part of the process that is bottlenecked; here: testing.

    The effect might be some kind of automated test suite that reduces effort needed to test any single feature or maybe improvements in code quality policies that result in fewer bugs, thus less rework for each feature.

    What Slack Time Is

    By this point you should already understand when slack time happens and what it is roughly. Let’s try to pack it into some kind of definition then. Slack time happens when any team member for whatever reasons restrains to do the task they would typically do, e.g. a developer doesn’t develop new features. It is used to do other tasks, that usually result in improvements of all sorts.

    That’s a bit simplified definition of course. You may ask what if a developer has a learning task every once in a while put into their queue. Well, I would dare to say that it is just planning for learning and not introducing slack time, but we don’t deal here with strict definitions so I could totally agree if others interpret it differently.

    Note: we went through two different root causes for slack time emergence. One is when there aren’t enough tasks to feed one of roles. This is something that happens pretty naturally in many teams. If one of roles further downstream is able to process more tasks than roles upstream (in other words: bottleneck is somewhere upstream) they will naturally have moments of slack time.

    Some people may argue that this is not slack time and again I can perfectly accept such point of view. However, for me it suits the definition.

    Another root cause is when we intentionally limit throughput upstream to protect bottleneck that is somewhere downstream. This case is way more interesting for a couple of reasons. First, it doesn’t happen naturally so conscious action is required to introduce such slack time. Second, for many people introducing slack time there is counterintuitive, thus they resist to do it.

    A result of not limiting throughput before a bottleneck is a huge queue of work waiting for availability of bottleneck role, which makes the whole thing only worse. The team has to juggle more tasks at the same time introducing a lot of context switching and crippling own productivity.

    Nature of Slack Time

    One of specific properties of slack time is its emergent nature. We don’t carefully plan slack time as we don’t exactly know when exactly it’s going to happen. It appears whenever our flow becomes unbalanced, which sometimes means all the time.

    You can say that slack time is some sort of flow self-balancing mechanism. Whenever team members happen to have this time while they don’t do regular work they are encouraged to do something that improves the flow in future, usually balancing it better. At the same time the more unbalanced the team and the flow are the more slack time there will be.

    Remember though that in software development business our flow won’t be stable. Even when you reach equilibrium in one moment it will likely be ruined a moment later when you’re dealing with a special case, be it a non-standard feature, a team member taking a few days off or whatever else.

    It means that even in environment which is almost perfectly balanced slack time will be happening. Even better, such state means that you don’t have a fixed bottleneck – it will be flowing between two or more roles, meaning that every role in the team would have slack time on occasions.

    Another specific of slack time is that usually we aren’t told what exactly we should do in it. It doesn’t have to be that way in each and every case, however since slack time itself isn’t planned we can hardly plan to complete something during slack time in a reasonable manner. On the other hand there may be some guidance which activities are more desirable.

    It means that slack time seems to be a tool for teams that trust each other and are trusted by their leaders. It is true as slack time, thanks to its emergent nature, can’t be managed in command and control manner.

    However, for those of you who are control freaks, considering you have sensible WIP limits even if your people do nothing during slack time (and I mean virtually nothing) it should still have positive impact on team’s productivity. This is because 100% utilization is a myth. Note that in this case you lose self-balancing property of slack time – you don’t improve your flow. You just keep your efficiency on a bit higher level than you would otherwise.

    What Slack Time Is For

    I’ve already mentioned a few ideas what to use slack time for. Let’s try to generalize a bit here. Slack time, by definition, isn’t dedicated to do regular stuff, whatever “regular stuff” might mean in your case. If you think about examples I used and try to find a common part these all are important things: learning, improving team’s toolbox, balancing the flow or improving quality.

    At the same time none of them seems to be urgent. It is usually more urgent to complete a project on time (or as soon as possible) than to tweak tools team uses or introduce new quality policies.

    In short, slack time is for important and not urgent stuff. If something is urgent it likely is in the plan anyway and if something isn’t important what’s the point of doing it.

    If you’re interested in more elaborate version of that please read the post: what slack time is for.

    Other Flavors of Slack Time

    When talking about slack time it is easy to notice that there is some ambiguity around this concept. Why unplanned slack time is OK and planned time slots dedicated to the very same tasks are not?

    Personally I’m far from being orthodox over definitions. For me the key is understanding why and how slack time works and why it is valuable, so you can achieve similar effects using adjusted or completely different methods.

    Considering that a general goal of slack time is improvement you can introduce dedicated time slots for that or include improvement features in your backlog. The effect might be pretty similar and you may feel that you have more control over a process.

    What more, you may want to plan for improvement activities not leaving it to the random nature of slack time. Again, that’s fine for me even though personally I wouldn’t call that slack time.

    We may argue over naming, whether something already can be called slack time or not, but I’m not going to die for that really. Especially if we agree on purpose of these activities.

    I hope this helps to understand the concept of slack time – what it is, how it works and why it is valuable. Should you have any ideas what is missing or wrong here please leave a comment below. I’ll update the post.

  • Pitfalls of Kanban Series: Abusing WIP Limits

    This is another problem that comes in different colors. It’s either simple acceptation of WIP limits violation, no matter how commonly it happens, or setting WIP limits so high that a team never gets even close.

    Now, I don’t say that violating WIP limits should be forbidden at all. Pretty far from that. I just say that if it is a common thing it basically means that you have no limits at all. The same is with too loose WIP limits – it means no limits at all. It’s always a matter of balance: when and why you accept to violate WIP limits.

    I point this issue high on my list as basically not using WIP limits means that you voluntarily resign from the biggest gain you can get out of introducing Kanban – the rate of improvements and changes you introduce in the team is way slower. It is so because WIP limits are a mechanism that incentivize people to change their behavior (they would normally do one thing but they can’t as it would mean violating WIP limit so they do another). Without changing behaviors most changes are quickly rolled back to what people know and feel comfortable with.

    When you start thinking about the issue it may be a very complex one and as such may be approached from different directions. One thing which is pretty obvious: make abusing WIP limits painful. I don’t mean here physically painful of course, but add enough hassle that people would think twice before doing it.

    A neat trick I used was that every time someone wanted to violate WIP limit they had to organize a meeting with a team and tell everyone why they’re doing so. First, organizing a meeting, even an ad-hoc one, takes some time which you may use to rethink whether this is really needed. Second, you want to have pretty damn good reason to share as everyone will like to know why you’re breaking the rule. Actually, if you could come up with good argument you probably had a point in violating a limit anyway. You can use other similar methods as well, but basically the goal would be the same – to make abusing limits reasonably uncomfortable.

    Different approach will be needed to deal with unreasonably high WIP limits. A thing that may come handy in such case is measuring WIP over a period of time. It is an interesting observation but some teams believe that they actually have more WIP than they really do. In such case once you’ve measured your work in progress you shouldn’t be scared of limits. Even more, your initial decisions on WIP limits will be informed.

    Another idea is to reduce WIP limits periodically to see what will happen. Eventually the team would find their sweet spots, where limits are tight enough so that they’re incentivized to improve but loose enough that the inconvenience of having WIP limits is acceptable. It is like playing ball flow game, but on the real work done in a real team.

    Check the other pitfalls of Kanban as well.

    Advertisement: Infragistics® NetAdvantage® for Windows Forms provides developers with flexible, advanced controls to rapidly build high-fidelity Windows Forms application user interfaces “IN” style with the look and feel of Microsoft® Office® 2010 and Windows® 7. It Features every control developers need to deliver superior user experiences with stability, performance and robustness.

     

  • The Project Portfolio Kanban Story: Better Board

    When applying Kanban on project portfolio level you’re dealing with different challenges than in case of standard Kanban implementation on a team level (if there even is such a thing). Both the flow dynamics and task granularity is very different, thus you need to focus on different aspects when designing Kanban board.

    This is basically why typical Kanban board design will often be suboptimal.

    Portfolio Kanban Board 2

    At the same time the biggest challenge you face on project portfolio level is defining and applying WIP limits. For the time being my thoughts on a subject are that depending on a specific environment teams would be choosing very different measures to manage WIP on portfolio level. However, as we as a community still lack experience from addressing different scenarios I’ll focus on the path I’m following. After all the story format I chose requires that.

    In my case the most reasonable thing I was able to come up with was a number of people involved in project work. Unfortunately the scale of the team (more than 130 people) didn’t allow me to use straightforward approach and scale up WIP limits with numbers.

    Instead of continuing my struggle to find a perfect measure that suits the current board I decided to redesign it completely.

    Whenever you read about Kanban you learn that it is an evolutionary approach. Kaizen and all the stuff. However one advice I have on designing a Kanban board in general is that when you start running circles with board evolution and see little or no improvements throw the whole board out and start from scratch. From one point of view it can be considered a revolution (kaikaku) but from another: you don’t really change your way of working, you just try to visualize it differently.

    Either way I took my own advice and started from a clean whiteboard. I also remembered another advice: not to stick to standard board designs. This is what I ended up with.

    First, there is no value stream or process in a way we understand it on a team level. Since the flow of index cards wasn’t dynamic I decided this isn’t information I should focus on that much.

    Second, on horizontal axis, instead of process there is a time line (monthly granularity). As variability of project sizes is huge I decided I need some sort of time boxes which I measure WIP against. With very few small engagements, ones that take us less than a few weeks, monthly time boxes looked reasonable.

    Third, I created swim lanes for teams. We don’t have 130 generic engineers, or Average Full-Time Equivalents, or whatever other inhumane label you can think of. We have teams that we strive to protect and teams do have specializations. It means the context of a team is very important and if it is important it goes to the board, thus swim lanes.

    Fourth, having such board construction I had to change my approach to index cards. Instead of having a single index card representing single project I ended up with territory-driven approach. A project covers a territory both in terms of team(s) and time. Looking at index cards with a project name you can instantly guess which team is working on the project and how long it’s going to take them. And the best part: a size of index card in any given month represents roughly how big part of a team would be involved in work on a project. This way we can easily show a few smaller projects as well as on big or any combination of those two.

    Fifth, as one of Kanban base concepts is pull it is represented by backlog area – green cards on the left side of the board. These are projects that aren’t yet started. The specific swim lane they are neighboring show preferable team to work on a project. However, it rarely is such a direct dependency: this team will do the project as there is no other one suitable to do the job. Most of the time we assume that another team can build the project too. Each time a project goes into development we decide, at last responsible moment, which team will take it.

    Of course there are some nice additional flavors here as well. Violet and yellow index cards differentiate maintenance projects from new ones. Green card are for projects that aren’t yet started and once they are we switch to yellow. Red index cards represent overrun in projects that are late. As we work on fixed price, fixed time projects we roughly know up front how much time and people we want to invest into a project. When something bad happens and this plan changes we show that. After all we put more attention to challenged projects.

    A simple fact that we are working on fixed time, fixed price projects doesn’t mean our arrangements never change. They do. Any time something changes we just update it on the board, same as we’d do with any other board. We just keep the board updated as other way its value would diminish.

    This Kanban board design definitely tells more than the initial one but I started this whole revolution to deal with WIP limits. What with them?

    Well, there still aren’t explicit WIP limits. However at this moment there are implicit WIP limits and information about them can be pretty easily extracted. Considering that I use territory-driven approach to index cards WIP limit is show by vertical axis of the board. Each team has a limit of one full-sized sticky note (representing whole team) per month which can be split in any way.

    In other words we won’t start another project unless there’s some white space that this project would fit into as white space represents our spare capabilities. Actually, it may be a bit of simplification as on rare occasions there are project we just start, no matter what. But even then we either can make such project fit the white space in a reasonable way or we need to make some more white space for it.

    Even though such WIP limits aren’t explicit, after some time of working with the board I can tell you they do the job. They do, not only in pulling new projects into development but also, and more importantly, in long-term planning as we have visibility a year ahead and can confront our capabilities with planned sales etc.

    With this board, for the first time from the beginning of my journey with project portfolio Kanban I felt satisfied.

    See how we come up to this point – read the whole story.

    Advertisement: Infragistics® NetAdvantage® for Windows Phone gives you rich, innovative mobile UI controls to build high-end mobile user experiences for Microsoft® Windows Phone®. Their high performance, eye-catching data visualizations, mobile form factor optimization, touch gesture support, and alignment with Metro usability guidelines take your social media connected mobile applications to the next level.

     

  • The Project Portfolio Kanban Story: Why Standard Board Design Is Not a Good Choice

    When I was starting my journey with Kanban on project portfolio level I based on a classic board design I knew from my work with Kanban within project teams. I basically tried to map value stream to the board but on a different level.

    The effect was sort of predictable.

    Portfolio Kanban Board 2

    It was also naive.

    The basic strength of such design is it’s very intuitive. Well, at least for these parts of the world that read from left to right. The same way we read the board: whatever is closer to the right edge of the board is closer to completion. The value stream we map may be a bit simplified (as me make it linear) but then it isn’t that much of a problem – after all index cards are flowing through the board pretty smoothly.

    Unless you put on single index cards “tasks” that last a year or more, which is exactly what I have done.

    When you’re looking at very long lasting projects you look for different information than in case of several hour long tasks. It isn’t that important how an index card is flowing through the board. After all you expect it to sit in one place for months. If you find out that the status of the index card has changed a few days late it likely isn’t a problem at all.

    It is way more important, and interesting at the same time, to see teams’ capabilities in terms of undertaking new projects, i.e. how much more we can commit to our clients. Note: we aren’t talking about a single team of 7 (plus or minus 2). What we have here is 100+ people working on a couple dozen different projects concurrently. At this level capabilities are pretty damn difficult to estimate, especially given ever-changing business surroundings.

    This is a huge weakness of the common board design: it doesn’t really help you with estimating free capabilities. It would help if we were able to set reasonable WIP limits on such board. Unfortunately, it is (close to) impossible.

    A number of projects isn’t a good candidate to measure WIP, as projects differ in size hugely. If you use time-boxing you could try using a number of time-boxes as a measure. However in this case you don’t want to have a random team working on thirteenth iteration of a project that was build so far by the other team. With WIP limits measured by the number of iterations you would likely end up this way. Another idea was using money-related measures. This brings a question whether you sell all your work for the same prices. I guess that is true in very few cases and definitely mine is not one of them.

    The longer I thought about it the more often I was coming back to people. I mean a team could start another project if they had some free people who could deal with it in planned/expected time frame. I even thought for a moment of setting base WIP limit around 130 (roughly a number of people working on projects represented on the board) and having each index card to weigh as much as there were people involved in a project at the time. The problem was the hassle needed to manage such board would be horrifying.

    On the other hand measuring WIP in number of teams was way too coarse-grained as we had anything from multiple projects covered by a single team to multiple teams working on a single project.

    All in all I ended up with a belief that, in terms of project portfolio Kanban, standard board design isn’t a good choice. I was ready to redesign the board completely.

    If I piqued your interest read the whole project portfolio Kanban story.

  • How Much Work In Progress Do You Have?

    One of common patterns of adopting Kanban is that teams start just with visualization and, for whatever reasons, resist applying Work In Progress limits at the very beginning. While, and let me stress it, resignation from introducing WIP limits means drawing most of improvement power out of the system I understand that many teams feel safe to start this way.

    If you are in such point, or even a step earlier, when you’re just considering Kanban but haven’t yet started, and you are basically afraid of limits I have a challenge for you. Well, even if you use WIP I have the very same challenge.

    First, think of limits you might want to have.

    Second, measure how the tasks flow through your process. It’s enough to write down the date when you start working on a task and the date when you’re done with it – the difference would give you a cycle time.

    Third, after some time, check how many tasks in progress you really had every day. In other words: check what your WIP was.

    Odds are you will be surprised.

    One of my teams followed the “let’s just start with visualization and we’ll see how it goes” path. We even discussed WIP limits but eventually they weren’t applied. It is a functional team of 4 that juggles tasks which are pretty often blocked by their “clients,” i.e. beyond team’s control. The process, besides backlog and done bucket, is very simple: there’s only one column – ongoing.

    The discussion ended up with the idea of limit of 8, considering there are some rather longish tasks mixed with quite a few short but urgent tasks, e.g. “needs to be done today” sort, and of course there are frequent blockers. In other words rough limits two tasks per person should account for all the potential issues.

    As I’ve mentioned, WIP limits weren’t initially set. Even the WIP limit of 8 looked too scary at that point. After a few months we came back to the discussion. Fortunately, this time we had hard data from a hundred days.

    Guess what the worst WIP was.

    Seven. Over the course of a hundred days there wasn’t a single case that the scary limit of 8 was reached, let alone violated. What more, there were only 5 days where limit was higher than 6. In other words setting the limit of 6 and keeping it would be no sweat. A challenge starts at 5, which sounds very reasonable for such team.

    All of that considering that each and every blocked item was counted within the limit as at the moment the team doesn’t gather the data to show how long a task remains blocked.

    The lesson I got was that we can and should challenge our WIP limits basing on historical data. How often we hit WIP limits. How often we violate them. If it appears that we have enough padding that we barely scratch the ceiling on rare occasions it is a time to discuss reducing WIP limits. After all, it might mean that we are pursuing 100% utilization, which is bad.

    If WIP limits are barely and rarely painful, they aren’t working.

  • What Is Slack Time For?

    Jurgen Appelo recently touched the subject of slack time discussing what kind of tasks are supposed to be done in such time slots.

    First thing that I find disputable is reducing slack time to mere padding: “I expect the task to be done in 1,5 hours but to be perfectly safe I’ll start it 3 hours earlier so I can deal with unexpected difficulties.” I guess I’m way closer to Marcin Floryan’s comment under the post. Anyway, that’s not what raised my biggest concerns.

    I don’t agree with Jurgen on what slack is, or should be, for. Jurgen points that when we think about important things, like improvement, refactoring, learning and brushing teeth, we should actually plan for that and not hope that there will be enough slack time to have all of them done somehow. After all, we know that hope is not a strategy. Well, at least not a good one.

    First, I see it a result of a simplified view of slack time. Actually, with Work In Progress limits set properly I can expect to have pretty stable amount of slack time over time. The thing I can’t predict is when exactly it will happen and who exactly will hit the limit and will be granted free slot. However, lucky me, statistics is on my side – the slack time distribution should be pretty fair over time.

    I say “pretty fair” as when I have a very stable process, which software development is not by the way, I will likely face the situation that people who work on bottleneck part of the process won’t get slack time at all. Fortunately software development is really far from being “very stable” and even if it was we would still be able to deal with the situation using different means, e.g. the way Jurgen proposes.

    Second, I actually think that slack is a perfect tool to be used against important but not urgent tasks. Improvement and learning definitely fall into this category. Refactoring may or may not, depending on a software development approach you use. And brushing teeth? Well, unless you accept the fact you’re killing colleagues with your poisonous breath I would treat it as important and urgent.

    Yes, it means that I accept the fact that we may not spend any minute improving or learning (consciously) for some time. Considering my WIP limits are reasonable such situation would happen if and only if a team is perfectly balanced, our productivity keeps super-stable and there are no non-standard cases. Um, have I just said it is impossible not to have slack time? Oh, well.

    Of course there is another situation: too loose or no WIP limits at all. And yes, in such case planning tasks, which would normally be done during slack time slots, is one of ways to go. But definitely not the only one! And not the most effective one either!

    Actually planning improvement, learning, etc. tasks is just adding additional work items to your project. It doesn’t make you more flexible. Pretty much the opposite.

    Simply adding “empty” slack time slots, which can be filled by a specific task which, at the moment, seems most reasonable can be a more effective approach.

    You can do even better though. If your system natively introduces slack time these empty slots will appear not when someone arbitrary says so, but exactly when it is optimal for the system, i.e. when adding another regular task would overcrowd the flow, thus harm the productivity.

    With such approach I believe slack time is actually the right place for important stuff.

    Actually if a task is simply optional I would likely advise not to do it at all. After all, why add the complexity which isn’t needed. Isn’t everything around complex enough? Thus I don’t consider slack time a tool to be used to do optional stuff.

  • A Myth of 100% Utilization

    Do you remember your very first job? A junior software developer or a quality engineer. An intern maybe. You were expected to do something. All the time. I mean someone paid you and wanted to keep you busy. You didn’t see a big picture. You just had a queue of tasks you should do. One after another. Like building a brick wall. Brick by brick. Done with one? Here’s another.

    More interesting question is: has it changed over years? I mean you probably changed the role a few times, possibly went through a handful of companies. Odds are you see a big picture now. Or at least a big part of a big picture. Maybe you’ve grown to be a leader or a decision maker. Maybe even things are under your control.

    Nevertheless I’m still interested: whether you or your bosses still expect people to be busy doing the project tasks all the time?

    I guess this is true for vast majority of organizations. We still build brick walls. Brick by brick. Done with one, here’s another. Why bother, you ask.

    Well, this approach means basically aiming to have all the people doing something, for the sake of this post let’s call it “project tasks,” all the time. It means aiming for 100% utilization of people. And you know what? If you aim for 100% utilization you’re likely to get pretty damn close to it.

    The problem is we don’t get paid for being fully utilized. We get paid for delivering projects (again, please let me go with such a generic word).

    Thus, we should be aiming for effective and optimal deliveries and not for having everyone around busy.

    And there the fun begins.

    Intuitively we follow the way of thinking which tells us that we do most work when everyone actually is doing work all the time. Finished with one feature? Go, start another. The project will end faster.

    Except it isn’t true.

    We don’t do simple manual work. We don’t build a brick wall where each and every task of adding another brick is similar, simple and almost completely independent of other tasks. And most of all it can be done without much, if any, cooperation with others.

    There are a few areas where 100% utilization hits us hard.

    Context switching

    This is an obvious statement but switching context comes at a cost. I guess we always perform better when allowed to complete one thing uninterrupted before starting another and the nature of task doesn’t matter here. However, when we think of knowledge work there’s another cost we pay – time we need to get at full speed back again. Time to get into the context of the task. It’s not just another brick which we don’t even think of as our hands do the entire job.

    100% utilization means basically more tasks being done concurrently, because we want to have so much work started that everyone has something to do. It means that tasks are waiting for people. It means that quality engineers have enough developed features to test that they’re never idle and so on.

    OK, but what happens when someone finds a bug? Well, a developer switches back to this feature and fixes it. Then they’ll go back to this new feature they’ve been working on. In the meantime the quality engineer started working on something else and now they need to come back to this issue to retest it. Another context switch. Now, multiply it by a big number and that’s what is happening in many software development teams. Constant context switching, sometimes to work items which were waiting so long that people barely remember what they were all about.

    It costs. Each time probably just a bunch of dollars, but multiplied by a number of such situations it stacks up to huge piles of money.

    Task juggling

    Another problem which comes with having tasks waiting for free people on every stage of the process is that we have lots and lots unfinished work. It means significantly bigger coordination effort you need to invest to keep you machinery working. It means way more prioritization work as every now and then people need to decide what to next. After all they are choosing among a number of different options.

    It might surprise you but prioritization can take a huge toll in terms of time consumption. Let’s go with a simple experiment: prioritize whether you prefer to drink or pee at the very moment. It was quick, wasn’t it? Now, prioritize importance of each and every thing which lies on your desk. How much longer the second task took you?

    Many ongoing features usually also means that you add cost attached to all the product politics. If there are many decision on priorities during the whole process it means there’s a temptation to change these priorities so team members start attending meetings or having discussions where they are told to add this little gizmo to the next release as it will allow conquering the whole world. No! Not the world, the whole galaxy! Now, imagine you could just avoid all that and focus on value-adding work. How happy you would be.

    Time to market

    This one is tricky. If you asked any decision maker whether they want to have shorter time to market they would eagerly agree. However, pretty often shorter time to market bears not that much value. Think of fixed priced custom project for a big client. Even if you can release per feature or you can deploy a new version weekly, chances are good they won’t touch it, even with a stick. And if you deliver the whole solution a month earlier than planned they won’t have capabilities to run user acceptance tests, thus you’ll wait anyway.

    However, there are project where shorter time to market has huge value. Ask almost any web based app targeted directly to end users. In such cases longer lead times are actually counted in dollars.

    Early issue discovery

    Although personally I think this one is overhyped it can’t be omitted. If there’s a problem in your process there’s big value in discovering it as early as possible. Think of broken deployment. If you wait until you deploy the huge product at the very end of the project you are screwed up. However, if you care to deploy first bunch of features as soon as it is possible and reasonable, you discover the issue early, sort it out and eventually live through the final deployment with little or no problems.

    On a side note: why do I think this one is overhyped? Well, if I hear examples of sending mass snail mails, you know, printing some papers, putting them into envelopes, sticking stamps and so on I wonder what can go wrong with such process. Yeah, envelopes can have wrong color. Wouldn’t I notice it instantly? Hopefully our teams know at least part of their craft at this level as we do mailing.

    OK, either way there are quite a few places where we actually pay for 100% utilization. The result is that with the very same team we deliver later when they’re fully utilized than we would if they weren’t.

    I know, this is counterintuitive.

    It also means that avoiding 100% utilization means that we can build our projects cheaper.

    I know, this is counterintuitive.

    Actually, it means that letting our people do nothing on occasions means that we can perform better. And I mean nothing like, well, virtually nothing.

    I know, this is counterintuitive.

    The funny thing is we aren’t that surprised when we think about a highway. When we pack as many cars into highway as it is possible (100% utilization) we expect to see a traffic jam. And that’s what happens. We’ve been there. We’ve seen that. We expect nothing different. Then it is intuitive. Maybe because we’ve experienced that.

    Maybe we should give ourselves a chance to experience it in our projects as well?

    And yes, we can do better than let people doing nothing when they don’t do project work. But that’s a subject for another post.

  • Limiting WIP Is a Buzzword

    As you already know I’ve recently attended ACE Conference. By the way, if you missed the message the event was great. Anyway, the interesting thing about industry conferences is you can clearly see some cool phrases, buzzwords or examples. I was once on a conference where like every second presentation cited CHAOS Report to share the news: two third of features aren’t used.

    Um, after third time it’s not much of a news anymore.

    Anyway, one of few buzzwords I caught in Krakow was limiting Work In Progress. To be honest, I’m confused. Wasn’t it me, who told you to limit WIP in my Kanban presentation? Yup, it’s hard to deny. Am I on this damned limit-WIP-bandwagon then? Yup, it seems so. But why, oh why limiting WIP became a buzzword?

    For some reasons we need them. I think we keep attaching those buzzwords to our messages for a very simple reason – they sell. They sell whatever we have for sale. So yes, we’ll be hearing a lot about limiting WIP these days. By the way, another such thing is system thinking which follows exactly the same pattern – every cool kid on the block will tell you about system thinking.

    Despite the fact I hate one of my genuine messages became a buzzword, which makes it easier to be depreciated, there are some good points as well. No, I don’t think about being right a couple of years earlier than the rest of crowd. It definitely scratches my ego on the back but, well, my ego feels pretty comfortable anyway.

    A good thing of some good concept becoming sort of buzzword is it reaches some ears much easier. There are people who won’t adopt good things unless they’re well-known. There are organizations which hate to experiment. I have a good news for you: now, you have an excuse guys. Everyone tells you that you should limit WIP. Hard to ignore that now, ah?

    Unfortunately I know what happens then. The concept is being misused and abused and finally under the buzzword there’s hardly anything coherent. It’s like with agile. What does it mean when someone states they do agile (or are agile, for that matter)?

    Basically nothing.

    Unless you see how people work you can’t really say whether we discuss hard-core agile team which could serve as Scrum+XP implementation in Sevres or just the good old do-whatever kind of team which just wanted to get agile badge.

    It will be the same with limiting WIP at some point of the time. But until then I’m going to enjoy being the part of buzz proponents.

    So go, limit your WIP! Use Kanban! It is a goddamn silver bullet! It will make your team hyper-productive and will bring the peace to the world! And of course, in the meantime, it will remove poverty as well!

    And if you really think it might be a good idea, let’s talk seriously. Because I know it works, when applied in a reasonable way. Yes, your guess is right “reasonable way” is a key phrase here.