If you have a need to know when the work will be done or how much you can do in a certain period of time then predictability will be important to you. We have great tools like monte carlo for probabilistic forecasting but the truth is that the forecast we generate is only as good as the data we give it. Garbage in yields garbage out. So how do we improve our data to make it inherently more predictable?

We’ve talked a lot about theory in the past and now I want to focus on some specific actions you can take to improve the predictability of your data.

Remember that these are very specifically focused on predictability and while they may also help effectiveness and efficiency, they could make those worse. At least in the short term.

Actively manage the work

  • Keep WIP low: Don’t start something new if you can help with something already in progress.
  • Prioritize older work items before newer ones. For best predictability, we want to work on everything in a First-In-First-Out model
  • Don’t ever move items back to the backlog. If it’s no longer important then cancel it. If it’s still important then finish it.

Write better stories

  • Stories must be valuable and should be small. When we chunk the work into random tasks then predictability takes a hit. If we ensure that we’re writing valuable stories all the time then it will be easier to predict.
  • The majority of things we call spikes are really just “doing the work”. Don’t split them out into their own tickets. Same reason as above.
  • If you’ve created a “front end” story and a “back end story” then you’ve likely violated the “must be valuable rule”. Is it still valuable if you only deliver one of those? If the answer is no, then you really have one story, not two. Put it into one story and that will improve predictability.

Focus on quality

  • Bugs introduce significant unpredictability into the system. Adopt a “zero defect” mentality. If there are any bugs then we should fix them before we start any other work.
  • If the original story is still open then do not open a bug; instead track the problem in the original ticket. There should never be more than one ticket open for the same request at any time.
  • Address technical and architectural debt. Both of these will slow down the ongoing work and will make the system inherently less predictable.

Actively collaborate on the work

  • People truly collaborating (pair programming, ensemble programming, swarming, etc) tend to have smoother, more predictable results.

Break dependencies

  • Wherever possible, break or reduce dependencies. Dependencies are the biggest single threat to flow.
  • Are you dependent on skills that your team doesn’t have? Develop those skills.
  • Is there a hand-off to another group? Can you collaborate with them to eliminate the hand-off?

Reduce expedited work (classes of service)

  • Anything that changes the priority of work items that are already started, will worsen predictability.