Archive for the ‘Scrum’ Category

I watched a recording of a webinar from the NeuroLeadership Institute recently, and it struck me how it supported the approach I’ve been advocating for preparing work (see Change managing our backlog refinement).

Here is my key take-out from the webinar which I believe supports an iterative, repetitive approach to creating understanding.

How do we mitigate this? By creating connections and giving people time to pause and digest.

What does this insight change for you?

Is that even the right question?

Sprint Reviews: my experience is that they can swing from compulsory to optional and very often fall short of their true potential. Some teams see them as “demos” – a place to “show off” and prove that we did some work. Others see them as a place to give Stakeholders the reassurance that we are delivering against our plan and are on track. Sometimes, they can be a place for feedback: usually when our customer is external and it’s the only chance we get to show them something while it’s still in progress. I’ve seen organisations make them compulsory – but then only invite the team, and I’ve seen other organisations choose to do them quarterly, usually after a major feature has gone live, and then the team spends hours preparing for them. Usually, it’s a presentation. Rarely is it interactive or collaborative.

I was working on a team that frequently cancelled their sprint review. Arguments ranged from:

  • We’ve already shown the stories to the key subject matter experts (SMEs): they have given their feedback
  • It takes too long to prepare for it: we’ll show everything once we have the end-to-end journey completed (and often, released)
  • There was an Exco meeting already this sprint: we covered everything then. No need to repeat. Let’s just have a team review. (Side comment – if your Scrum team needs a meeting every sprint to show each other what happened in the sprint, then that’s a signal there are other problems to solve.)

Cancelling a sprint review made my Scrum Master heart very heavy. The Scrum Guide describes the Sprint Review as follows:

The purpose of the Sprint Review is to inspect the outcome of the Sprint and determine future adaptations. The Scrum Team presents the results of their work to key stakeholders and progress toward the Product Goal is discussed.

During the event, the Scrum Team and stakeholders review what was accomplished in the Sprint and what has changed in their environment. Based on this information, attendees collaborate on what to do next. The Product Backlog may also be adjusted to meet new opportunities. The Sprint Review is a working session and the Scrum Team should avoid limiting it to a presentation.

Some of these conversations WERE happening. But they weren’t happening in our Sprint Reviews nor were they happening with the whole team. These conversations also often focused on the roadmap from a feature-list perspective rather than how our product was evolving. Our sprint review had turned into a presentation – and one that required a lot of preparation – so it was no surprise that the team wasn’t seeing the value. We tried some experiments to get more interaction out of our attendees (often about 50 when everything shifted to virtual), without much success. Mostly they seemed to be there to get updates on how things might be progressing rather than out of interest in how our Product was developing.

So I took a step back. And decided to approach the problem with my facilitator hat on:

  • Who were our stakeholders? Why were they there?
  • What was the desired outcome of the Sprint Review – and were we inviting the right people?
  • What did the people we were inviting want out of our review?
  • Why did we seem to have multiple versions of the same meeting?

One clue to this problem was that my Product Owner and other key people in the management space often referred to the Sprint Review as a Business Review. Long story short, my first a-ha moment was this:

What was happening in our space was that the stakeholders for both meetings were pretty much the same people. And those people were not comfortable having project type debates in front of the team. And although they were interested in the thing we were building, it was at a high level and more in terms of progress rather than a desire to build the best thing for our users.

If you take these two types of interests, and then consider the following stakeholder analysis for the two “meetings”, you would get two different groups of people (with some overlap):

Another thing I noticed was that whereas the group of stakeholders for the project would remain fairly consistent; the group for the Product could shift sprint-to-sprint depending on what the sprint goal had been. Based on this observation, if your meeting invitees for your sprint reviews never change, then that might be another signal that your Sprint Review is not actually a Sprint Review.

I believe that in a true Product focused environment where decision making sits mostly in the team, the Sprint Review could and should satisfy both interests. However, while most organisations are still transforming and things like budgets, team composition, and ROI still sit with managers, it may be wise to use this perspective and ensure you’re having the right meetings, with the right people, on the right cadence for both needs to be satisfied.

What has your experience been with Sprint Reviews?

What a-ha moments have you had?

I did this retrospective with one of my teams recently, and seeing as the feedback afterwards was really positive, I thought I would share. First off, kudos to The Virtual Agile Coach for creating this retrospective in the first place. I don’t have a paid Miro account so had to recreate the experience in Powerpoint (file attached), but he had done the heavy lifting and Miro templates are available on his amazing site for those with the power to import.

Some context to add is that I have had some push-back from the team in the past when it came to activities in meetings that they did not regard as “work”. For example, some people don’t like random check-ins while others complain when we have to interact with a visual aid (“can’t we just talk?”). As an experiment, for this retrospective, I explained the “why” behind each of the facilitation activities I was using. And I believe it helped 🙂

Another note is that although I have indicated the timeboxes I used, it’s worth mentioning that this was a fairly large group (14 people) which brings its own challenges. For example, if you have a smaller team, then potentially break-out rooms would not be necessary.

1) Setting the Scene [10 minutes]

First I shared the Miro board link in the chat (I had already shared it before the session, but wanted to make sure everyone could get there) while we were waiting for people to join.

Then we started with an activity. I pasted the following instruction in the chat:

Take turns to answer this
==========================
What FRUIT are you today? (and, if you want to share, why?)

We used https://wheeldecide.com/ (which I had set up with the team names and to remove an entry after each spin) to decide the order for people to share in.

I also gave the instructions verbally.

Before we started, I explained why we were doing the activity:
“When a person doesn’t speak at the beginning of a meeting, that person has tacit permission to remain silent for the rest of the session (and often will). We want to ensure that no one has a subconscious barrier to speaking up in our retrospective because it is important that everyone feels able to contribute equally.”

Remember to pause before you spin the wheel for the first time so people have a chance to think about what they will answer.

After the “fruit” check-in, we went to the Miro board and I reminded everyone why we did retrospectives (The Agile Principle) and the mindset we were meant to have during the discussion (The Prime Directive). I also ran through the agenda.

2) Gather Data (1): Silent Writing [4 minutes]

Gather Data

I pasted the next instruction into the chat before I started speaking (it included a link to the correct Miro frame):

Silent writing for 4 minutes. Add stickies to the sections on the Miro board.

I explained why we were doing silent writing:
“Some people need time to stop and think or are not able to think while other people are talking. We’d like to give those people a chance to gather their thoughts before we move into a stage where we want them to listen to the “speak to think” people in the room. Another reason we’re doing silent writing is it is easier for the human brain to stay engaged and focused when we engage at least two of our senses. So in this instance people are seeing and typing (movement). And having a whiteboard in general means you can capture notes (movement) and listen at the same time. Another reason it’s good to capture notes is sometimes people might have to step away, or will be briefly distracted, and then there is a visual representation of what they might have missed and they can catch up with the rest of the group. We also have some team members who cannot be here today, and this creates something they can refer to when they are back at work. Lastly, our brains can only hold 5-8 items at any one time, so by writing down our thoughts before we move into conversation, it means we can focus on listening rather than trying to remember what we want to say.”

I then reiterated the instruction and played the song “Another One Bites the Dust” while they performed the activity (because the length of the song is almost 4 minutes).

3) Gather Data (2): Conversation [6 minutes]

Once again, I started with pasting the instructions (the same link as for silent writing) into the chat:

--- Breakout Rooms: Discuss Queen ----
Discuss what's been written. Add any new thoughts.

I explained that we would be going into break-out rooms of 3-4 people randomly assigned by Zoom and that each group would have about five minutes to discuss what they could see on the board plus add any new thoughts out of the discussion.

I explained why we were using breakout rooms:
“We want everyone to have a chance to speak, and because we are so many people, to do so in one group would take a long time. Breaking up into smaller groups means we can have some of those conversations in parallel. It’s also easier for people to connect online when they are in a smaller group and our brains find smaller groups less tiring, particularly when using a tool like Zoom.”

I then repeated the instructions and sent everyone into break-out rooms.

4) Generate Insights [15 – 17 minutes]

Generate Insights

Once everyone was back, I added the next instruction to the chat (with a new link to the relevant frame on Miro):

----- Breakout Rooms: Generate Insights ---
Talk about what stands out? What surprised you? What patterns do you see? What is missing?
(You can add notes -> miro_link )

I then told the group we would be going into break-out rooms again (this time with new people) and this time the idea was to step back and look for patterns or trends. To try see things from a new/different perspective. I mentioned that the instructions were in the chat and that there was a space on the Miro board to add notes (if they wanted to). I also said that we would be having a debrief of what was discussed as a single group when everyone came back from the break-out rooms.

Before I opened the new rooms, I checked in as to whether the first break-out slot had been long enough. One group mentioned that they hadn’t really managed to get to everything so, as we were running ahead of schedule, I added an extra two minutes to the five-minute break-out room timebox.

While people were in the break-out rooms, I added a funny hat to my Zoom attire.

When everyone had returned from the break-out rooms, we made time for discussions. This is where, as a facilitator, you need to be prepared for awkward silences! Once the first group had had their turn, things flowed again. I was ready to add any additional comments/notes that came out of the debrief however, in this instance, there were none.

5) What could we do? [5 minutes]

The chat instruction:

Please add ideas for what we can try next sprint to the "Ideas" section -> miro_link
We will then have a 10 minute break until xx:xx

I explained that we had gathered data and highlighted any trends or observations, and now we had to decide what we wanted to try in our next sprint. The first part of that process was to capture and share our ideas. We would do this by having five minutes of silent writing, followed by a 10 minute break, and when we returned after our break we would discuss the ideas on the board. I told the team that I would be playing music for the silent-writing part, however people could use the time as they chose, as long as they had captured their ideas by the time we returned from our break. After checking for any questions, I started playing the song: “I want it all“.

While the song was playing, I kept my camera on as a visible indication that the break hadn’t officially started. When the song finished playing, I turned my camera and microphone off (we generally stay in the Zoom room for breaks) and re-iterated in the chat window what time everyone was expected to be back.

6) What will we do? [Remainder of the timebox – approx 30 min]

I changed my Zoom hat again for the final part of the session, and reminded the team that we were aiming to shape our ideas into at least one action or first step that we wanted to try in our next sprint. We started with a debrief of the ideas that had been added to the board, particularly the ones that were not so specific and more like thinking items (so that we could generate some specific ideas for what we could try).

Once we were done discussing, we used Menti to rank vote the actions we’d come up with. One could also use something like dot voting. I used Menti because my team are familiar with Menti and I find it’s quicker to update ‘just in time’. As an aside, before we rank vote, we also usually get the team’s input as to the impact/effort for each of the proposed actions. For this session, it actually led to further discussion, because one team member realised that they didn’t know enough about the action to be able to rate the effort to do it.

Effort vs Impact of Actions

Once ranked, we took the top ranked action and ensured that it was SMART. At that point we were out of time, so I asked the team if we were OK to end the session. Sometimes in the past we have decided to take more than one action into our sprint (but we try limit it to no more than three).

We also always do a fist-to-five to ensure everyone can live with the SMART action(s) as described. I like to use a Zoom poll for this.

7) Close

To close the session, I re-capped what we had done during the session (starting with the check-in activity) and that we had agreed to one action for the next sprint. I reminded people who had specific actions from our discussions about their tasks. Finally, I asked the team if they would give me feedback on Miro by

  1. Dragging a dot to rate the retrospective out of five
  2. Where they had comments (things to keep doing, things to stop doing), adding those thoughts to a sticky

And, with that, we thanked each other and ended our sprint retrospective.


If you give a similar retrospective a try, let me know how it goes. I would be interested what did and did not work for you and your team.

noganttMy team were struggling to make their sprint commitments. Sprint after sprint, we’d go into planning, pick the stories that we believed we could finish in the sprint, and get to the end with things not where we wanted them to be. To make matters worse, stories were piling up towards the end of the sprint, leaving testing (and feedback) right to the end. Our best intentions were just not translating into a workable plan and it was hard to see why. And then someone suggested that we try visualise our plan in Sprint Planning 2 (SP02): would it help if we created a Gantt?

My gut reaction (as their Scrum Master) was pretty strong. I had flashbacks to my Project Administration and Project Manager days where my life was ruled by Microsoft Project Plans and unrealistic resource-leveling. I recalled long arguments about how, just because you could get a document through our intensive quality checks in two days, usually, it took about a week, plus you needed some days to rugby-tackle your busy stakeholder into signing it once it was ready. All this meant that your team was (in Gantt terms) “not working” for the duration of the document review task – which was unacceptable when everyone needed to be at a consistent 75% utilisation for the project. Then there were the status reports and percentage complete updates (how do you know you’re 50% complete if you’re not done yet?) and lines that jumped and moved (or didn’t) when your dependencies were mapped incorrectly.

All of the above happened in my head, of course, and we agreed to give the Gantt chart a try during SP02. Thankfully, besides knowing how to draw a basic frame, all my historic experience with Gantt charts meant I also knew which questions the team would need to answer to complete one – plus the mistakes people usually make when creating a visualisation of duration.

Before I share with you what we did, I think I’d better let you know how things turned out. The first few times we did it, people really struggled and it took a while to create the chart. However, with practice, it became just one more SP02 activity, and eventually, I didn’t need to help the team at all.

The visualisation helped us highlight where we were overcommitting ourselves (expecting one person to work on too many things at the same time; forgetting when a team member was on leave at a crucial point; or not finding ways to do some testing earlier). In making our poor planning assumptions visible, it helped the team figure out workarounds before the sprint even started e.g. for very long stories, they’d identify smaller milestones for feedback. Or where they realised that the type of work was very heavily weighted towards a particular skillset, they identified simpler pieces where less experienced team members could pair up and work together saving our “big hitters” for the more complicated stories. We also got better at accommodating sprint interruptions (like public holidays or whole-team-training) and adjusting our sprint forecast accordingly. Lastly, we started taking our Gantt into daily stand-up, and the team would adjust their Gantt plan at the end of stand-up which was a great way to see if we were on track and, where we weren’t, what needed to change.

How did we do it?

This is how we used the Gantt chart. Firstly, after SP01, I would create an empty framework for the 10 days of the sprint. I’d add any known “events” that would impact us, for example:

  • Our sprint ceremonies were on there
  • Any planned grooming slots were indicated
  • Planned leave/training was reflected- with the box size representing whether it was a half-day or full-day
  • Other significant “distractions” were added, like floor release dates
  • Any other planned meetings we were aware of after Sprint Planning 1 (SP01) were added
  • Weekends and any public holidays were blocked out
  • We also made the sprint goal visible on the last day (Review box)

The team would then work down their list of Backlog Items agreed in SP01. After discussing the item and the tasks for the work involved, they would then plot its expected start and finish date on the Gantt. As this was duration-based, in the beginning, I sometimes needed to remind them to add an extra day where a task ran over a public holiday or the person(s) the team assumed would be picking up the task (based on what was going on/availability) was going to be out of office. As they generally had an idea of who might be doing what, durations were also adjusted based on the person doing the work e.g. they would sometimes add extra time if the person was working in a space they were less familiar with. Even without thinking about who would be working on a specific task, the Gantt made it very clear when they were expecting to start more stories on the same day than there were people available to work on them. As previously mentioned, where stories looked to have a longer than usual duration, the team also brain-stormed mini-milestones where testing/checking could happen (e.g. if it was a five-day task, they’d try have something that could be tested/checked every 1-2 days). I added the tasks to the Gantt chart the first few sessions we used it, and once they’d got used to the idea, then a team member started doing it.

Finally, if the Gantt showed we’d been mistaken about our forecast in SP01, it meant we were able to communicate changes to the forecast before the sprint even started.

ganttall


This team had a specific problem to solve. As it turned out, the Gantt chart helped them create a shared view of their sprint plan which could be used to help them test their thinking/approach. It had a bit of a learning curve and took time and energy to create though, so I’d still caution against “just using it” for the sake of it. However, I’m also now likely to suggest a team tries it if they are experiencing similar planning problems to this team.

Have you ever used a Gantt chart for sprint planning? What did your team learn? Or have you been surprised by some other tool that you’d previously had bad experiences with? What was it and what did you learn?

 

 

My team had been working together for three sprints. During this time we’d been grooming and delivering stories (into Prod) but we had not done any sizing. Our Product Owner and business stakeholders were getting twitchy (“how long will we take?” – see How big is it?) and it was time to use our data to create some baselines for us to use going forward (and, as a side benefit, to find out what our velocity was).

Besides the fact that it was a new team, this team was also very large (15 people), some of them had never done an Affinity Sizing type exercise before, and we were 100% distributed (thanks to COVID19). Quite the facilitation challenge compared to the usual exercise requiring nothing more than a couple of index cards, masking tape and some planning poker cards. This is what I did and how it worked out.

1. Preparation

First, I needed something I could use to mimic the laying out of cards in a single view. As we’d already done three sprints of stories, there were a number of cards to distribute and I didn’t want to be limited to an A4 Word document page or Powerpoint slide. This meant a whiteboard (unlimited space) was required and we eventually ended up using a free version of  Miro.

Second, with my tool selected, I needed to make sure everyone in the team could actually access/use the tool. Unfortunately, Miro does require one to create an account, so prior to the workshop I sent a request to everyone on the team to try and access an “icebreaker” board.

Third, I needed to prepare my two boards:

  • The Icebreaker board which was to serve three purposes:
    1. Give people something to play around with so they could practise dragging and interacting with Miro
    2. Set the scene in terms of how sizing is different to estimating. Hopefully as a reminder to those who already knew, or as an eye-opener to those who might not.
    3. Use a similar format/process to the board I would be using for the Affinity Estimation exercise so that the team could get used to the process in a “safe” context before doing the “real thing”.
  • The Affinity Estimation board and related facilitation resources.

The Icebreaker Board

Ball game start

This layout matched the starting point of the Affinity Estimation exercise.

There was a reminder of what “size” was for the purposes of the exercise in red (1) and instructions for how to add the items to the scale (2). The block on the left was for the “stories” (balls) that needed to be arranged on the scale.

The Affinity Sizing Board

(I forgot to take a screenshot of the blank version, so this is a “simulation” of what it looked like.)

same blank stories

“Simulation”

For the Affinity Sizing, besides the board, I also prepared a few more things:

  1. A list of the stories (from JIRA) including their JIRA number and story title in a format that would be easy to copy and paste.
  2. The description of each story (from JIRA) prefixed with the JIRA number in a format that was easy to copy and paste
  3. I asked one of the team members if they would be prepared to track the exercise and ensure we didn’t accidentally skip a story.

A reminder that at the point when we did this exercise, we were about to end our third sprint, so we used all the stories from our first three sprints for the workshop (even the ones still in progress).

2. The session

The session was done in Zoom and started with the usual introduction: what was the purpose and desired outcomes.

From there, I asked the team members to access the “icebreaker board”. In the end, I had to leave the team to figure out how to use this board for themselves while I dealt with some technical issues certain team members were experiencing, so couldn’t observe what happened. However, when I was able to get back to them, I was happy enough with the final outcome to move on.

balls 2

Round 1: Small to Large

To kick things off, I copied and pasted the first story from my prepared list (random order) into a sticky and the story description (in case people needed more detail) into a separate “reference” block on the edge of the whiteboard. The first person to go then had to drag the story to where they thought it best fit on the scale.

From the second person onwards, we went down the list and asked each person whether they:

  1. Wanted to move any of the story-stickies that had already been placed or,
  2. Wanted a new story to add to the scale

A note here – it might be tempting to have some team members observe rather than participate (e.g. your designer or a brand new team member); however, I find that because mistakes will self-correct, there is more benefit in including everyone in the process.

We repeated the process until all the stories had been placed on the scale. At this point, it looked something like this (again, a “simulation”):

round 1 Round 2: Buckets

At this point I used two data points to make an educated “guess” to create a reference point.

  1. I knew that our biggest story to date was of a size that we could probably fit 2-3 of them in a sprint
  2. I could see where the stories had “bunched” on the scale.

So I picked the first biggest bunch and created a bucket for them which I numbered “5”. Then I drew buckets to the left (1,2,3) and to the right (8,13,20) and moved everything that wasn’t in the “5” bucket down to below the updated scale/grid (but still in the same order left-to-right).

buckets

Before we continued, I checked with the team whether the felt all the stories in the 5-bucket were actually about the same size. They did (but if there had been one that they felt might not be, it would have been moved out to join the others below the buckets). After this point, the stickies that had been placed in bucket five at the start of the process were fixed/locked i.e. they could not move.

Then we repeated the process again where each person was asked whether they

  1. Wanted to move a story-sticky that had already been placed into a bucket, or
  2. Move one of the unplaced story-stickies into a bucket

Initially, some people moved a couple of stories on their turn into buckets, which I didn’t object to as long as they were moving them all into the same bucket. Again, I was confident that the team would self-correct any really off assumptions.

We had one story that moved back-and-forth between bucket 1 and 2 a few times, and eventually, the team had a more detailed discussion and made a call and that story wasn’t allowed to move again (I also flagged it as a bad baseline and didn’t include it in future sizing conversations).

Once all the story-stickies had been placed in a bucket, everyone had one last turn to either approve the board or move something. When we got through a round of everyone with no moves, the exercise was done:

stories

The actual outcome of the workshop

Even with technical difficulties and approximately 15 people in the room, we got all of this done in 90 minutes. This is still longer than it would usually take face-to-face (I’d have expected to have needed half the time for a collocated session), but I thought it was pretty good going. And the feedback from the participants was also generally positive 🙂

These stories (except for the one I mentioned) then became baseline stories for comparing to when we did future backlog refinement. Also, because I now knew the total number of points the team had completed in the three sprints (sum of all the stories), we also now knew what our initial velocity was.

Have you ever tried to use Affinity Estimation to determine baselines? Have you tried to do so with a distributed team? What tools did you use? How did it go?

 

Scrum Ceremony Puzzle

Posted: November 19, 2018 in facilitation, Scrum
Tags: , , ,

Image result for puzzleThis is a “game” I played as a kick-off activity with a new team. Thought I would share in case someone might find it useful 🙂

The basic idea is to match the correct Purpose, Outcome(s) and Output(s) to each Scrum ceremony.

Preparation:

  • Print out the Ceremony Boards (each team will need its own set)
  • Prepare the Ceremony Cards (each team will need its own set)

Game Play:

  • Place the cards on the boards in the correct spaces
  • The cards are colour coded as a Purpose/Outcome/Output to help

How we played it:

  • I divided my participants into two teams and made a bit of a competition of it.
  • Both teams started in opposite corners of the room and ran to a table in the middle to try solve the puzzle.
  • When a team thought they had solved it, they would signal and both teams went back to their respective corners (think “Survivor style).
  • I would then check the solve against my solution. If the team had solved the puzzle correctly, then they were the winners. If the solution was not correct, both teams could return to their tables to continue working on the puzzle.

Feel free to try out the game and give me feedback!

Resources:

I not-so-recently attended the regional Scrum Gathering for 2017 in Cape Town. This is a post in a series on some of the talks that I attended. All posts are based on the sketch-notes that I took in the sessions. 

Image result for help your team

I think a better title for this talk by Gavin Stevens would have been “How to be an awesome Product Owner”.

The basic structure of this talk for Product Owners was:

  1. A dysfunction and how you will notice it
  2. What you (as the Product Owner) can do about it
  3. Some ideas for how you can take action

The seven dysfunctions that Gavin touched on were:

  1. The team has lost sight of the vision
  2. The Corporate Mentality is that the PO is the leader of the team
  3. The team is not autonomous in the sprint
  4. The team isn’t motivated to finish the sprint early
  5. The PO is the middle man
  6. The PO needs to check everything
  7. The PO is not with the team

The team has lost sight of the vision

What you will notice are “weird” statements or questions like:

  • “How does this fit in?”
  • “Why now?”
  • “If I had known…”

The solution is to ask the team those weird questions when they are planning / discussing their work before the sprint starts.

Corporate Mentality: the PO is the leader

You will hear language like “Gavin and team”. Or “well done to Gavin for this great delivery”. The organisation has not yet realised that the PO is a leader – not THE leader.

What you need to do is create an understanding of the team structure. That the team structure is flat and that there is no single leader in a self-organising team.

The team is not autonomous in the sprint

The team doesn’t seem to be able to make decisions about how they work in the sprint. You, as the PO, are always the “go-to” guy.

What you need to do is empower the team.

Some ways you can do this are:

  • Don’t interfere during the sprint. Trust that the team knows what the goal is (because that was your job) and let them decide how to achieve it.
  • You make the decisions about why, and maybe what, but never how.

The team is not motivated to finish the sprint early

The team doesn’t seem motivated to try to achieve the sprint goal before the end of the sprint. This may be because, as soon as they finish, more work is automatically added to the sprint.

You need to create space. People need time to be creative. One way to achieve this is to tell the team that when they hit the sprint goal, the remainder of the sprint time is theirs to do with what they please.

Gavin mentioned that what the team then chooses to do is also often insightful. If they’re bought into the roadmap, they’ll usually choose to pick up the next pieces on the backlog. If they choose to do something completely different, then it’s usually a good idea to question why they feel that the work they chose to do is more valuable.

The Product Owner is the Middle Man

Which also means the PO is a blocker. Because if you’re not there, everything stops.

Some of the signs that you are a blocker are:

  1. You are the admin secretary who needs to check everything before the team releases
  2. Selfish backlogs – no one besides the PO is allowed to touch the Product Backlog
  3. You are a layer between the team and stakeholders

If you find the reason you are checking everything at the end is because it’s not aligned to what you expected, then you need to examine all the up-front areas where you are responsible for conveying what the team needs to deliver the right thing

  • Have you communicated the vision properly?
  • Did you help the team ask (and answer) the right questions in grooming and planning?

Once you believe that you have given the team the right information to build the right thing, then make each team member the “final checker”. Any team member can do that final check that something is ready to release (because a second set of eyes is usually a good thing – it just doesn’t need to always be the PO).

Fixing selfish backlogs is “relatively” easy – let others add to the Backlog. Ordering is still your decision, but what goes onto the list can be from anyone.

The Product Owner needs to check everything

The reason for this is normally related to a lack of trust: this happens when the PO doesn’t trust the team. Some of the signs are the same as when the PO is the middle man.

Building trust is a two-way street: the team need to trust the PO as much as the PO needs to trust the team.

One way to build trust is to create a safe space. Do this by

  • Allowing team members to learn from their mistakes
  • Not blaming
  • Protecting the team from external factors
  • Taking the fall when necessary

A second way to build trust is to tell team members that you trust them. For example, when a team member says “I’ve done all the tests and I think this is ready to go. Can we release?”, then don’t answer with a yes. Rather say “I trust you know when it is ready so you can make that call”.

The Product Owner is not with the team

The Product Owner needs to be available – to the team and to stakeholders. Although the PO should not be a middle man, one of the main functions of the role is to act as a translator between the team and stakeholders. How much you need to sit with your team does depends, and is somewhere on a continuum between “Always” and “Never”.

Some things you can try to make yourself more available are:

  1. Don’t schedule/accept consecutive meetings
  2. If you do have downtime and work in an environment where working distributed would be an option, rather choose to spend it at your desk if possible.

 

I found this an interesting talk and what was especially great was it paralleled much of what we have experienced as a team. Are you a Product Owner? What are your thoughts on what Gavin had to say?

I have a new Product Owner (PO). She is new to the team and also relatively new to the Product Owner role as a whole. One of the things that I have needed to coach her on is Backlog Refinement or Grooming – and how to do so at the various levels of the Product Backlog. This is something I’ve seen many teams struggle with in the past. Either the team sees stories too late (and there’s a rush and they don’t really problem-solve); or they see them too soon (and we go into the detail far too early and forget most of it when/if we eventually pull the work into a sprint); or there’s some gap between understanding the problem and getting into the detail which means some team members get left behind and never really own the work.

So, this time, I decided to try a different way of evaluating how far a story/epic/feature was in its “readiness” journey (and, thus, how much more grooming the team still needed to do and at what level). And, what I decided to try was overlaying the ADKAR change management steps on each of the items that the PO had ordered near the top of our Product Backlog for the next couple of sprints.

So, for each item we care about, we regularly check whether the team has moved through:

1. Awareness

Do they even know this is coming? Do they know what it is? Are they familiar with the domain and the problem space?

2. Desire

Has the team engaged with the problem? Do they understand what we are trying to solve for the user? Do they WANT to solve this problem for the user?

3. Knowledge

Have we covered all the aspects of the problem? Have we started thinking about how we might want to solve the problem and what questions we want to answer or explore? Are we starting to get a feel for the steps involved and how we can break this thing down?

4. Action

We’re doing what we need to do to be ready to start on this work in the next sprint. We’re ensuring ourhighest ordered stories are INVEST.

5. Reinforcement

We’ve finished our story – what did we learn? (The Sprint Review is one natural place where this happens.)

 

Mostly, both in change management and backlog refinement, people seem to tend to launch in around steps 3 (Knowledge) or 4 (Action). Together with the Product Owner, I now try make sure we’ve moved through each of the first four steps (ideally in order) before we pull a story into the sprint. And if we realise we’ve missed a step, we try to go back to it as quickly as we can. This doesn’t need to take long at all – for the Awareness step it’s often just a short communication – after a stand-up, or perhaps in a Review when sharing the roadmap. In fact, for the Awareness step, I’ve noticed that it doesn’t have to be a long thing at all. Often the best way to move teams through the Awareness step is to repeat something brief many times, over many channels, and over a short period.

We’ve been trying this for about two months now and, so far, it seems to be working better than anything I’ve tried before when checking to see that the state of the backlog matches where the team’s understanding is of a particular piece of work. And, because we’re not skipping any important parts of our team coming to grips with the problem, we seem to be uncovering important questions and potential challenges earlier in the process.

What tools have you tried to help with Backlog Refinement? Or where have you borrowed from one problem space (e.g. Change Management) and found it has helped with a challenge in another problem space (e.g. Backlog Refinement)?

Image result for grooming backlog

download In my opinion, one way to make a team coach feel really useless, is distribute their team across multiple locations where it’s really hard to observe their interactions with one another. For me, a lot of my “obvious” work and channels disappeared when that happened and it’s taken me a while to find alternative ways to provide the insights and support that my team needs. I also had to take a step back and acknowledge that when working distributed, certain elements of effective co-located collaboration no longer matter or have negligible impact on team greatness, whereas new elements turn out to be important levers. The trick, it turns out, is to identify what exactly those are. And I suspect, as always, that they will be different for each team.

For example, the daily stand-up or Scrum. A time for the team to sync up and share what happened the day before so that they can plan and adjust for the day to come. An opportunity to celebrate achievements and adjust for disappointments. A good time to interact and build some team rapport. The standard method is everyone stands up (to help maintain focus and brevity) around a task board (for visibility) and speaks to what they achieved yesterday (speaking and moving their tasks to show progress and create psychological ownership) and what they hope to achieve today that will help the team achieve their sprint goal. The Scrum Master and Product Owner observe – and perhaps facilitate – and ask questions where blockers might be hiding in what the team has to say. And the outcome is everyone on the team walks away with a plan for how they will contribute to the team’s success today – and a commitment to each other that they will do their utmost to complete what they have agreed to do for the day.

There are some parallels when we are working distributed – the task board, for example. There are some practices that are just impractical – like standing up. And there are others that may detract more than they add (for example, in our case, it seems less confusing to have one “driver” for the session than to pass control during the stand-up). Sometimes the limitations are tool-related. Sometimes it’s just the nature of working as a distributed team.

So what changes have I tried when facilitating a distributed stand-up? So far, these ones seem to be working:

  1. I try to watch all of the faces. We use Zoom and there is a setting where you can view all of the attendees on a single screen. Whenever we have a distributed meeting – not only stand-up – I spend most of my time and attention watching the faces of the attendees. It’s a good way to notice how people are responding to the session and give clues as to when people are tired (my team can’t do distributed for much longer than 45 minutes), or confused, or distracted, or are trying to ask a question.
  2. I make a note of who has spoken or been “spoken for” in terms of the plan for the day. Basically I listen out for what each person or pair is doing today and at the end of the stand-up, I explicitly ask individuals to share where I haven’t managed to tick them off on my list of names. Note, this is less about everyone having a chance to speak, and more to ensure everyone has made visible to the team what they plan to do for the day. I’ve noticed it’s really hard for my team to keep track of this themselves in a distributed stand-up.
  3. I try to notice if people are trying to say something and find ways to ensure that they get a chance to speak without speaking over the person who is currently speaking. Sometimes this may mean providing an order for people to speak in (you then you then you) if a group happens to accidentally speak over each other.
  4. In my opinion, certain on-line tools (like a digital task board) may satisfy the superficial purpose of the physical tool (e.g. visible stories and tasks for the team to talk to), but not necessarily the deeper purpose (e.g. the psychological ownership that comes with writing and moving a physical sticky). So I’m continuously researching and experimenting with new ways to achieve these outcomes within the context of a distributed team.

For me, the following facilitation activities are still valuable when facilitating  a distributed stand-up

  1. When necessary, introducing the session to re-confirm the purpose and outcomes – especially if there are newer team members or things have started to go a little off-track
  2. Listening out for impediment words
  3. Using open-ended questions to help the team develop insights or notice information

One thing I have noticed, is paying attention in a distributed session is REALLY exhausting. It is also very difficult to split your attention between people “watching” and understanding the content. In my case, I have decided to prioritise the former over the latter, which sometimes leads to other interesting side-effects. On the upside, I’ve become great at asking “stupid questions” 😉

What have your experiences been with distributed stand-ups? What were the challenges? What were the opportunities?

I am currently working with a distributed team and we use JIRA for our sprint task board. We use it in our daily scrum (I can’t call it a stand-up) via Zoom. Over time, I’ve noticed that there are some things that come “for free” with a physical board, but are hidden or not as obviously visible on a digital board (at least not in JIRA). We have found workarounds for some and not for others and, perhaps, depending on the team, not having some of this information “in your face” might be OK. However, I thought I’d make a list of things to look out for if you happen to be using a digital rather than physical board for your team. Also this blog is all about learning 🙂

Please note, I’m only basing my observations on JIRA for this blog post because that is what we use. I suspect that most digital task boards have similar issues.

1. Who’s doing what?

My teams in the past have used personalised avatars to indicate who’s doing what task(s) for the day. We found this had two related benefits:

  1. You were naturally constrained to the number of avatars you happened to have available to you (although it was still fairly easy to take on more merely by initialing the sticky).
  2. It was very easy to see at a glance where a task had too many people, or where one person seemed to have spread themselves to thin, or where someone hadn’t committed themselves to a task.

When asking the question, “what do you notice about our focus?”, it was easy for the team to notice where they may have over- or under-committed themselves for the day. Or to notice and confirm where they were swarming for the day.

In JIRA, only one person can be assigned to a task. It’s not visually obvious where multiple people are working on a task. Also, because we usually only expand the story we’re currently talking about – and usually our full sprint of stories doesn’t fit into the view if we expand all rows – it’s very hard for the team to see good and bad patterns in how they have allocated themselves to tasks for the day.

2. Where are we stuck?

One of the tools one can use on a physical board when it seems a team is taking a while to get things done, is to start dotting tasks. The idea is that a task gets dotted for every day that it has been in progress and not finished. As the task develops measles, it’s pretty obvious where someone may be blocked or may need help.

JIRA does have the concept of task-dotting, but it’s very hard to see (it’s a light gray) and unfortunately the dots don’t stick around. They disappear as soon as someone moves the task to the next column on the board (so, for example, a task that may have been in progress for two days will suddenly have no dots when it moves to the show me column).

When dots have measles, it’s easier for the team to notice where tasks are dragging on for days and do something about it. You don’t really want tasks that have started to take more than a day to finish.

3. How big is our story?

This is probably (hopefully?) a JIRA funny. When we’re viewing the active sprint and sprint board, the story points aren’t visible. Assuming you use story points, they can be useful in helping the team notice when a story is taking too long – a supplement to the burn-down (see below) and tasks with measles (point 2 above). We have a workaround in that we add the story points to the end of the story title. It would be cool not to have to do this.

4. What’s our progress?

JIRA generates a pretty cool burn-down. But it’s not visible on the sprint task-board (which is the view we use for our Scrum meeting). How you’re doing on your burn-down is quite an important piece of feedback for how to adjust your plan for the day. Our workaround is to publish it on Slack before we meet, but it would still be useful to have it visible for the conversation.

5. What’s our goal?

I love (good) sprint goals. I find they give the team something specific to aim for that still allows for creative ways to respond to minor changes that emerge during the sprint. Goals are also a really useful way to bring the team back to the bigger picture in terms of sprint progress: “Are we on track to achieve our goal?”; “What are you doing today to help the team achieve the goal?”. So we create an awesome team sprint goal and ideally we want to have it front-of-mind when planning our tasks for the day. On a physical board, this is easy: it can be as simple as printing your goal on a piece of paper and sticking it to the board (ideally in colour and with sparkles). On a digital board, one needs to get a little more creative. In our case, we write the goal as a story at the top of the sprint and try remember to refer to it before we start our daily conversation. It seems to be working, but it does blend into all the other sprint work.

6. There are other aggregate data questions that are harder to answer

As Jacques de Vos once said: “If you have to scroll, you can’t see the whole“.

With a physical board, the team can usually notice useful things when answering questions like:

  • What do you notice about our tasks in progress?
  • Where do we seem to have the most focus?
  • What do we notice on the board about stories not started?
  • What do we notice about the state of our overall sprint in terms of stories in progress and not started?

Usually a quick glance at how stickies (whether stories or tasks) are grouped in the various lanes of the task board can provide a lot of insight into how things are going – especially if the distribution pattern is looking different to what the team is used to and/or expects to see. With JIRA, this view isn’t easily available. Expanding all of the rows creates a very busy view which is also not guaranteed to fit without the need to scroll. Collapsing the rows hides the task distribution (which may hide other things) and also the story status is represented by a word rather than the story’s location relative to the board’s columns and other stories.

7. There’s usually a driver

The way we use JIRA, someone screen-shares the taskboard in our Zoom session and that person automatically becomes the ‘driver’. What I’ve noticed about this is:

  • People are less likely to interact with the board during stand-up: they’d rather ask the driver to make updates or create emergent tasks
  • Some people are scared to drive (probably a tool thing – either JIRA and/or Zoom), so never do
  • The driver can get distracted by the mechanics of having the right story expanded, or making changes in JIRA, or whatever – so are not always fully present in the conversation
  • If the driver ends up being someone in a “leadership” position (e.g. a senior developer, the Product Owner), then sometimes they subtly control the decisions the team makes in terms of what they plan to do for the day because they can move things or assign things before the team have finished their discussion
  • All of the above means that the negative aspects of “you do it, you own it” sometimes sneak in…

I shared some of these challenges on the #zacoachclub channel in the Coaching Circles Slack Group and got some useful ideas to try out:

  • Write down in detail what information you really need the board to show so that it becomes your information radiator. Then lose all pre-conceived notions of how a board should look and how your tool sets up its boards. Based on the info you need: what could a board in your digital tool look like?
  • Try to represent the info you need in something other than your tool (i.e. JIRA) – maybe Google Draw or something. Once you have something that works, try implement that in your digital tool.
  • If the problem is too many things on the board, could your sprint/commitment be smaller to fit everything in one view?
  • Create a filter that filters out “old” done items and try to only work from the top story (limit work-in-progress).
  • Shift some of the information elsewhere e.g. Say pairs work on the story – they break down tasks in another place (Trello?) and feed back only relevant info to the greater team on the story which is in JIRA. Feedback to their mini team is much more granular and on another board/tool.

Do you use a digital board on your team? What challenges have you experienced? What did you try?

Scrum-Task-Board