As an intern here at Boost I have had the privilege of working with a group of experienced and friendly developers. I have been here two weeks now and already feel settled in completely. One of the great things about working for Boost is that everybody is very approachable when you need to ask for help or when you need things to be elaborated. This has made the transition from university to industry easier than I initially expected.
Here at Boost we use the Agile software development methodology known as Scrum. So every day I have a stand up meeting with my scrum master (Jacob Creech) and product owner (Nathan Donaldson) where I go over what I have done, what I will be working on today, and discuss problems that I need to get out of my way. So far at Boost I have been working on bug fixes for our online usability testing tool IntuitionHQ, which is built in Ruby on Rails. Working in this way has helped me get my head around the large code base that I will gradually move towards developing features for.
The IntuitionHQ Scrum Board
Using Scrum means that I’m working in ‘sprints’, or two-week long development periods. Each bug in IntuitionHQ is written up as a user story. At the start of my first sprint I took part in a sprint planning meeting which included sizing the stories (assigning them points between 1 and 8 to indicate their complexity/the effort required to fix them) and then breaking the stories down into tasks. I had to indicate how many of the stories I could commit to in the two-week sprint, and how confident I was that I could complete them in that time frame.
As an intern I was not really sure how much I could complete, being new to Rails and working in the industry in general. But one of the cool things about Scrum is that at the end of each sprint you have a sprint retrospective. This is a chance to talk about how the sprint went, and what can be done to improve things. If I don’t complete all my stories in the first sprint, the next sprint will be adapted to deal with this, and so on and so forth. So in the case that I didn’t complete all my stories it will be known for the next sprint to take on less stories in relation to their size. Overall, this is about figuring out your ‘velocity’ – how many story points you can get done in a sprint.
For my first sprint I initially committed to seven stories. I ended up completing the stories early and brought in two more stories from the backlog. One of the fun things I have found about fixing bugs is it really stimulates the mind’s problem solving abilities. I developed most of my problem solving abilities while doing my Software Engineering degree at Victoria University. Although university is a great learning environment I have found that learning in a working environment has more merits. This is because you are working with a group of people towards a common goal so they are more likely to help you out and I find that social learning is the best way to learn. This differs from university as everybody in your papers are competing to get higher grades than you so they generally don’t feed you all the facts.
One of the cool things about coming out of university into a working environment is that once you get home from work it’s your time, not stressing-about-assignments time. I believe that the less stress you have weighing on your mind the more productive you can be. Not being stressed out has helped me to be more productive working here at Boost and has got me highly motivated and keen for my next sprint. To sum up my experiences so far I would say that working here has been awesome!
Courtney is a former General Manager of Boost, she can now be found gracing the halls of the Dowse Museum as their Director.
Author Slide Up
[Here's the tl;dr version of this blog post. Every Friday we run free workshops about Agile development here at the Boost offices in Wellington. To find out more, read on. To sign up, scroll down to the end of this post, or email [email protected]]
Here at Boost, we’ve been using Agile development practices – Scrum in particular – to run our internal projects for five years, and with our clients for three years.
We keep meeting more and more people curious about how using Agile might help their organisations. So a few months ago we sat down and developed a two-hour workshop, Introduction to Scrum, which introduces the main Agile ideas and practices, with a special focus on the Scrum techniques that we use. We tested the workshop with clients and other people, and got really good feedback.
We’re now opening the workshops up to the world. There’s a workshop session available every Friday from 2pm to 4pm, and we’re alternating between Introduction to Scrum and Writing Great Agile User Stories. Further workshops are being worked on right now.
Workshop 1: Introduction to Scrum
The Introduction to Scrum workshops are run by Boost’s managing director Nathan Donaldson, a certified Scrum master.
We start off by talking about where Agile has come from, and how it’s different from traditional Waterfall development.
Then we’ll talk about the different roles in Scrum:
We’ll cover off the core ‘artifacts’ in Scrum:
And then run you through the Scrum sprint rhythm:
After this, we’ll talk about some of the improvements we’ve seen in projects and organisations that have adopted Agile, like more communication, better specifications, less waste and less rework, better prioritisation and planning, and happier, more productive teams. And we’ll talk about the challenges that have to be overcome when Agile practices are introduced into an organisation for the first time.
And in the last five minutes we’ll run a quick retrospective on the session, so you can tell us what you liked and what we could improve. Continuous improvement is one of the core principles of Agile, and we apply it to these workshops too.
Workshop 2: Writing Great Agile User Stories
Writing Great Agile User Stories is run by Courtney Johnston, one of our project managers, a certified Scrum master and experienced Product Owner. The workshop is a focused and hands-on introduction to writing user stories and creating a product backlog.
How to write user stories
How not to write user stories
How to write acceptance criteria
About Done definitions
How to create and maintain your product backlog
How user stories are estimated by the team.
As with Introduction to Scrum, at the end of the session we do a quick retrospective to figure out what worked well, and what improvements we can make.
Who are the workshops for?
Introduction to Scrum
This workshop will be helpful for anyone involved in website and software development. We’ve had project managers, usability analysts, programmers, designers and writers attend, and everyone has found something useful in them. It doesn’t matter in the least if you’re public sector, private sector, work for a charity or a start-up, or are just plain curious.
Writing Great Agile User Stories
This workshop will be helpful for people who have already had some experience or exposure to Scrum, and who want to learn more about this particular aspect. It will be especially helpful for people new to or thinking of taking on the Product Owner role.
How many people can attend?
We cap attendees at 6 people; this is the best number for discussion and sharing experiences.
You can come along as a team – that way, you can talk about how you manage things currently, and what you’re looking to change. But we’re also happy for people to sign up in ones and twos; it’s just as useful and sometimes even more interesting to have a bunch of different perspectives in the room.
Where are the workshops held?
We hold the workshops here at the Boost offices in central Wellington. You won’t be trapped in a stuffy little room – it’s nice and spacious, with great views over Cuba Street.
What does this cost?
Nothing. The workshops are completely free, and completely obligation free.
We’re running these as free sessions for two reasons:
We really think people would benefit from using Agile methods to run their projects
We’ve learned a lot from the Wellington and international Agile communities, and want to keep the sharing going
Then we talked about the how. How do we know which practices we should be using, or trying to improve? So things like, if a product owner keeps rejecting delivered work, maybe we need to look at the way acceptance criteria and done definitions are being stated, because there seems to be gap between what the developers are hearing and the product owner is seeing. Or things like holding regular product backlog grooming sessions, so we know we’re always working on the most important features for our product. As Jean observed, this is how you avoid getting trapped in cargo cult Agile – going through all the right motions, but not seeing the expected benefits.
In that discussion, we started digging into the principles of Agile – the why. Why is it that we and our organisations have decided to adopt Agile? For some people it was about increasing returns, or decreasing risks; for some, it was about improving the quality and timeliness of work delivered; for some, it was about team morale. Everything about your take up of Agile needs to stem from this why – if you don’t know why you’re doing something, why bother?
Back at work I started reading over the Rally blog, and found this post from Jean about being a newbie on the Project Management StackExchange. This is one of 50-plus question and answer sites on the StackExchange network, where people can ask and answer questions on specific topics. The StackExchange sites are known for their exemplary community management (and Jean’s post gives a great insight into how this works). In fact, one of my favourite Webstock 2010 talk was Jeff Atwood’s Stack Overflow: Building Social Software for the Anti-Social, about creating the first of these sites, devoted to programmers and their detailed technical questions.
Nathan is Boost's Managing Director, sole owner and Scaled Agile Framework expert. When he's not in Boost Agile's Shanghai office he can be found at his South island office in picturesque Queenstown.
Author Slide Up
Here at Boost we’ve been running Agile projects (using Scrum) internally for about five years, and with clients for more than three. Constant refinement and improvement is a key aspect of Scrum processes, and for our scrum masters in particular (myself, Gavin, Kriston and Courtney) looking for ways to tweak our projects is a big part of what we do.
One way we do this is by trying practice runs of new processes internally before we unleash them on our clients. Recently we trialled story mapping as a different way to generate user stories, and then tested two different ways of prioritising the stories into a product backlog. We learned a lot from this, and are looking forward to trying it with clients soon.
What is story mapping?
Jeff Patton has done the most to formulate the method of story mapping, and he contrasts it to the traditional ‘flat’ product backlog. Patton argues that while a flat product backlog is good for helping the team understand what needs to be done next, it doesn’t help the team see the big picture of what they’re making:
Arranging user stories in the order you’ll build them doesn’t help me explain to others what the system does. Try handing your user story backlog to your stakeholders or users when they ask you the question “what does the system you’re building do?”
For my money, trying to understand the system – the whole system – is the difficult part of software development. One of the most common complaints I hear from Agile teams is that they lose the big picture – that is if they ever had it in the first place.
… [A] story map arranges user stories into a useful model to help understand the functionality of the system, identify holes and omissions in your backlog, and effectively plan holistic releases that delivery value to users and business with each release.
Occasionally on our Agile projects we’ve run into the problem where, although we’re working in order of priority and regularly delivering new functionality, it still feels like that new functionality isn’t building into a cohesive whole for users. We decided to try out story mapping to see if it might help in these situations.
Generating the stories
For the trial we had:
the four scrum masters (me, Kriston, Gavin & Courtney)
a big empty wall
some builders tape, lots of Post It notes, and a bunch of Sharpies
I facilitated the story mapping, and Kriston, Gavin and Courtney took on the role of the team. Gavin was our Product Owner, and Kriston & Courtney played the part of topic specialists, there to advise the Product Owner on business and user needs. (Any combination of people could form the team for this exercise, but it’s important to make sure that the Product Owner continues to be the person making decisions about priorities based on business value, with everyone else there to advise and support them.)
The scenario we used was imagining we were going to launch an online card-sorting tool to complement IntuitionHQ, our online usability testing tool.
First, I asked the Product Owner ‘What will people do with this tool?’ (this is a more user-focused way of asking ‘What will our software do?’). The team brainstormed the high-level activities:
manage the site (admin features)
open and manage an account
create and distribute a test
The Product Owner wrote each of these down on Post Its and and placed them in a row above a strip of builder’s tape on the wall.
Next I got the Product Owner to brainstorm the user stories that fell out of each activity, and stick them up in columns under the related activities. For example, under ‘Open and manage an account’, we had the user story As a IntuitionHQ customer, I want to log into the cardsorting tool with my existing account details, so I can get started testing quickly. We ended up with about 25 user stories across the four columns.
'Wall' with stories arranged into groups
Prioritisation 1: traditional method
At this point, the user stories were in random order in their columns. Next I got the Product Owner to order them from most to least important within their columns.
After the stories were prioritised, I got the team to work together to identify a ‘walking skeleton': the stories from each column we’d have to complete in order to have a first release of the software that was both high value and immediately useful. We put a line of builder’s tape across each column where the cut-off point fell.
'Wall' with priortised stories
Prioritisation 2: ‘buy a feature’ method
Next we tried another way of selecting stories for the first release. We went through and roughly sized each of the stories, allocating 1, 2, 3, 5, or 8 points to each (in the real situation, we’d have the people working on the project estimating like they normally would).
Then I gave the Product Owner a ‘budget’ of $30 to ‘buy’ the stories they wanted to see in the first release (with ‘buy a feature’ prioritisation, you use a budget of between 1/3 and 1/2 the entire system budget, to force decision-making.) The ‘cash’ was in the form of small Post Its with $5, $2 and $1 written on them – so to buy an 8 point story, the team had to pony up a $5, a $2 and a $1.
'Wall' with stories prioritised by 'buying' features
What we learned
It was fascinating watching the team change their mind about priorities with this spending limit in place. For example, in the first prioritisation, the story As a IntuitionHQ customer, I want to log into the cardsorting tool with my existing account details, so I can get started testing quickly didn’t make the cut as a first release. In terms of opening and managing an account, this was originally seen as a nice to have, compared to the functionality to create a new account. When faced with a limited budget however, the team decided this was the only story they wanted to buy from the ‘Open and manage an account’ column, reasoning that for a beta release, they’d be happy to offer the site just to existing customers. This released more cash to buy the essential stories associated with creating and distributing tests, and collecting and displaying results.
Based on current and previous projects, we know that a point usually represents about three hours work. Using this technique of estimating and ‘buying’ stories, we know we’d be able to give a client a reasonably accurate picture of what we’d be able to deliver within any given budget.
Where we think story mapping will be useful
The scenario we picked – building an online card-sorting tool – was quite simple, and as we’ve built something similar we had a good understanding of what we’d need and how much work was involved. Our story mapping exercise was therefore quite straightforward, and we completed it in under two hours. In his article ‘How you slice it’ (download the PDF) Jeff Patton describes how to run a far more complex story mapping exercise. The overall goal remains the same: a useful and highly usable first release, which sets the stage for further iterations. As Patton writes in the article:
Incremental release may be one of the more valuable aspects of the various Agile development methodologies. An early release can help capture market share, generate early return on investment, and reduce money risked on software development. A strong early release can increase those benefits immensely. The model we’ve built can give you a better picture of your software’s features and help your organisation construct the most useful and coherent early release possible.
We can see a number of situations where this technique will be useful
at the beginning of any Agile project, when user stories need to be written and prioritised
particularly, at the beginning of projects where the software or product is intended to do a number of different things
when you’re working with a team that has previously felt like it doesn’t have the big picture of a project
when a product owner is finding it hard to prioritise stories for the first sprint or first release
when a product owner needs support getting stakeholder agreement on how features and stories are to be prioritised.
More background on user stories
Want to know more? Check out our introductory series
Courtney is a former General Manager of Boost, she can now be found gracing the halls of the Dowse Museum as their Director.
Author Slide Up
For the past three weeks I’ve been trialling a new form of to-do list, inspired by the Agile visible workspace. It’s a literal desktop solution: it involves three pieces of tape, some Post It notes, and the right-hand side of my desk. So far, it’s been awesome. Here’s the story …
Since joining the working world, I’ve tried all sorts of ways of listing and prioritising my work: mentally (yeah, like that was ever going to work), with various online tools (always felt like too much overhead, and like I had to go somewhere to see what I should be doing), by blocking time out in my diary to focus on chunks of work (awesome, right up to the point when someone books over your work time with their meeting time) and paper lists (my favourite, but they have a tendency to breed promiscuously on my desk, resulting in archaeological layers of half-done lists doing double-time as a place to rest my damp-bottomed mug of tea).*
Over that time, I’ve found Agile visible workspaces to be the best form of to-do list for me. The whole point of the Agile board is to show what work has been committed to (through user stories), the priority of each story, the task related to each story, and the stage each story and task is at. (You can read more about how this works in our earlier post on user stories and the Agile development practice.)
Scrum Board by Drew Stephens on Flickr, released under a Creative Commons BY-SA license
My ideal situation then would be working full time on one of our Agile projects. At the moment however, while I contribute to one of our large Agile projects and run a couple of smaller ones, I’m spread over multiple projects and clients. So I started thinking about how I could adapt what I enjoy about the Agile workboard to my own case.
First I thought about what I needed. I wanted:
to keep track of the various tasks I needed to complete for each of my projects and clients
to see these tasks at all times, but not keep a whiteboard by my desk
to know what my backlog of tasks was
to be aware of which tasks were ‘blocked’ (for example, where I was waiting on client feedback before making the next set of revisions to wireframes).
I decided on a super-simple solution. I cleared some space on the right-hand side of my desk (to the right of my mouse, so firmly in my peripheral vision). I tore off three bits of blue builders tape (the kind that doesn’t mark surfaces) and used them to create three boxes on my desk top, and used a Vivid to mark these as ‘NOT STARTED’, ‘IN PROGRESS’, and ‘BLOCKED’. Then I wrote down each of my tasks on one of the smallest sizes of Post It note (5x5cm), and stuck these in the ‘Not started’ box. I tried to keep my tasks to about three hours’ work or less (so not prepare workshop but prepare card-sorting exercise; not write strategy but research governance models).
After that, I moved the tasks that I needed to work on that day into ‘In Progress’. There were about 6 of them, which isn’t ideal – not a lot of priority there. When Nathan (the boss) looked at my new visible workspace, he suggested that I try the Kanban technique of limiting how many tasks can be in progress at any given time. So I got out my Vivid and added (3) to my piece of ‘In progress’ tape.
I’ve trialled my simple visible workspace for the past three weeks. In that time, I’ve prepared and given a user-testing workshop, worked on strategy documents for two clients, worked on wireframes for one of our large Agile projects, overseen some online user-testing for a client, kept the wheels turning on two development projects, and done miscellaneous other stuff. And I’ve found my visible workspace works really well.
I can see at a glance all the work I need to do. I make decisions every morning about which tasks to move into ‘In progress’. When I’m waiting on feedback or decisions, tasks go into ‘Blocked’ (so I don’t forget about them) and new tasks move into ‘In progress’. I haven’t gone to the level of writing acceptance criteria for my stories, as I know these already.
The one thing I miss is done stars. On our big Agile boards, when a story is completed and accepted by the product owner, it gets a lovely big orange star-shaped Post It note slapped on to it during the stand-up and everyone gets to share in the glow of a job well done. When I complete a task, the Post It note gets crumpled up and tossed in the bin. The result is the same – the task moves out of the backlog of work – but the effect is certainly lacking. This reinforced for me how well Agile supports team building and team morale through very simple practices. However, having my own set of gold stars feels a wee bit over-indulgent, so I’m sticking with my more puritanical ways.
*All this makes me sound rather unfocused. I like to think that the amount I angst over my to-do lists is a sign of how much I like to be organised, not how little.
Today’s post is about how you can use user stories (and other tactics) to engage stakeholders in an Agile project.
It might sounds like user stories are being proposed here as some kind of magic bullet for any and all project woes. They’re not. User stories are a tool, and like any other tool, if they’re badly used or ill supported they won’t bring you the benefits you were seeking. Equally, when well used they not only underpin a very effective development process but can also be used to communicate project progress and decision points to people outside the development team (aka stakeholders).
What’s a stakeholder?
As noted in the post about the development process, in an Agile project there are three roles: Product Owner, Scrum Master and team member. Only people doing actual work are in the team. Only people who are in the team go to stand-ups, retrospectives and planning sessions. It might sound blunt, but that’s the way it works best.
I usually define ‘stakeholder’ as a person outside the team who has a direct interest in the project’s outcome. (This is another good definition.) They might be paying for the project, they might be ‘sponsoring’ the project within an organisation, they might be the people who work with the end customers. They are the people who the Product Owner needs to take direction from and report back to.
Product Owners and stakeholders
The relationship between the Product Owner and project stakeholders can be a delicate dance. Ideally, the Product Owner will be someone who the stakeholders really trust. The Product Owner is constantly making decisions for the project, and needs to have the confidence to make these without referring back to the stakeholders in each instance. Equally, the Product Owner needs to keep stakeholders advised of progress, and get sign off on any necessary decisions.
I’ve been the partner in these dances before, and I’ve learned it’s something you get better at the more you practice. Here are a few things that I’ve found work well.
Before you start writing user stories or anything else, bring the whole team and all the stakeholders together. Get the stakeholders talking about who their customers are, and what they want to make for them.
In these meetings, we often use a variation on the project success slider tool to understand the environment we’re working in. Often stakeholders are under pressure: a limited budget, a tight timeframe, a group of customers who they need to deliver a new service to.
Project Success Slider from LibraryTechNZ
At Boost we used a modified version of the sliders, where each factor can be awarded a value between 1 and 7, but only 28 ‘points’ are available to be awarded. We find the exercise has two benefits:
Everything gets discussed out in the open, and the group has an objective and visual way of reaching consensus on what the project needs to do in order to be successful (e.g. “We’ll accept delivering beta software that’s 80% in terms of our quality criteria, if it means that we hit our deadline and we have all the functionality we wanted to get out there.”)
An understanding is reached that can be used to make decisions later in the project. Say the group decided that staying within budget was more important than the timeline. Now imagine a scenario where a key team member has to take two weeks’ sick leave a month before launch. Going back to the original values, you decide to push out the launch and wait for the team member to come back to work. If you’d decided timeline was more important than budget, you might decide to bring in a contractor to take the team member’s place to get the work done in time for the scheduled launch.
Priorities and the product backlog
I don’t advise getting stakeholders involved in writing user stories, or doing the prioritising. However, they are likely to want – and warrant – insight into what’s being prioritised and why. And you as product owner need to make sure you’re still making decisions according to the business’s needs (and that the business needs haven’t been changed without anyone telling you).
A technique that’s worked well for me in the past looks something like this. The afternoon before the sprint retrospective, but after I’ve prioritised the user stories for the coming sprint, I have a meeting with the project stakeholders/sponsors. I show them the work that’s been completed since we last met, and present anything that needs to be signed off as a milestone. I explain what I’m trying to achieve in the next sprint. Then I confirm that my priorities are still the right priorities.
I usually use Pivotal Tracker and show stakeholders a view where completed stories are presented in one column, current sprint stories in the next column, and the unstarted stories in the last column. It’s a project update in one screen. Then if they chose to reprioritise anything, they watch on the screen as I drag and drop stories around. It demonstrates very effectively the impact of these decisions on when work is likely to get done.
Because the focus with Agile is on regularly delivering deployable software, you’re in the happy position of frequently showing stakeholders completed chunks of work. And because user stories are written in plain language, when you look at a list of completed stories it’s easy to understand exactly which features and functionality have been completed – even if you’re delivering something hard to demonstrate, like setting up a server or fixing bugs.
Between demonstrations and the user stories, I’ve found there’s rarely any need to write project update documents. It’s obvious what’s been completed, and what remains to be done. It’s also possible to see if you’re working more slowly than you expected, and therefore need to start thinking about getting more people into the team, or freeing up more of existing team members’ time for the project.
The things you’re already doing as part of an Agile project make good communication tools when you’re talking to people outside the project. You can do reporting without the overhead involved in writing reports, and you can stay within the spirit of the process. All of this helps develop people’s understanding of how web and software projects happen.
That’s all for this week. The next post will look at trouble-shooting some of the common challenges faced on Agile projects. Thanks for reading!
Courtney is a former General Manager of Boost, she can now be found gracing the halls of the Dowse Museum as their Director.
Author Slide Up
Welcome back! So far in this mini-series I’ve covered the basics of user stories, and added some detail in the shape of acceptance criteria. Today’s post is about the INVEST model for writing user stories, but for that to make sense you need to know how an Agile project is run.
If you’re already familiar with Agile development, you might like to skip down the page to the section about the INVEST model. Otherwise, go make yourself a cup of tea and then settle in for a description of the Agile development process from the Product Owner’s point of view.
Agile / Scrum
Scrum is the form of Agile development that I’m most experienced with, and the one we follow here at Boost.
In Scrum, the development of your product (a website, a piece of software, an application) is split into a series of iterations, called sprints, each of which is usually between 2 and 4 weeks long. The number of sprints in your project might be determined by budget (how many staff, for how long, can we afford to put on this project?), time (how long until we need to have something live?) or experience (how long has this kind of project taken us in the past?).
Scrum relies on a self-organizing, cross-functional team. The scrum team is self-organizing in that there is no overall team leader who decides which person will do which task or how a problem will be solved. Those are issues that are decided by the team as a whole. The team is cross-functional so that everyone necessary to take a feature from idea to implementation is involved. These teams are supported by two specific individuals: a ScrumMasterand a product owner. The ScrumMaster can be thought of as a coach for the team, helping team members use the Scrum framework to perform at their highest level. The product owner represents the business, customers or users and guides the team toward building the right product.
Product Owners and Agile
I’ve been a Product Owner for a number of projects, and it’s a role I find immensely satisfying. You’re the voice of the customer on the project, and it’s your job to make sure that the work the team is doing matches the business’s needs. As Product Owner you don’t necessarily need to be a technical expert, but you do need a deep understanding of your business and your customers, and the confidence to make fast decisions.
The Product Owner manages the product backlog, the list of all the things the product needs to be and do. The product backlog is made up of user stories, and your first task in a new project is to sit down and write all the user stories you can think of right now (one of the beauties of Agile is that you can keep adding, removing and modifying user stories throughout the project) and then prioritise them.
Handing over the user stories: sprint planning
The sprint planning meeting is where you see the user stories being put into action. It’s attended by the Product Owner, the Scrum Master, and all the development team.
In the first part of the meeting the backlog will be put in front of the team (perhaps as a spreadsheet, or using a tool like Rally or Pivotal Tracker, or as a bunch of index cards). The team will then ask you questions about any of the user stories that aren’t immediately obvious, and you’ll talk about acceptance criteria. Through this conversation the team will decide which user stories will be tackled in the coming sprint, and what the sprint objective is. You might write this up as a sprint goal: “At the end of this sprint we’ll release the sign-up/log-in functionality to the live site”.
The user stories taken on for a sprint become the sprint backlog. This is all the team will focus on during the sprint – only the Product Owner will be looking at the rest of the product backlog.
The Product Owner isn’t usually present in the second part of the meeting, but I’ve sat in on these sessions (and kept my mouth shut – no doubt a surprise to anyone who knows me well). In this part of the meeting the team puts estimates on each of the user stories. Estimates can be expressed in different ways (story points, complexity points, team hours) but the general idea is that estimates show how much work a user story involves, and are used throughout the project to manage workloads, and predict and track how much work can be done in a given amount of time.
When the estimates are locked in, the team starts work.
User stories throughout a sprint
During a sprint each story will go through a number of stages:
These stages are tracked through online tools like Rally or Pivotal Tracker or with a visible workspace.
Scrum Board by Drew Stephens on Flickr, released under a Creative Commons BY-SA license
During the sprint, the team will hold regular stand-up meetings (maybe every day, maybe on Mondays and Thursdays – whatever works for the pace of the project). As the name suggests, the meetings are held standing up – a physical signal to keep things snappy. At the stand-up the team members will update which stage each user story is at, and talk briefly on three points:
What I did yesterday (or over the time since last stand-up)
What I’m doing today
What’s blocking me (anything that’s stopping them from progressing a user story – e.g. “I haven’t got the wireframes, so I’m blocked on starting the design”).
It’s good to have the Product Owner at the stand-ups, so they can answer any questions on the spot. You’re also likely to be called on throughout the sprint, to review wireframes, to give design briefs, to test out functionality, to answer questions about business needs. As work is completed, each user story will be assigned back to you to ‘accept’ or close: work on a story is complete when the user can achieve the stated goal, and all the acceptance criteria are met.
The aim is to get all the stories in the sprint backlog done before the sprint ends. Stories that run over several sprints are probably badly written (see the INVEST model at the end of this post).
At the sprint retrospective
At the end of the sprint, the team meets again to demonstrate the completed user stories to the Product Owner. Nothing should come as a surprise (you’ve been involved in the work throughout the sprint) but that doesn’t mean you won’t get a sense of delight at seeing finished functionality that’s ready to be released.
The Scrum Master will then lead the team (including the Product Owner) through a retrospective, an analysis of what went well in the sprint, what didn’t go well, what could be changed to make things go better, and any ideas that might improve performance or productivity.
Before the sprint retrospective you’ll have reviewed the product backlog (probably in a meeting with the Scrum Master) and done any rewriting or reprioritising of user stories. After the retrospective the sprint planning starts over again.
Independent Negotiable Valuable to user or business Estimable Small Testable
‘Good’ here means ‘good for making this whole process work smoothly’, which is why we’ve walked through how a sprint plays out before coming to this definition.
Independent The story stands alone. Stories that are highly dependent on each other are hard to prioritise (“all the stories are equally important”) and hard to estimate (“I can’t put a time on that until we’ve finished that other story”). Problems with dependencies can be solved by dividing stories differently, or combining several small stories into a single larger one.
Negotiable Remember card – conversation – confirmation? A story should be the starting point for a conversation and an opening for the team to suggest a solution, not a detailed description of how the Product Owner expects that feature or piece of functionality to be implemented.
Valuable It’s all about the end-user. If you can’t describe the value a customer is going to get out of your story, it’s not a good story.
Estimable No estimate, no entry into the sprint backlog. If there’s not enough information or definition to allow the team to put an estimate on a story, it doesn’t get started.
Small A story shouldn’t take longer than a sprint to finish. Any larger than this and it’s hard to estimate or plan for. It’s also likely to be hard to write acceptance criteria and to test.
Testable If you can’t test it, how do you know when a story’s done and working as it should?