Going Agile: Scrum or Kanban?

I have been using Scrum for a while. Back at my previous role, we tried using Scrum within the integration team that was creating the nightly builds and our bi-weekly releases. It brought good results, the team specially liked the visibility of the task board and the daily stand-ups.

We did found a bit artificial to have a cadence. We were suppose to put out a release every two weeks but we end up doing it as often as we could (or made sense), as we were not in control of when the new software was landing in our plate.

Since then, I’ve this nagging thought that Scrum might not be appropriated to service teams or teams with a large portion of maintenance/customer support work. I have found iterations shorter than 2 weeks, can be over burden by the demo, planning and sizing overheads. In the other hand, two weeks is too much time for teams with Service Level Agreements of days or hours. It also seems a bit cumbersome for short project (~1 month), were you end up with 2 or 1 iterations… What to do!?

In Canonical several teams have used Kanban in order to improve their development processes, so I started reading up on it when I stumbled on this excellent article on Kanban vs Scrum.

The author won me over straight away by not trying to decide which of the two practices is best but instead doing a great job at remaining impartial.

Looking back at the Symbian Foundation’s integration team it seems that Kanban would have been better suited. It retains the focus on making information visible while concentrating on reducing WIP.  It seems better suited to a “specialist” team, where most members share the same skills and work on similar tasks. Scrum seems to work better for cross-discipline project teams.

Also, the emphasis on managing constant flow of work is one that resonates with teams that have a work “currency” measured in days of effort (bugs?) rather in large projects lasting months at the time.

While Scrum has been very successfully adopted by the Certification team at Canonical, My previous experience with the Integration team had stopped me from cheering on Scrum in teams that have a constant flow of work. Now, we are thinking on going Kanban! Don’t get me wrong, we are going to continue using Scrum. It is just a case of using the right tool for each job. I will keep you posted on how it goes.

If you have any advice, tips or gotchas that you could share with us, I would be most grateful if you could drop your comments here!

Going Agile: Trying To Do Too Much

When you are managing a team that starts migrating towards Scrum, you will find yourself looking into things like velocity and burn down chart wondering if the team is committing to too much or not enough.  You will soon realise that if you allow your scrum master to do her job, the team’s velocity will quickly stabilise and become predictable on their delivery.

However, what I find often overlooked is the impact of the backlog management. In my experience, trying to do too much is not just about the team over committing on an iteration but also about the product owner providing a lack of focus for the release.

Let me give you an example. Within the Ubuntu Certification team, we run six monthly releases, this are then divided into two weeks iterations. On the last release, we scheduled 13 themes. A theme for us is a overarching issue or requirement to which then stories are link in the backlog. In other Scrum practices this are called Epics.

Out of this 10 themes, we estimated that we could deliver 75 stories.  The team is in average finishing 7 stories (depending on sizing) per iteration. The problem with this approach is not that the 75 stories we picked weren’t the right priorities but rather that:

  1. We went for breath rather than depth. We achieved some progress in each individual theme, but not in depth progress in any.
  2. The team constantly had to switch mental context between themes. Some times a month would pass between stories from the same theme. Although the stories are independent this did not build on the sense of achievement by team every time a story was complete.

What I have learned in this release is that context switch is not only a problem for multi-tasking coders but it is also a source of waste for scrum teams needing to frequently change backlog themes from iteration to iteration.

With hind sight, I would have rather schedule 5 themes. I think that the kick that the team gets from making substantial progress in a theme plus the reduce need for context switching would have actually increase the productivity of the team.

Our next release starts in November and I am going to make sure that this time we focus on depth!

Going Agile: 2 Weeks On The Life Of a Scrum Team

The Ubuntu Certification team is fully distributed and has now been running Scrum for over 9 months. The team has members in Canada&US, Europe and Asia. I have been blogging about several parts of our scrum experience, now is time to piece it all together!

We run in 2 week iteration cycles within a larger 6 month release cadence. Here is what those two weeks look like:

Day1 (Thursday)- Planning session

We run the planning session (30 minutes) just after the previous iteration Demo session – No room to breath! The reason for doing this is just down to timezone and trying to get as many people as possible into this sessions.

We host the planning session in Mumble, and we review the backlog for the next iteration. We found it a bit dull just for the Product Owner to explain what each story was about. Instead, we ensure that everyones participation by agreeing the definition of done for the stories. This eliminates any misunderstandings of what needs to be deliver and ensure that everyone is paying attention.

Just after the planning session, the scrum team gets together to flesh out the task-board for the iteration. At this point the stories are re-size via IRC planning poker: At the count of three by the Scrum Master every one pastes a t-shirt size on the IRC channel.

Following the poker planning, the team discusses possible implementations and they write down tasks in the IRC channel, to be later translated by the Scrum Master into the backlog.

Daily Scrums

We run two scrums (no longer than 15 minutes) a day. A reduced one at 9.30 UK time with Europe and Asia, and a larger one at 15.00 UK time including UK and US. We run both using Mumble but Google+ is also a good option.

Day 5 (Wednesday) – Backlog review with the Scrum Master

On Wendnesday, Ara and I review the progress of the backlog and discuss any stories that might need to be refocused, unblocked or delayed to a later iteration.

Day 6(Thursday) – Discussing impediments and new ideas

At this point, we have reach the equator of the iteration. We host a 45 minutes meeting following the main scrum to talk about any issues the team wants to raise. This mainly focuses around problems facing our work or new ideas for future iterations or releases.

Also, the Scrum Master send an mid-iteration status email. This ensures that nothing is falling through the cracks and everyone knows the overall iteration progress. We find that scrums tent to focus on what people are working and not what is left in the backlog, this can lead to lower priority user stories being worked on while higher importance ones remain overlooked.

Day 9 (Tuesday) – Backlog review for next iteration

The Scrum Master, Product Owner and I get together to review what stories are likely to not be completed. This is normally 80% accurate and gives us a better idea of how many new stories are to be added for the next iteration. Then, we discuss priority of stories and we create a draft backlog for the next iteration. Although there are always  changes during the planning session, this gives us a solid draft to start from.

Day 11/Next Day 1( Thursday) – Demo

We completed the full circle and we are back at the demo and planning meeting, where a demo lead shows via Spreed (screen sharing tool) what has been achieved.

Going Agile: Don’t Forget About The Future!

When working with Agile, make sure to define your long term strategy that gives direction to your product backlog.

The Ubuntu Certification programme follows the beat of the 6 monthly release cadence. In the certification team we run a two week iteration cadence.  It is a continuous delivery machine! The danger is for your ambitions to get stuck in the quick rhythm.

Regardless if I am working with a product or a service team, I found it important to set a clear vision to aim for. The constant cadence of Agile is normally riddle with changes in priorities. While this enables the team to remain flexible, I have found that can be confusing for the individual: “Tell me again why are we doing this?”

Having a clear vision or product road map doesn’t only benefit your team, but also your stakeholders. I often find that a lack of a shared vision creates a mistrust – “This iteration could be the last one. Quick, I better ask for everything I need at once! Everything is high priority!”, sounds familiar?

Sharing a common set of principles and aspiration to deliver great value is sometimes confused with the need to have a committed  two-year plan. To remain competitive, I rather stop second guessing the future and build working practices that allow for change and make people comfortable working with the unknown.

Going Agile: Poker Planning In Action

The Certification team at Canonical has been Going Agile now for the last 9 months. Oneiric is the first release that we are running full Scrum practices. We are a bit unique as we are spread all over the world. We have 2 people in Montreal (Canada), 1 person in Boston (USA) , 1 person in Raleigh (USA), 3 scatter over the United Kingdom, our Scrum Master is in Germany, and our latest team member is in Taipei (Taiwan). Running Scrum in this type of  environment needs constant innovation. I am keeping track of our progress in my blog at victorpalau.net/tag/scrum/

Roughly every three months, we get together somewhere in the world. We just got back from the Ubuntu Rally in Dublin, where we decided to give our backlog some love!

We largely build our backlog at the Ubuntu Developer Summits and then we continue to add and remove items as we go.

Halfway through the project and with over 100 items to complete before the end of October, we needed to step back and make sure that we were working on the right priorities and that nothing had fallen trough the cracks. What better way to do this than a full poker planning session. Here is how it worked:

  • We use real cards that I brought over from home
  • We clear up a round table big enough to fit the whole team and we booked an hour and a half for the session.
  • We had a house dealer: I chair the session, I did not participate on the poker, my computer was the only one allowed at the table.
  • Using the list view in our google docs backlog, we reviewed a blueprint at the time
  • We spent less than 90 seconds per use case.
  • We use the following t-shirt sizes as measure of effort required to complete a use case: S,M,L & XL
  • Where there was substantial disagreement on size, we asked the highest and lowest  bid to briefly reason their decision. If needed, we did another sizing round after that.
We did came out of the session with a better sized backlog. The biggest benefit for me was that we merged, deleted and added new stories based on what we had learned over the last few months of implementation.
I also had to make some tough choices based on the new information and I decided to removes some blueprints from our Oneiric backlog scope.

Poker by Jonathan Rubio

Going Agile: Late Night Poker and Uncertainty

After the Ubuntu Summit in Budapest, We were faced with a lengthy backlog for the next 6 months. We made sure that we wouldn’t waste too much time on defining in great detail stories that would not be executed until 3 or 4 months from now. The result is that the next month worth of stories are smaller and more granular and large stories are found towards the bottom of the backlog. So far so good.

Like any successful team ;) we have more work that we wish we could do than we can actually fit over the next 6 months. To reduce scope, I needed to at least defined what is our estimated capacity for the 6 months and compare it with the current backlog.

To be accurate, we would need to estimate the size of every story in the backlog, in a more consistent manner than asking a team member for their gut-feeling (current process). We discussed having a Late Night Poker session at Budapest where we would size every single story, however this strike me as not agile at all.

Having discarded the massive Poker Planning session, I started looking with the Scrum Master at other options: Monthly Poker, Next Iteration Poker…and so on.

Eventually, I decided that I was looking in the wrong direction. We are going to continue doing planning poker for the Iteration that we are about to start and we will need to leave with the uncertainty of our backlog.

One thing was certain, that our backlog was too large and needed trimming down. Looking at our team’s velocity, I noticed that it was not only consistent on the story points but also fairly consistent on the number of stories completed per iteration. Saying this, I set out to cut down the backlog assuming that we completed 7 stories per iteration and that the last iteration should be empty. Clearly, this is not 100% accurate, maybe not even 80%, but it is a good starting point.

Agile is about managing change and living with uncertainty, and I’ve realised that I was trying to bend that in to good-old false security feeling of predictability.

Going Agile: The 6-Months Cadence

I have commented several times on the 2-weekly cadence that we follow at the certification team, but I haven’t gone into much detail on our 6 monthly cycle. We have just completed the Natty cycle (normally release date + 2/3 weeks) and we are about to start our Oneiric one.

6 monthly cycles help to plan achieving longer goals that drive the user stories implemented by the team in each iteration/sprint. During Natty, we had a loose coupling between these two.  I regularly (once a month) reviewed the progress of the Natty backlog and made sure that nothing was falling through the cracks. Despite the good completion rate in Natty, it was more of a case of the user stories forming the Blueprints (6 monthly requirements) than the other way around.

For Oneiric, the certification team went into UDS-O with much better defined blueprints. This has not only resulted in better sessions, but also on well defined backlog. Clearly, there is no much point trying to tight down what we will be doing in 4/5 months, so user stories towards the end of the cycle are vague and fairly large.  User stories for the next 2 months are better understood and described.

We have been collecting velocity data for the last few months, so by asking the team to roughly size new stories and review the sizes for the “next_iteration+1″, I hope to be able to build a burn up/down chart over the next few weeks! I will keep you posted.

Going Agile: The Ultimate Scrum Google Doc Template

While trying to work out the best way to adopt Scrum in the Ubuntu Certification team, I didn’t want to commit to an expensive process tool. So we have end up developing overtime the ultimate Google Document SCRUM tool.

I didn’t want to spent too much time reviewing tools and shopping for better prices rather than working on embedding the process correctly in the team. We might eventually move to a hosted “funky” web 2.0 solution, but in the meantime, Google Docs is doing the job just fine.

I thought that it will be great to share our backlog template with everyone, so I have created a public template with some fake stories. Here is the breakdown on how it works: Read more of this post

Going Agile: A few iterations under the belt

I wrote recently about the Ubuntu Hardware Certification team transition to Scrum.  We have since completed a few iterations, which means that the Planning and Demo sessions are in full swing. I am also happy to say that we now have a full-time Scrum Master in the team. One of the key advantages of this is that I get to sit in the demos and ask questions “from the outside” :)

Because of the global distribution of my team, we have end up with back-to-back Demo/Review and Planning meetings. This is how it goes:

3pm UTC – Demo meeting (30 minutes)

The Scrum Master runs (using Mumble) through all the user stories in the backlog.  Previous to the meeting, team members have posted links to their demos. We share the demos using a “virtual meeting” tool.  We end up settling for Spreed, as we already had some company accounts ( but I still secretly love yuuguu!).

At the end of each demo we [product owner, scrum master and me] give our opinion on whether the user story is completed or should be carried over to the next iteration (or later). Read more of this post

SCRUM can help you running workshops

The Sprint Taks Board

Last week I had the chance to run Rick Spencer’s Test Sprint. In Canonical-jargon a sprint is normally a 1-week workshop around a specific topic. In this case the topic was Automated Testing, hence my team was participating in the sprint.

As this was my first sprint at Canonical, I got thinking: what would be the best way to ensure a tangible outcome after a week of locking up 10 engineers in the same room? It seemed a good idea to borrow some SCRUM practices to organise the sprint. Here is a summary of what we did:

Read more of this post

Follow

Get every new post delivered to your Inbox.