Methodology

Another way of prioritising stories

One of the cool things in Agile is the way we prioritise stories – functional and technical requirements. With the stories being cards it is easy to shuffle them about on the table and move them up and down a hierarchy of importance. Trouble is such a simple idea often fails to provide the simple desired outcome.

Problem 1.
Prioritisation is difficult. Bad experiences with IT often lead the business to believe that anything given a low priority is effectively being de-scoped and thus are reluctant to mark anything low.

Problem 2. Relating the prioritisation back to the business objectives. If it is not made clear before (and during) the exercise that the prioritisation should be based upon business objectives (for example we are doing this project to reduce costs or drive revenue) stories tend to be prioritised according to the personal agendas. So the marketing stakeholders will be pushing content management to the top of the pile, change management will be pushing training and support tools, IT will be pushing diagnostic tools… and the high priority stories become a disjointed list of features that do little to address the business objectives.

Problem 3. The language of prioritisation. Often it is not clear why we are doing the prioritisation. The business wants the project with all its features – otherwise why would it have identified them in the first place. MoSCoW – must have, should have, could have, want to have softens the language of “high, medium or low” but there is still a bucket of “W – want to have” which in effect is perceived as “won’t have”. Doing away with language altogether can be more effective, but ranking the stories tends to lead to clusters and moving things out of the clusters (i.e. assigning lower priority) tens to be painful.

Problem 4. Highest priority stories do not make a release. Let’s be clear, more often than not the objective of the prioritisation exercise is to drive some sort of release plan. To be successful a release should constitute a meaningful and coherent collection of stories that drive business benefit. Logging in to your shopping cart is deemed as being of high business benefit, password reset and logout low priority. Yet without these the release is incomplete.

So what to do?

The concept of a tree is useful, there are roots that are essential, a trunk, branches and leaves (and the leaves can be pruned by the conscientious gardener to produce the perfect tree), but this approach does not really address problem 4.

We’ve started trying a new approach which seems to work. You are open and honest about the purpose of the exercise. It is all producing a high level feature plan to inform the way we will develop (and maybe release) the software. We make it clear that it is not about fixing scope or producing a release plan that we will all be held to (things change right?). You lay all the cards on a central table, spread out and not overlapping. There are four separate tables labelled A-D (or however many ‘releases’ you aspire to). These are the following:

Table A – If you could launch the product tomorrow, what is the bare minimum you would require to satisfy immediate requirements of customers and the business?

Table B – What would your customers require next? What would does the business need next?

Table C – You’ve been live for a while, what comes next?

Table D – These are the final features that are important but not mandatory on tables A-C

It is important that the cards do not have titles on them. That way the people prioritising them must read them (and understand them) before assigning each card to a table. You then prioritise in time boxed iterations (it can be useful to have an egg timer to help this). In the first iteration you ask everyone as individuals to pick a card from the centre and place it on a table. Remind them to think about the business objectives. The only rule is that the tables must contain a roughly even number of cards. (If table “A” becomes “full” a gate keeper can prevent more cards from being added to it. Remember this is just the first iteration).

The second iteration involves everyone standing around Table A and looking at is as a meaningful release. Does everything in there meet the business objectives? Is it self contained? The objective of this iteration is to exclude items that could come later (for example “data migration”. For the first release maybe it would just be a pilot and we could manually put customers on the system). There may be comments that there are things missing – it doesn’t matter, we will find those later. Again, time box the iteration and then move on.

The next iteration focuses upon table D. What needs to move up? Ten minutes then move on to tables C and D. These might be hardest; it is easy to agree what must be delivered early and what can come last, but the stuff in-between can be a challenge. Maintain momentum by always returning to the business objectives, and what are the most important to deliver on first. Once all tables have been visited a final iteration walks through them all. Again, it is made clear that this is not something we need to be held to, but it informs how we move on; to drilling into more detail on the high level stories and producing sufficient insight to make meaningful estimates. Estimation? Now that’s a different story.

Meetings dust

The builders are currently in our house, the last week they’ve been knocking down walls. And oh the dust! It’s got everywhere, no surface in the house remains without a thin layer of dust. And that is dispite their putting up plastic sheets to contain it. As the building work has progressed, there are many parallels to software development. But is there a parallel to the dust? Something unpleasant, gets in the way, chokes you and makes everyone tense and unhappy? Well come to think about it there is. Meetings. Surely meetings are the dust of software development.

Office inconsistency beaten by a tortoise

If there is a Golden Rule of usability, surely it must be consistency. Internal consistency (i.e. whenever you click “home” you will always return to the homepage), external consistency (i.e. mirror “real life” – when I “send” a mail it goes to a “recipient” … when I do something similar I expect a similar behaviour.Experience has taught me when using Microsoft Office that I should continually save. Experience also teaches me that if I select “undo” that will reverse the change I have just made. Cool! In Word I make a change – save – undo and the change is undone. PowerPoint is in the Office Suite so I expect consistent behaviour. I expect to be able to save my document and still be able to undo any changes I made before I saved.

But Office breaks the Golden Rule and yet again looses all my work.

I wanted to send a single slide from a presentation to a colleague so I deleted all the other slides, and subconsciously hit control-S. I then realised that I didn’t want to save the document using the current file name, but should have selected “save as.” No worries, I can undo that delete… Only I can’t. And I’ve lost all but one slide of my PowerPoint masterpiece. Once again I’m cursing Microsoft.

What to do? No hesitation, straight to Tortoise CVS and a resolution to use source control locally on my documents. It’s not just Devs who check work in and out… Only problem may be when I come to share documents with colleagues – rather than calling documents v0.n, I’m always working with version 1.0. Now if I had a personal central repository that others could access…

Building with bricks, developing with code

January 30, 2006, 12:34 pm

We’re building an extension on the back of the house. Three weeks into the build, the foundations are down, the walls are up and the roof is on. And in many respects the builder is like an agile developer. For a start he is cursing the architect.

The build is to some extent emergent, not least because of all the hidden surprises that QA (building inspector) is throwing up. And the customer (me) is having to make decsions as the build progresses, reprioritising according to business value (or cost – how much for those folding sliding timber windows? Sorry aesthetics. Hello uPVC).

But what we can always return to are the architects plans. Not so much for the detail (much of the time the realities of the build invalidate the up-front design) rather for the vision of what is being built. I’d argue this vision is equally important in agile projects; without it can you really be sure what you are going to get? Story cards are great, but when supported with storyboards (lo-fi prototype, wireframes, call them what you will…), it is then that developers get an “a-ha” moment and see the phyiscal manifestation of the story. At least how the analyst and the customer see it. And with that tangible, visual model it is easy to gain consensus before a line of code is written.

So what?

January 3, 2006, 9:29 am

I’ve been in several situations recently when people have been extolling the virtues of their Great New Idea but I’ve been unable to share their enthusiasm. Probe a little deeper beyond their excitement (with a healthy dose of cynicism) and things often get vague and the idea isn’t as bright as it first appeared.

There are three questions that every Great New Idea must surely answer.

1. “So what?”
If you can’t tell me in thirty seconds or so why I should share your excitement, we are on dodgy ground. Successful propositions will have a succinct, easily understood and compelling response to the “so what” question. If a customer comes to your website and they there is no clear proposition for them to stick around that old adage “your competitor is just a click away” is likely to become a reality. If you’re a developer and you’ve got some great new technical wizardry that you want the whole project to get excited about, there must be a clear answer to the inevitable “so what” question from the not so technically minded business sponsors.

2. “Who needs it?”
The next question is “who needs it?” You may think it’s a great idea, your friends and family are equally convinced, but how about the broader market? There may be a niche in the market, but is there a market for that niche?

3. “what’s in it for me?”
The final question that a Great New Idea must answer is “what’s in it for me?” Why would someone else get excited in the idea? Why should someone go with your Great New Idea rather than a competitor? Why should the business buy into the idea of sacrificing functionality for technical stories that speed up the build?

Sadly there are far too many initiatives out there that fail to address these three questions. If someone can’t see the point of your Great New Idea, can’t see what it will do for them and can’t see why they need it, why are they going to use it? Customising software is a good example of this – stakeholders often get excited about the ability of customers to customise the web portal to their needs, but go beyond the technical / business community it’s not something people do. How many people have the same desktop settings that came with their computer? How many people have changed their browser homepage from that their ISP set as default?

User journeys

December 14, 2005, 11:55 am

One of the issues with dealing with functionality, especially when working on B2C web sites is that it does not always fit comfortably into the broader customer proposition. Functionality is only useful in the context of what a customer wants to do at a site and how they do it. Chances are customers won’t hit that functionality straight away, it will be but one component within their overall journey. For example a shopping cart is the final stage of the buying process. The customer has to firstly find a desired product to put in the cart. The cart’s value is only truly realised when the end to end process is considered – what use is great functionality if the path to reach it is broken? So by thinking about customer journeys, (scenarios by which different customer types will come to the web site and the paths they will take to accomplish their goals) we can ensure that functionality we write cards for has demonstrable value and contributes to a usable and compelling experience. And this helps better prioritisation.

During prioritisation exercises we shuffle the cards according to their business value. Rather than trying to find business value on individual cards, taking this end to end approach will helps us to better estimate the business value of what we are building. And it might make for surprising decisions.

This is something that I tried at a recent financial services client. When we began scoping the work for the forthcoming releases we had a list of important sounding requirements that were to be migrated to their new platform. But how do you prioritise “set income flag” against “capture Debit card details”. Answer was you don’t. Each is part of a customer journey – “existing customer wants to view her accounts” and “new customer want to buy an ISA”. And like a stuck record I interrupted every conversation with “yeah but…. Customer journey” and soon our roadmap for the future was built around journeys. It was the journeys themselves that were prioritised rather than a random bunch of requirements. And what a sexy, customer-centric roadmap it was. Sadly it was later torpedoed by functional requirements that we had no control over and the journeys lost their strong flavour.

11 of 11
7891011