Agile

I recently worked with a client where one of our deliverables were wireframes that illustrated how pages would be laid out and how the UI would work. We were quite pleased with the results, there was some quite complex AJAX based functionality that provided a really immersive, goal orientated experience that looked like it would make finding products easy and enjoyable. Testing the initial wireframes with users was an enlightening exercise, and demonstrated that the wireframes we had developed were not yet ready – users were not able to fulfill the goals they were set. More worrying, some of the complex functionality we were introducing just did not work (some of the navigation, filters and sorts were confusing, just presenting information on a single page would suffice).

Usability testing often gets discussed and is a good intention but all too often budgetary or time constraints mean it never happens. The user testing I refer to here impacted neither. We did our testing in a meeting room, the customer sitting at one end with a facilitator, and the team watching on the projection screen in the same room. We used a talk-aloud protocol walking through the static powerpoint wireframes that were linear in their presentation according to the ‘happy path’ to realise the customer goal. Someone took notes as we went through the wireframes (in the notes section at the bottom of the PowerPoint deck). It was quick and dirty but produced results. After a couple of sessions things that we, too close to the design, had missed. Changes to the wireframes took a few hours and allowed retesting the following day. Indeed we made some quite significant changes to the user interaction model. When we re-tested the wireframes the improvements were evident. The feedback was more positive; there were fewer blank faces, less confusion and “I’ve no idea what to do next” was never uttered. This was true iterative design in cycles that took a few hours. Compare this to the days if code was involved.

Where does this fit into the agile way of delivering software? In the agile/ lean zealot’s passion (and impatience) delivery, and their (dogmatic?) assertion that anything but code (working software) is waste, they loose focus upon what is really important, that of overall product quality. Product quality is not only zero/ minimal defects and meeting the business requirement, but also delivering something that is usable and delightful to use. Developers may do Test Driven Development, but this is based on assumptions that what they will code is right. TDD should start earlier in the process, Test Driven Design. It takes time to write your tests up-front, but we know it to be a good thing. So why not design the user interface (wireframes) and test that up front?

There’s this idea called the Disconfirmation of expectations theory that states that having unrealistically high expectations from the adoption of a new IT application will result in lower levels of realised benefits. Get customers excited about a new product and fail to deliver on it and you will have unsatisfied customers. And unsatisfied customers are unlikely to use the product to its full advantage.

There is a risk with products developed using agile approaches that they fail to deliver on their initial promise. The immediate stakeholders know that the product will evolve incrementally, but is this true of the broader audience? Are they aware of the intended regular heartbeat of delivery or are they expecting a fully featured product at the first release. How are you managing expectations beyond the immediate product team?

Be wary of what you say early on. Creating a vision is essential but be mindful of how this is communicated. Early demos, proof of concepts, prototypes, wireframes often show a vision of the end goal, several releases into the future. Words are easily forgotten, explaining that this is an end goal vision is not enough, you must show a vision of what the cut-down product for the first release is and ensure it is appropriately communicated.

Expectations work both ways, it is easy for the business to tell IT their requirements and assume they will be developed in their entireity in one go. Similarly it is easy for agile developers to expect the business to understand their incremental approach to delivery. The key to success is effective change management; identifying all stakeholders (both core and peripheral) and create a culture of agility that goes beyond the immediate project team. In a large organisation that maintains more traditional approaches, agile projects must be supported by a well designed communication plan that builds the relationship between both IT and the business. Identify whose life will be touched by the product and develop a strategy for communicating to them. This doesn’t mean “they can see what is going on on the project Wiki” this means someone taking responsilibity for listening, engaging and evangelising on the product, the project and its goals.

Let’s assume that you are not bought into the whole agile thing. That doesn’t mean you can’t look at your IT organisation and identify waste and fat in the process. How long does it take from the business having an idea and requesting IT to build something to the developers actually starting to code?

This seems to be common: The initial ‘idea’ is fed into the PMO team, it is documented with a high level scope, rough business case and napkin estimate of +/- 100%. Elapsed time (i.e. the time from the first email or conversation requesting the requirement through to the initial scope document being circulated and approved): two weeks, value added time (i.e. the time actually spent thinking, doing or deciding); two hours. The project, having gained approval in principle, is then prioritised. Some organisations actively monitor thier project protfolio, others do it annually, with the business having to put in project requests when the budgets are set. Mid-cycle and the project is unlikely to take off.

Let’s assume PMO agree the value of the project, next step is high level design. Analysts capture high level requirements, ascertain what the business really wants and refine the business case further. IT puts some high level estimates against the requirements, with a +/- 80% confidence. Elapsed time: eight weeks. Value added time two weeks. With a refined business case to take to PMO or the steering commitee all that has changed now is that we have some more detail and a guess on what it might cost. We are ten weeks down the road and we still have not made a decision whether the project will commence. This due dilligence is notionally about reducing risk and keeping costs in check, but in reality, what value has been added?

Now it is time for detailed design. Another (elapsed time) eight weeks of analysis, drilling down into the requirements. Documentation follows workshops, only now the specification is no longer speaking the language of the business. Use cases, UML, it’s all getting slightly technical and the business are not really sure what they are reviewing. Let’s call it another couple of weeks of actual value that is added.

Eighteen weeks elapsed time, countless meetings, momentum and still no decision on whether project will start, let alone a line of code being written. But the business case is really taking shape and IT have got the estimates down to a 20% confidence limit.

The project gets the go-ahead, but it is not yet time to start coding. Technical design needs to take place, four weeks of architects architecting and documenting the spec. Six months has elapsed (of which maybe a month was actually doing stuff that positively contributed to the success of the delivery) and finally the developers start writing code.

What value did that six months deliver? Requirements, design, business and estimates. Yet we all know that the requirements will change, and with that the business case. The estimates will be way out, but we’ll justify the process of estimation because they would have been right it the requirements hadn’t change during the build…

Knocking the process is easy. What’s the alternative? Start with a burning desire to release something of value at the earliest responsible moment. Get the business in the same room as the analysts and the architects and get them to articulate their vision. Use personas and more importantly scenarios and customer journeys to drive out the business vision. Ask the analyst to capture the business intents on index cards. Lots of whiteboarding, visualisation and pictures to inform the thinking. Don’t dwell on the detail, this is about capturing the intent of the system, what are the desired outcomes that it will deliver, how will it impact the lives of all the people who will touch it. Next step is to prioritise these outcomes. Collate these into the minimum set that would make a coherent and compelling product that you could go to market with. For the business case make basic assumptions on the revenue that this feature set will deliver (or what costs it will save) and ask the architects and developers in the room to do some high level estimates. The whole process should take no more than a week (you could get a first cut done in a couple of days) and there is your initial business case. If we accept that estimates are little better than guesses and things will change anyway, if we have an initial realisable goal that we have demonstrated will deliver value, why not go straight into development. By actually ‘doing’ you will minimise risks that you can only predict on paper, and value will be delivered so much quicker, indeed you should be able to have something to market, generating revenue in the same timescales that you otherwise spent planning and analysing. And if you still want to do waterfall, you’ve got a smaller number of requirements to analyse and design for, again, delivering value sooner.

So another government IT project fails to deliver. The National Offender Management Information System had been budgetted to cost £234m (total lifetime cost) and take four years to complete. Three years in and the costs had spiralled, with a new lifetime project cost estimated at £690m. The plug was pulled and a new three year project at the cost of £513m was commenced. Poor project management was blamed, but I’d go further and blame the project approach as well. The Minister responsible says why;

“As soon as the extent of the projected costs and delays to the project were recognised, we took immediate steps to halt the project and consider the most cost-effective way forward which effectively preserved the work done to date”

So let’s get this straight:

It took three years to recognise that a project to implement a single database had gone wrong.

Contrast this to an agile project where progress, costs and risks are continuously monitored. But what does the goverment do? Continue with the same approach as before with some new project managers on the job. And wait another three years before any value will be delivered.

A product rarely sells itself. What sells a product is the advantage it brings and the benefits it delivers to the customer. It is the benefit of the product that sells rather than the product itself. What is the advantage of the requirement you are stating, and what is the benefit it will bring the customer?

Let’s start with a product. Think broadband. It’s dull. Put 10MB in front of it and it is still dull.

Now think about the advantage that 10MB broadband brings. The advantage is that it is fast. Lightning fast.

Now think about the benefit which that advantage brings. The benefit is that you can download an MP3 tune in seconds rather than minutes with your old dial up connection. You are no longer selling broadband, but the experience that it brings.

Let’s consider IT requirements to be products. A dull list, a thick document gathering dust. How do you prioritise one requirement over another? What is more important?

Agile introduces ‘stories’ as the requirement product. They are written in the format ‘As a <role>, I want <a feature>, so that <some benefit is achieved>’. It is the ‘So that’ which is usually the hardest part to articulate, yet it is the most important part of the story.

Applying the marketing thinking to how the story will “achieve some value”, don’t just define that value in the advantage it will bring, rather also consider the benefit it will deliver to the user. The two are different. There maybe a business advantage to delivering some feature, but if the benefit to the end user can’t be articulated, it’s real value must be questioned.

Don’t be fooled into thinking that you don’t need to do any design when you adopt Agile. Agile development strives to deliver business value early and often, focusing on getting working software to market as soon as possible rather than dwelling in documentation and ‘analysis paralysis’. But let’s be clear, “business value” and “working software” are not the same thing. You can quite easily get something into production that fails to generate revenue, decrease costs or whatever other yardstick you use for ‘value’. What differentiates the two of them is design. I don’t mean big up front design that details all the features and provides a concrete spec, I mean a design vision that articulates what the product goals are and a roadmap for getting there. And what is a design vision? A short statement of intent is a good place to start, and soon after a user interface mocked up in pen and ink. It is cheap and easy and helps bridge the path from idea to execution.

One of the problems with IT development is that it is tactical and piecemeal in its approach. Functionality is added in response to competitor or broader market activity. Expect to see an increasing number of brands doing something ‘social’ (and tactical) on the web, but don’t expect these new initiatives to be (strategic) seamlessly integrated into the existing digital channel offering.

This piecemeal approach extends to larger initiatives as well. In refreshing the website or developing new digital channels such as mobile and TV, IT will typically build out features and functionality prioritised upon their perceived individual business value regardless of what the sum value of the proposed release is. (Focusing all your effort of building functionality that delivers to your bottom line will seldom be as successful as you predict if it is not supported by features that meet the customers needs).

So when it comes to thinking about new features and functionality, where’s the best place to start? I’d suggest collaboratively, thinking around the customer. Collaboration is important to ensure that everyone starts with the same vision. It needs to be shared it with the broader audience, the product teams, IT; anyone whose day to life life will be touched by the project when it starts. I’d argue that you cannot start this soon enough. You don’t need to spend time doing analysis, interviewing all stakeholders individually, coming up with a document that is circulated and reviewed and re-written (with all the delays and waste that such a process incurs). Start the process getting all those stakeholders off-site for an afternoon and get the thoughts out on the table.

Commence with a presentation that introduces thinking in terms of customers and customer journeys. The below SlideShare presentation does this for the airline industry, addressing a new customer experience across channels. I acknowledge that it is pretty simple and doesn’t touch on half the ideas that airline executives may have. That is the point, it is just enough to get people thinking about different customer types and their touchpoints without getting bogged down in detail. This is what we want the participants of the off-site to share.

[slideshare id=912224&doc=airline-deck1-1231817842408345-3&w=425]

Once we’ve been through the presentation we break out into small groups a, each taking an individual customer (or persona) and build up a story; a day in the life of… (It is important not to forget the internal users of the system). These breakouts last 15-20 minutes with ten minutes for the team to play back their findings. As they build out a richer picture of the customer interactions they are asked to sketch out what the user interfaces may look like. The process is rapid, intense and iterative, but always focussing upon the customer journey; how will the customer realise their goals. When the teams tell their stories an analyst captures the essence of the requirements on index cards. The final exercise is to lay all these cards on the table and ask the team to group them into similar areas then prioritise them according to their perceived importance. In an afternoon you will have achieved four things. Firstly, you will have captured a vision for the new product in less than a day, with all stakeholders understanding not only the vision itself, but also the process that developed it and the concerns and issues that different parts of the business have with it. Secondly you will have an initial prioritised roadmap for its development. This will change, but it is a good strawman to circulate. Thirdly you will have introduced all the stakeholders together – projects succeed or fail based upon the strength of relationships and getting people engaged from the start will go a long way to creating shared ownership. And finally you will have generated energy, engagement and traction; to do the business case and to get the project started, recognising that just one part of the business having a vision is not going to bring it to the life that they dream.

It’s budgeting time with many organisations putting together their budets for 2009. In the current climate IT is an easy target for cutting costs. Stories such as “no new non-core projects till 2010” and “no project that can’t demonstrate a postive ROI in 12 months” are abound. There is a risk that only focusing upon projects that keep the lights on will do longer term damage to the company. Seth Godin writes:

Wealth is created by productivity. Productive communities generate more of value.
Productivity comes from innovation.
Innovation comes from investment and change.

Annual budgeting cycles combined with inflexible development approaches preclude real innovation. It is hard to justify any cost, especially untested products that brings a burden of risk to the organisation.

There are two solutions that go hand in hand. Agile software development enables IT to release value from production earlier and more often than waterfall development. Rather than significant sunk cost in risky product innovation, it removes waste from the process and focuses upon delivery of working software that is of value to the business, taking the product to market at the earliest possible time.

This is a challenge to the annual budgeting charade where line item projects compete for guessed amounts in return for notional value. (IT put crude guesses – not even estimates- against even cruder descriptions of required features from the business). A better model would be to take that of the venture capitalist, with different rounds of funding. Rather than allocating specific funds to specific projects, far better to ring fence budget for ‘product innovation’. Within this pool of cash projects compete with each other with a pitch for seed funding. Those that are successful go straight into agile development with sufficient funding for a first release (say three to four months). Getting to production (and to market- internal or external) will validate further funding or equally enable the business to make an informed decision and kill the idea – fail fast, fast cheap.

..CIOs will be expected to become more and more strategic, delivering greater productivity gains while at the same time ruthlessly cutting costs. There will be a heightened debate about the role of IT in the enterprise. (ComputerWorld)

OK, so we can either spend months writing documents before a line of code is written. Do some application development then manually test what we’ve built and fix the bugs before eventually going live (late and over budget and not to the customers satisfaction).

Alternatively we could get more strategic and focus upon what value we can deliver in the shortest period of time. We could better align IT with the enterprise by delivering early and often, enabling us to test and learn from the enterprise as we go. We could adopt a more ‘just in time’ approach to requirements (whilst starting with a clearly defined vision from the outset). We could build testing into the development to lessen the bugs at the end, we could do automated testing (to ruthlessly cut manual testing costs). Downturn sounds like a case for agile.

To the development team ‘change’ relates to scope and requirements within the project, but change runs far deeper than that.

A question that I am often asked is how do you manage business change on agile projects. Release regular and often is an often quoted mantra, but what does that mean to the business where rolling new software across the large, multi-site organisation? How do you manage the piecemeal introduction of new technology, features and functions to hundreds or thousands of people, many levels removed from the project across remote offices and geographical locations? How do you ensure the recipients of the new technology rapidly adopt it and accept the change, even when change is occurring every few months.

What are the financial and human performance implications of each new release in terms of training, productivity and morale? What is the overall burden on people in frequent change?

The reality is that it is not unusual for projects deemed successful by IT and the immediate business team to ultimately fail when released to the broader organisation. Effective change management can be even more important when an organisation adopts agile software delivery.

An analogy as an example. If I expect a screwdriver and you only give me a cross-headed screwdriver when I really want a flat head one I am going to be unhappy. The core team may have prioritised the cross-headed one first for good reason, a flat headed one maybe coming just round the corner, but if you don’t deliver to my expectations I am going to be unhappy. Worse, I am likely to become resistant to future change and less likely willingly cooperate with the uptake of future releases, even if they do start to deliver to my needs.

Keep it on the shelf
The first point is that regular and often does not necessarily mean release to production for the entire organisation or marketplace. Running a number of internal releases, keeping them on the shelf until a complete and marketable product is ready is a strategy often employed. Significant value can be accrued by getting tested and working software into a pre-production environment and held “on the shelf” awaiting a full release. This maybe a UAT environment where a limited number of stakeholders test the functionality in an ‘as-live’ environment. Or it maybe a beta release to a small, selected number of interested people (e.g. a ‘friendly user trail’). This can often pay dividends with usability issues and minor gripes being picked up and addressed before a major roll-out.
Communication
Let’s assume that the team wants to roll out the application early and often to the whole target population. Critical to the success of managing the business change is communication. It is important to manage expectations on a timely and appropriate manner. Explain what the upcoming release will do and more importantly what it will not do (and when it will do it). Keep all stakeholders informed of the project progress (setting up a project blog can be a cheap and easy way of letting interested people know of progress), yammer maybe another way of broadcasting updates and information. Having a release count-down can also prepare stakeholders for the change. The techniques can be googled, the important thing is to communicate and manage the expectations (and be ready for inbound questions and comment after go-live).

Adaptable user interface
It is not unusual for the core team to drive for as much functionality as possible in the first release, considering UI enhancements as ‘nice to haves’ and consigning them to later releases. This is a false economy. Consider the cost of training and lost productivity through a hard to use interface. Now multiply that across multiple releases that focus upon utility before usability. Delivering a first release that is self contained and compelling will go a long way to driving organisational buy-in of the new application and greater acceptance of future change. (Jeff Patton writes some great stuff on using story maps to explain what the system should do. Using these will help focus on complete and useful slices through the application rather than random features that are perceived to be of value but do not make a coherent product).

A new user interface, however well designed will inevitably take time to learn the first time it is used. The challenge is with each subsequent release to introduce funcitonality and interactions that leverages the users existing mental model of the application, building upon what has been already been learned. Starting with the end-state, wireframes that articulate the final application then trimming out features, feields and controls to represent each notional release can be a good way of ensuring a UI that will scale as new functionality is added.

Agile organisation
Ultimately the most successful way of introducing agile is to build a beta culture with everyone as agents of change across the whole organisaiton. More importantly change becomes a cycle of learning and continuous improvement. And here I’ll borrow this most excellent graphic from David Armano. David compares what he calls conventional and unconventional marketing but the parallel with software development is obvious. His iterative cycle is “plan-design-launch-measure” but that is not a million miles away from the lean philosophy of “plan-do-check-act”. And critical to the journey is the learning cycle between iterations.

Marc McNeill

For more than a decade Marc has been a passionate advocate of placing the customer at the heart of business, working with clients in finance, retail, government and entertainment sectors, helping them craft compelling cross channel customer experiences. Marc champions lean and agile approaches for making customer driven innovation happen. He co-authored the book Agile Experience Design. As a consultant with ThoughtWorks he brought design thinking and creativity to clients, engaging across their organisations with a focus on delivery as well as ideas. Today he is Customer Experience Director at Auto Trader. He has been known to dance and is rather partial to mangos.