skuvault

Tuning up Scrum Approach

~ maratkiniabulatov ~ Leave a comment

IMG_2016-06-17 13:21:33

Recently my colleague, Tim, decided to try out Planning Poker, to have better estimations. Planning is essential, and scrum already offers a framework of how to deal with planning. But over the course of my work and experience with scrum techniques, team usually shapes

Previous experience showed that daily scrum meetings are merely pointless. Direct communication / skype / IM is much more efficient. Especially in distributes teams.

And following each and every ritual from scrum routine is time and efficiency consuming during the first iterations, since agile methodologies need a good deal of instructions. Usually, after some time teams shape up scrum as they want, and it just works, so from my experience it’s not essential to follow scrum by the book (Agile Estimating and Planning book by Mike Cohn, written 10 years ago). Here are additional thoughts on why our transatlantic distributed team doesn’t fully fit into planning classic scrum and it’s rituals:

  • Due to out product having two versions, we sometimes have developers jumping in and out of projects;
  • Since we’re distributed and flexible – it’s hard to incorporate planning poker with all it’s “team that takes the hint” practice. Distributed team of two-three people can handle classic scrum, but not bigger one.
  • In order for classic scrum to work, team must be onsite (together in one place), and everyone should be in one timezone. That’s not our key point, we’re strong in our flexibility, adapting to challenges and different projects. Scrum meetings are not that effective, when one part of the team has finished work day, and the second one only starts with the fresh brains (smile)

Story Points vs Ideal Days and time estimates

  1. Story Points are valuable when it comes to relative complexity (e.g. that task is twice more complex as this one), and when the team has sort of fog of war before them. However, when elaborating on stats from burndown chart and calculating Focus Factor, we go to the point of calculating how many points / ideal days of uninterrupted development do we need. All because we need to know how to squeeze features into sprint timebox.
  2. If you work with JIRA
    1. Story Points are not as comfortable to work with, as Original Estimate field. Subtask story points do not sum up in parent ticket, unlike original estimates.
    2. Story Points lack ‘remaining story points’ bit, which is uncomfortable once user story has spilled over to the next sprint. Original Estimate, in this case, can be complimented with Remaining Estimate field.
  3. It’s not convenient to estimate buffers for unplanned work with Story Points.
  4. At the end of the day, Story Points are calculated to that very same hours developers spends effectively inside a timebox. Do we need an additional layer of calculations, if it will eventually come to measuring time?

Planning Poker

Planning poker is a ritual before the sprint, where the team (devs, qa) estimates upcoming user stories by a consensus-estimate (average estimate of all team members), assigns user stories to developers, and discusses possible roadblocks collectively.

Don’t have anything against that, but it often comes out time consuming (not that critical as it sounds, actually), and shows lack of detail from other estimators. Moreover, planning poker usually means that devs themselves think about which ticket is to take, which is quite hard to do when we have such a vast scope (~1300 tickets in backlog) + ~2 sprints planned ahead.

But let’s omit devs and tickets self-assignment and time consumption. That’s all tunable.

There are online tools for planning poker:

Estimations and Forecasting

Man Day !=  Calendar Day, because developer gets distracted during man day. So none of these terms reflect what we need.

Story Point is too abstract. Let’s use Ideal Day term, meaning 6 hours of undistracted work.

Key questions to answer when making a good plan (cynical comment: plan is worthless, planning is essential, as Napoleon said) are the following:

  1. How many ideal days on average are in sprint.
  2. How many ideal days can certain developer actually works per sprint.

Once again, Ideal days != calendar days.

Buffers and Planned Days

While starting to estimate and plan back in August, I started by making buffer of 0.5 day, thus making development occupy other 4.5 days in the sprint.

Currently it’s 1.5 days buffer, and 3.5 days of development. This may not be enough, as I’m continuing to tune and gather stats on that. I think that somewhere closer to 3 days is tolerable.

MONTH

TIME BUFFER / SPRINT

PLANNED DAYS
August 0.5 4.5
September 1 4
October 1 4
November 1.5 3.5
December 1.5-2 3-3.5
  • I’m aiming at 3 days of development for devs, and 2 days for code review / scope creeps / finishing up tickets that are reopened;
  • Time buffer includes time for Code Review, fixing Reopened Tickets, other distractions;
  • Planned Days = Ticket Estimated in Ideal Days multiplied by Complexity Multiplicator.

Such empiric way is basically the same focus factor scrum is offering, but without a layer of story points that you later need to convert. And btw, it falls into same ratio I had during previous two projects, which is 2/3 development, 1/3 buffer for fixes and everything else. Seems like more or less ratio across projects then.

Complexity Multiplicator

Plus we have complexity factor, which helps to form buffers. Complexity multiplicator is a combination complexity and unknown unknown. 3 ticket complexity levels:

  • easy <x1.2>
  • moderate <x1.5>
  • complex <x2>

The common equation for one person will look like:

Sprint = SUM(User Story x Complexity Factor) + Time Buffer
5 days = SUM(User Story 1 x Complexity Factor; User Story 2 x Complexity Factor) + 1.5

Individual numbers differ among developers.

All in all, these are estimation basics. Questions asked will add up to this post. Meanwhile, some literature to read:

resized_high-expectations-asian-father-meme-generator-you-are-scrum-master-why-not-scrum-phd-f56adf

I’m not telling pages behind those links are true / correct, but they are certainly allow to overview issues from different angles.

Manage process, not people

~ maratkiniabulatov ~ Leave a comment

It’s all about the process

I might be a captain obvious here, but supporting a process for an analyst / pm is a more important, than micromanaging tasks amongst developer pool.

When a new team member steps in, who’s responsibility is to manage development processes, she needs to find how to make business processes inside a company better.

Business processes are evaluated from various points of view, but in a nutshell, aside from developer professionalism, she needs to make sure there’s no room for slowdowns and uncertanties when product passes different stages across different teams. Whether there are delays in communication, or delays of resources for the project, or sick-days, – there should be a correct process to tackle such cases, in order to minimize negative outcome.

There’s always a temptation to micromanage issues, no matter how big the project is and how little time you have. But project manager’s job is to create a process that allows to handle various situations. Once the process has been established – keep an eye on the workflow, so that it doesn’t jump over the fence of how the process should work.

Fencing is the key idea. Micromanagement is bad, if you don’t have a clear process: it’s time consuming, it’s inefficient on a project scale (of course there are exceptions), and most important – micromanagement doesn’t cope with scaling.

So the typical steps to establish a working mechanism is to:

  1. Create the process
  2. Adjust it to keep all needed operations inside that process fence
  3. Make sure operations can connect to each other via unified inputs and outputs
  4. Optimize the process to allow painless scaling
  5. Do not pay too much attention to micromanagement 🙂