How to estimate, pitch for and charge for a project in an agency enviroment

When I talk about estimation and planning, people often ask me the above question. The styles of estimating I talk about are more frequently used in a non-agency environment, that is, somewhere maintaining a single, existing product, or creating one, for your own company from scratch instead of the agency method which delivers software per project, per client.

The problem

The problem with this kind of work is that of estimates. Typically, as an agency, you’ll be bidding or pitching to a client to get the work. The client will probably be soliciting bids from multiple agencies, so you need to either stand out from the crowd in some way, or be the cheapest (or, preferably, both).

The client will generally be looking for a fixed price too, this is so they can go back to whoever is commissioning the work and get funding, or raise a PO or whatever.

Sometimes you’ll be given a brief, which you might then turn into a functional and/or technical spec, which then goes to the client along with the quote, then there’s some to-ing and fro-ing, an agreement and then work commences and oh shit, we forgot to add the widget to the spec and oh crap we underestimated the amount of data we’d need to use and have to re-engineer to use mongodb.

So, with this in mind, how do you estimate, quote, pitch or bid when agile methods are so fluid and you have to work to a fixed cost? You know the least about how long a project will take and what is involved right at the beginning. Using the Cone of Uncertainty, you’ll be between 4x and 0.5x inaccurate with your estimate of an end date (eg: at the beginning of a project that you estimate takes a month, it could take between four months and two weeks)?

Some metrics

There’s a few metrics you’ll need in order to derive costs from estimates:

  • Day Rate: How much a team costs per day. This is only ever going to be a rule of thumb (as there are holiday, illness, training etc.). But you should make it as accurate as possible. This becomes a key metric in working out costs from estimates. You should make sure that your client understands that for the purposes of estimating and pitching, this is an accurate, but rough figure.
  • Best, worst and average velocity: these are important metrics. Your average velocity is simple, add all your sprint velocities together and divide by the number of sprints. You could make this more realistic by using a rolling four sprint velocity, this then takes into account changes in team size, tooling or process. However, for the purposes of estimating the cost of project up front, the average will do.
    The best and worst velocities are derived by taking an average of your three most successful sprints and the three least successful sprints. Why you need these will become clear later.
    Should you have multiple teams and you’re not sure which team will be working on your project, then take an average across all the teams.

If you don’t have this data, you have two options: guesstimate, or use the cone of uncertainty.

Honesty and transparency

The fundamental tenet in any of these below strategies is complete honesty and transparency with your client. You’ll also need to invest three or four days (maybe less, it will depend on how practiced you are at this process, it will become quicker) in your client, it might sound like a lot and there is a risk there might not be a contract at the end of it, but it is worth it. Once you’ve deeply involved your client in the process from the start, they’ll feel like they’ve already started the project and so it’s easy for them to transition to being a paying customer.

From the outset, you’ll need to explain that you do things a little differently to other agencies. Whatever framework you choose to use (scrum, kanban, etc), spend some time explaining to the client what it is, how it works and why you use it. If you’re a little stuck, here are some ideas

  • It gives you a realistic view of the progress and scope of the project.
  • It gives you, as the client and stakeholder, complete control over what features make it into the final product and which don’t.
  • It allows us to deploy features to live as soon as we’re ready to, meaning you can be getting value from our work and your product, even before we’ve finished it.
  • These early and frequent deployments allow you to test your assumptions about your own users and customers and, if necessary, change the features or product without additional cost.
  • You will be encouraged to be involved throughout the whole lifecycle of the project and can view each separate feature as soon as it’s finished to help guide and steer the project toward exactly what you want (which might not be what you originally asked for).

The best way to do this is to invite your client in for a half-day, high level training and workshop. Run some exercises to illustrate the key points and answer all their queries – this is a new thing for many companies who aren’t used to this kind of agile environment, so it’s definitely worth introducing your client to it if they haven’t experienced it before.

The next step is to create some artifacts. Once you have a brief in hand and have spent some time with your product team and analysts and have a really good understanding of the brief, the market, the competitors etc, invite the client in again in order to build a product backlog of user stories. Set the scene for them and explain that, unlike other agencies, you won’t write a functional spec, or a technical spec, because they’re a waste of time. What you will do is write user stories, which describe each feature from the users’ point of view and what value each of the stories will bring.

Labour the point too. Ensure your client *really* understands that you won’t be building ANYTHING that you can’t find the value for and WHY you take that stance. If a feature, or some functionality, has no value, then why would you build it?

Work quickly through the brief and your research and build a backlog of epics with your client. Don’t spend longer than an hour or two on this and, if you have somebody, get someone to facilitate the meeting so you don’t get bogged down in ANY technicalities, or discussions that are long or drawn out. Once you’ve got your list of epics, have the client order them – which are the highest priority things? What user/customer value do they want to deliver first? Don’t worry about dependencies right now, this is only rough.

Finally, break the highest priority epic into a few slightly smaller stories. This isn’t strictly necessary, but will help the client understand the process better. Again, this shouldn’t take longer than 30 mins.

The estimate and the pitch.

Now you’ve got your feature list of epics and some smaller stories for the highest priority, get some estimating done. I won’t cover it here, but you can read the article on white elephant estimating, or watch my presentation on agile estimation. Try and use the team that will actually be doing the work. If you haven’t got a team, or not sure which of your teams will be doing it, then pick engineers, designers and QAs from multiple teams – you’re only looking for roughly accurate figures. If it’s proving too difficult because of the epics, then break some into smaller stories – getting epics and stories sized well enough to estimate will become easier with practice.

Finally, you’re in a position to pitch, but how do you do it? It all depends on your clients requirements.

It’s very important that the client understands they have complete control over what goes into their product on a sprint-by-sprint basis. Explain that you expect them to be involved in the decision making about what goes into the product, the priority of the features to be added and the scope. So, once you’ve agreed on one of the below strategies and signed a contract, the success of the project will be partially down to their input.

Fixed deadline

If your client requires the project to be finished by a certain time, you can work towards that. It will be to your advantage to provide two estimates though, allowing the client to choose their own end goal:

All stories by the deadline

Estimate the number of teams or people required to deliver all the story points by teh date, then, based on a day rate, create a figure. Remember, to be accurate (but not specific), you’ll need to provide a range, so, using your best, worst and average velocity you can say to your client, “We ESTIMATE, it will take four months, but it could take up to five and half, but it could take three months, therefore, it will cost between £40,000 and £55,000”.

A valuable, shippable product by the deadline.

Do the same as above, but use a fixed sized team – you won’t be able to fit some stories in, but this is fine. Use the average, best, worst to show the client the stories you will definitely do, you will probably do, you might do and you won’t be able to do. This will reduce the scope of the project, but also the cost. Remind the client that what features make it into the product is based on their input.

Fixed cost

Working towards a fixed cost is quite rare, but does happen and it will likely mean that the client won’t be able to have all the features they’ve asked for. In order to work towards a fixed cost, you need to know it (obviously…). Once your client has offered this, you can use it to work out your strategy. It will be similar to working out a fixed deadline. You know how long you have to deliver the project based on the day rate (fixed cost / day rate = number of days). So, then you have a fixed deadline to work to and can use the average, worst, best strategy again to indicate what you can definitely achieve, what you can probably achieve and what you definitely won’t achieve.

Fixed scope

Finally, there is fixed scope. The client has to have everything they’ve asked for – in practice, during the project, this is rarely true once you start building and the early, regular releases helps steer the project.

Again, using your best, worst and average velocity, you can work out a range of how long it will take and then use your day rate to provide a figure.

Cost per iteration

(I wouldn’t suggest this method unless your client is particularly agreeable to trying new things, but, assuming you did the setup correctly I describe above, then they should be chomping at the bit to try this new, visible, transparent and honest method of commissioning software)

Pitch at a cost per iteration, instead of a day rate. You can give rough estimates on how much it will cost and these will become clearer after each iteration. Pitch for a minimum number of iterations after which your velocity will stabilize and you can be more accurate in the remaining length of the project. This is a fairly ambiguous method of pitching though, you’ll need to draw on the other strategies above to work out what features and functionality can be delivered, but if your client agrees to sign you for a minimum number of iterations, and you deliver what you agreed to, by this time, your estimates should be pretty accurate and your velocity very stable, allowing you to accurately cost any stories you haven’t managed to complete.

Using your average, best and worst velocity to predict a schedule
Using your average, best and worst velocity to predict a schedule

Honesty and transparency, again.

It’s worth reiterating here that you should be completely honest with your clients as to how complicated and amorphous quoting for a software project is. If you think your client can understand it, then break out the cone of uncertainty to explain that 40 years worth of data prove it to be true.

Explain that, being agile and adopting a framework to allow for short, deliverable cycles allowing for fast-feedback means that your company will very quickly start delivering visible value to them. It will also mean that they can control what that value is on an iteration-by-iteration basis. But, probably the best arrow in your quiver is to explain that, throughout the project, they can see the progress on an almost daily basis and adjust both what you deliver and how much they want to pay you should they need to.

If you deliver some valuable piece of software that causes them to change they way they think about their product, then they could pivot their entire offering and find more funding – and who is already in place to help them achieve that?

Hooray! We won the contract!

Congratulations! Now, don’t sit on your laurels. Remember the commitments you made to your clients during the pitch process and keep them involved through the project. Begin with release planning to decompose the epics into more usable stories and begin to uncover more of the project as you go, with milestones and deadlines if necessary. Keep your client informed, involved and in-the-loop and they’ll be happy when things change (and they will).

Boo, we didn’t win the contract.

Sorry, that sucks – but use it to learn a lesson. Find out why you didn’t win. If it’s just down to cost, then perhaps review your costs, or spend more time breaking down and estimating the stories to provide a more accurate figure next time.

Send out a survey to the client, asking them what they thought of the process and whether there is anything they’d change, or something they didn’t like. Gather as much data as possible, then spend some time retrospecting with your teams about how you can do it better next time.

My client doesn’t want to be that involved or isn’t interested in how we do it.

My advice here would be to not take on the business. If your client isn’t interested in being part of the process of building their product, then you are setting yourself up to fail. You’ll deliver a functional and technical spec detailing exactly what they want, you’ll deliver it and then find out that, while you delivered what they asked for, it isn’t what they wanted.

Finally

The old black box model of estimating and pitching for client work is difficult to manage, hard to sell and will bite you in the ass later down the line if you got it wrong at the start. By getting your client on board and understanding how you do things, and that they can and should be involved from the beginning to the end, you put yourself, your company, your team and, importantly, your client in a position to succeed.

Advertisements

Have you read the manifesto?

I sometimes wonder whether people have actually even read the Agile manifesto. It is made of four core values and 12 principles, I won’t paste them all here, you can find them at the above link. Maybe the principles are hard to find, but you can read them here.

That’s all there is to it. Agile isn’t a “framework” or a “methodology”, if anything, it’s common sense. Common sense described in four values and 12 principles.

Agile is not a synonym for scrum, or kanban, or anything else. The term “Agile” shouldn’t be used as a description of an all encompassing set of practices that it doesn’t describe. For example, what does “Agile adoption” even mean in this context? Does it mean you’ve finally decided to use common sense? No, it means a company is adopting a framework or methodology that is inspired by the Agile manifestos values and principles, such as Scrum.

Agile is a mindset, a way of being. So please, stop posting things about how “Agile has failed”, or “Agile does damage” unless you actually mean that common sense has failed, or common sense has caused damage. Which is unlikely.

Remember, you don’t DO agile, you ARE agile, it’s a way of being, not something you do.

How big is it? A guide to agile estimation

I gave a talk at LondonWeb a couple of weeks ago. It was a lot of fun. I tried to broadcast it with Google Hangout on Air, but the hotel wi-fi was rubbish. Luckily, @nathanlon recorded it too, so here it is:

and the slides:

Slides for ‘How big is it? A guide to agile estimation’

Who tunes the guitars?

Black Cat by erin m on flickr
You need men like this, otherwise live music would sound awful.

I read a lot of blog posts, articles, papers and what-not on creating, maintaining and coaching teams. It’s the one thing that, for me, has no set formula. Each team is different, as they’re made from different individuals, each with their own set of morals, ethics and experiences that drive their behaviours. There is no ‘one-size-fits-all’ team guide, unfortunately.

So, what we’re left with is a miasma of different works, all decrying or promoting some way or other of how to form and maintain a team, how to help them become high-performing, how to retrospect, plan, work, play, love, eat, argue and play football together. None of them are right and, equally, none of them are really wrong. But the one thing I see frequently is suggestions, and often demands, that “if they don’t fit, you’re hiring wrong/replace them” and this is alarming.

The common theme I see is that, yes, there IS a formula for creating the winningest team and, if one of the members of the team you’re trying to engineer to stardom doesn’t fit your mould, then he’s out on his ear … hit the road jack, your awesome-coding-but-complete-lack-of-personal-skills ass is outta here!

Not everyone can be a rockstar, you need some roadies too.

Perhaps you know someone, or have someone in your team who doesn’t really have any great ideas, isn’t that keen on researching the latest javascript framework or building some wanky Hipstagram filter in Ruby, but who can build a data abstraction layer, fully unit tested in a day and always reviews your code and finds the one or two things you missed. Where would you be without this guy?

Or maybe there’s the guy who just REALLY enjoys honking about with MySQL queries, doesn’t really give a rats ass about what the business does, but cares deeply about the quality of his code and making his queries elegant and fast.

Some of you may know the guy who get’s a real kick out of cutting HTML all day, taking the photoshop files from your rockstar, sweater-vest wearing, macciato drinking, fixie-bike riding designer and making a cross browser compliant, responsive and even working in IE.

These guys may not be the fastest, or the bloggiest, or the githubbiest, they may not even really get on that well with agile estimation, sprinting or ‘stakeholders’, but they’re rock solid and dependable.

Everyone has a place, even if they’re wearing a christmas sweater in June, they’re part of your team. Find a place for them, or, better yet, let them find their own place and do what they do best, even if it doesn’t align with your idea, or the internets’ idea, of what a perfect team is.

They tune the guitars and your rockstars play ’em. That’s what a real team is.

Some of us inherit teams. We don’t have the luxury of hand picking the people we want to have. Maybe there just isn’t enough in the budget to fill your team with rockstars. Software gets written outside of Silicon Valley too!

This, for me, is the real notion of building a team. Not chucking money at a bunch of rockstars, but taking what you have, or building on a small budget and creating a live band – you need rockstars AND roadies if you want to wow your audience.

You don’t really want a faster horse!

French Officers watering horses
Horses, going slowly. Photo by The Library of Congress - http://flic.kr/p/a88fYb

Henry Ford is quoted as saying “If I’d asked my customers what they wanted, they would have asked for a faster horse!”. While this might be true, this is a short sighted view of product management.

Often, our customers will ask us for something they want, but they’ll frame it in the context of something they already have. This seems to them to be the right thing to do. It’s helping us out as the people who build their products, right? Kind of. If we were to take the view that customers always know what they want, then I suppose so. However, our customers will endeavour to give us a solution to the problem they have, instead of being clear about their problem and letting the problem solvers have at it instead.

If your customer says “I want to be able to send an email to all my users informing them of X,Y and Z.”, You’d think they what they wanted to do was send an email to customers about X, Y and Z. But is that what they really want?

If you probe a little deeper, by asking open questions, you might find a different answer:

“What is X, Y and Z?”, you ask.
“Well, it’s the new promotions we offer, we want to tell our users about them as they might not find them in the promotion list.” Replies your customer.
“How does the promotion list currently show them?” you probe.
“It’s ordered with the newest on top, but if our customers aren’t looking for promotions, they might miss them.”
“So, you need a way of highlighting your newest promotions?”
“Yeah, I guess so. But we’d like to be able to send them emails about other things as well, like changes to our terms, or new features.”
“OK, so am I right in saying you need some way of informing your customers of new features, promotions and other pertinent information?”
“Yes!”

Now you have the real problem, which turns out to have little to do with email and there are many ways to solve this kind of problem. It’s now a case of discussing these ideas further with the customer and the team in order to find the right solution … which might not be a complex email system.

So, if Henry Ford had asked his customers: “What do you want?” and they said “A faster horse!”, he might have asked, “What do you need a faster horse for?” and the answer might well have been, “Duhh! To go faster!” Which is the real requirement. One that he fulfilled quite well.

Originally published on Technorati.

The Definition of Ready

Well, I’ve only gone and got myself published on the Agile Journal! Here is what I had to say:—–

Ready 4
Are you ready? Image by Kevin Dooley on Flickr

Development teams use the idea of a definition of done (DoD) to decide when they think a user story is ready to be shown to the stakeholder for review. The DoD is like a bouncer or doorman, ticking technical criteria off on a list before the story is allowed in to party. The DoD is a powerful tool, and while its explicit value is obvious in ensuring the quality of a user story before review, its implicit value is equally, if not more, important. The DoD forms a contract between the development team and the product owner (PO). This contract not only ensures that stories meet a baseline of quality but it also creates a bond of trust. The PO knows that, with a DoD, he can trust the team to deliver a quality technical solution, and in agile software development, trust is key to your success. The acceptance criteria form a similar bond between the PO and the stakeholder or business. The criteria are designed to help a PO decide if a story meets the stakeholder’s requirements. It’s this list—defined in conjunction with the stakeholder—that creates trust on the stakeholder’s side. They know that their PO will deliver what they need, because it says so on the story. The DoD and the acceptance criteria combine to make a powerful ally for your team’s success. But both of these things require that the user story itself is sensibly written and defined and that the acceptance criteria aren’t some magical pie-in-the-sky, moon-on-a-stick list of ridiculous demands that would give a hostage negotiator nightmares! The PO can make use of a similar DoD called the definition of ready (DoR). This can be used for all the same reasons the DoD is used for the team. It’s useful if the Scrum team helps the PO come up with a DoR, help her define things about stories that make them easy to understand:

  • small enough to be manageable in a sprint
  • contain enough detail to estimate accurately and
  • create acceptance criteria that really help define “done.”

POs don’t just pluck an idea out of the air, write a user story, and drop it onto the backlog (we hope). Stories go through a process just like the software they drive does. The PO has a responsibility to the team to create user stories for them to estimate and, at some stage, work on, that aren’t badly defined or not thought through. Team members don’t want to have to do a bunch of the PO’s work in order for them do their own work and deliver value. To this end, a PO and the Scrum team might find the DoR useful. This is a contract that the PO has with the team in order to say “Before I put a story in front of you, I will have done everything I can do make it not suck.” Some examples of criteria on a DoR are:

  • Story contains actors, problem, and value
  • Story should fit in a sprint
  • Story should be appropriately documented (does it require wireframes? User-journeys?)
  • Value should be obvious, if not, it should be explicitly stated
  • Story should have reasonable conditions of satisfaction
  • Story should focus on problems, not solutions

Using the above example, we could ensure that the user story: Show users other products that they can buy before they checkout which begins life as a throwaway request from a stakeholder at an audio-visual online storecan be rewritten using the DoR as: As a customer, I would like to see products that I might like to buy at the same time as my television, hi-fi, or other product, so that I can be certain I have everything I need. Acceptance Criteria:

  • Show users products that other customers, purchasing the same products as this user has chosen, have bought also
  • Based on what the user has added to his basket, show him products that could potentially be used with it, e.g., if he has chosen a TV, then show him cables, TV stands, and Blu-Ray players
  • Show ratings and percentage of customers who ended up adding the additional products to their basket.

This shows the actor, problem, and value for the customer. The value for the business is implicit in that it will increase uplift. The story is appropriately documented with reasonable acceptance criteria, however it doesn’t tell the developers how it should be done technically. I’m a big fan of release planning meetings. These meetings include going over the team’s DoD to see if there are any changes team members want to make in conjunction with the PO or stakeholders before they start sprinting. This is an ideal time to create your DoR as well. In addition to the explicit value you get from having a contract between the Scrum team and the PO, the DoR also goes a long way to fostering trust (as long as the PO follows through) in the same way that the DoD and the acceptance criteria do. If you have a bad sprint, during the retrospective, you can review your DoD and your DoR. Did the story require more work before it went into the sprint backlog? The DoR provides a similar yardstick to that of the DoD when looking for root causes of failure. Try adding a DoR to your process, especially if you’re having trouble with your stories being difficult to estimate or work on. You’ll reap benefits immediately, building trust and creating stories that have real value.

Lower the pain threshold and you’re not waiting, you’re impeded.

Jenny by  jamesfischer on flickr
Jenny by jamesfischer on Flickr

Women, it is said, have a higher pain threshold than men. I saw evidence of this as I watched my wife give birth … twice. She went through something that I can’t even imagine having to endure. I’d have screamed ‘epidural!’ the moment the first contraction hit, but then I am known to be a bit of a wuss. My wife however, gritted her teeth and got on with it, I’ve never been more proud.

I’ve witnessed a similar thing with scrum teams. Some of the teams I coach have an extremely high pain threshold when it comes to dealing with impediments. It’s often been one or two days later that I’ve even heard about the impediment, let alone had a chance to deal with it. I suspect this might happen in other teams too and it’s worrisome; it may mean that the team doesn’t believe their SM will be able to remove the impediment (which would illustrate a trust issue and is the subject of another post), it might be a show of machismo to tough out the impediment themselves and resolve it without bothering anyone. This is an honourable motive, but chaps, this isn’t 12th century Japan, if you need help, you can, and should, ask for it. Understanding when you’re impeded and recognising the need to seek help is a more macho thing than flexing your muscles and baring your teeth, it also makes the ladies swoon*.

However, the most likely reason that people don’t raise the issue, is the team simply don’t see it as an impediment in the first place. In standups, or in just day-to-day team chat, the term “I’m waiting for…” crops up quite frequently, usually in reference to the design or operations team. This term is poisonous, it’s a pseudonym for “I’m impeded by…” and teams don’t recognise this is the case.

If you’re waiting for something to occur before you can do something else, you’re impeded by it and your best course of action, if you’re unable to un-impede it yourself, is to raise it to your SM (or your coach. ;)) and have them try and remove the block for you. Next time you catching yourself saying “I’m waiting for…” remember, you’re impeded.

Don’t tough it out, leave the high pain threshold stuff to the mothers of the world, they’re much better at it.

*Probably, I have no data for this, I made it up.

Should I start with scrum, or kanban?

or, Should I transition from scrum to kanban?

Tellurian Post Apocalypse Roleplay
Adventure lies EVERYWHERE! Image by Daniel Voyager

We’ve been doing scrum at Affiliate Window for a couple of years now. We go through the inspect and adapt cycle regularly and we’ve made few, if any, changes to our process, only our engineering practices. Recently, however, we’ve been working on a couple of projects which have required some groundwork and lots of backend work. This kind of work doesn’t really lend itself to the ideal of having something to show the stakeholders at the end of every iteration. We still have the review, describe what we’ve done and then take a look at the backlog with the stakeholders to decide what the priorities are for the next iteration.

This has raised a question from one of the teams about moving over to kanban and it got me thinking about what organisations can do to start on an agile journey, should they start with scrum, or kanban? What about established teams? Can they transition from scrum to kanban, or vice versa? Why should they? Should they even do it?

Now, there’s no reason why you can’t continue doing scrum (which is what we’ve decided to do), even with backend heavy work. Afterall, it’s simply a framework designed to offer constraints in order to create fast feedback (amongst other benefits), but kanban is attractive in that it allows you to decide when you demo/review and so gives you the benefit of time in order to actually have something tangible to show the stakeholders. Kanban is also attractive for those coming to agile afresh. It allows you to start integrating some agile practices and get a view of your issues (in order to solve them) without changing your heirarchy or existing process.

For Kanban to really work, you need to make sure you’re setting up a pull system that describes your entire process, from inception to delivery – not just a column based todo board (which, unfortunately, you see a lot described as ‘kanban’). To be able to do kanban well and retain the holistic view of your work required by the product team to make educated guesses on delivery and suchlike, the team needs to be mature enough to do kanban well. This means; mapping out the different states in your system, working out WIP limits and, importantly, deriving cycle time (how long it takes an item on the board to get from left to right) in order to estimate delivery/scope/cost etc. Herein lies the rub (I’ve always wanted to put that in a blogpost!).

If you’re not able to use scrum to help you deliver backend-heavy, large work items, then it’s unlikely that kanban can help either. The constraints of scrum help you stay on target and be accountable for what you have or haven’t done and make tweaks and adjustments to perform better in the coming iterations. Once you’ve nailed scrum and you have a product backlog with well defined stories, which are easily estimatable, then you’re ready to mature to a really valuable, efficient and data-driven kanban implementation. Eventually, when you’re able to size your stories all the same, you can do away with estimating as your cycle time will remain constant. Allowing you to set regular reviews and inspect/adapt cycles. You’re one step closer to programmer anarchy!

So, should you start with scrum, or kanban? Kanban allows you to start your agile journey without upsetting the status quo; you don’t change any names, or add/remove roles. You simply illustrate your process on a big visible board and become accountable, as a team and a company for the work you do. You can implement any agile practise you like (standups, backlogs, user stories, etc) and see how they work for you without rocking the boat. Scrum, on the other hand, requires a reboot and an installation of a new process, one with constraints *built in*, but the benefits are numerous and valuable right off the bat.

Should you start with scrum, or kanban? The answer, I think, is ‘it depends’. If your organisation, including those at the top are comfortable with scrapping your current process and starting something new, even with it’s inevitable lead time, then go for it. Use scrum and the constraints will help you become agile. If your organisation is reticent to start, or you have buy-in from teams, but not the business, then start with kanban. It’s lightweight and non-intrusive and will still allow you to raise your impediments and issues (but solving them often requires bold and honest action, beware!).

Should teams transation from scrum to kanban? Probably, but make sure it is for the right reasons and that your team is mature enough to make the most of it, if you’re not sure, then try transitioning via scrum-ban, it’ll help you see the benefits and enable you to get better at the things which make kaban most useful, without changing more than you are comfortable with.

I’d be interested to know how others started their agile journey, or whether many transition from scrum to kanban (or the other way). Drop me a mail, tweet or leave a note in the comments!

Agile core values: working software over comprehensive documentation

Documents Enclosed
Documents Enclosed, maybe. Anyone want them?

As humans, the best way to learn about something is by discovery. Discovery based learning and, especially kinaesthetic learning (fiddling with things in the physical space), is fundamental to our understanding of the world around us. Imagine a pre-school child. They cannot read, no matter how advance their parents think they are and will instead learn about the things around them by playing, poking, fiddling and, sometimes, breaking things.

As a man, I learn best about something by ripping open the box and playing with the content. Rarely will I pick up a manual, Only when I’m very stuck will I rummage through the packaging looking for it, but more often than not, they’re dull, badly written with difficult diagrams and just make the whole ordeal of finding out how something works more, not less, painful. (If I can’t find out how to make something work, I try not to blame myself, it’s nearly always the fault of the product. No, really, it is. Read The Design Of Everyday Things and you’ll understand!).

As a user, the same thing applies. I’ll find out how your software works by playing with it and, usually, online software doesn’t come with a manual. Some come with help pages, but not often on HOW to use the site, just the site functions. There are some great websites that slowly engage their users by offering functionality that doesn’t require signing in and making the whole signup process part of that engagment (anyone who has used Picnik will know about that).

As a product designer (read; interaction designer, UX designer, designer, whatever) I’ll learn about how my users interact with my product by watching them use it. This is key to my understanding of the user experience and how to make it better.

As a business owner or customer, I can play with the software that my engineers have created from some of my half baked ideas and, importantly, some of my users’ half-baked ideas in order to see if it’s what I wanted, if it’s what I thought I needed or even if it’s how I described it.

None of this is possible with half a pound of paper that someone (or someones) spent six weeks slaving over.

The trouble with documentation is that it’s easy to mistake a big wad of requirements for the sum total of features required (the clue is also in the name). If you give an engineer a requirements document, they’re apt to go away, spend some time building what the specs require and assume that, given the size of the weighty tome, everything they need to know is contained within it’s black and white, mono-spaced pages.

Of course, in most instances, they’d be wrong. Once they show the “finished” product to the customer, there will more than likely be a whole slew of changes, one or two “hmm, that’s not what I meant, you’ve misunderstood” and maybe even a “no, this is useless now, the market has changed and our users want X, Y and Z instead”. This usually results in a pissed off engineering team.

So, instead of comprehensive documentation, provide working software to your customer and do it frequently. They can provide feedback straight away, steer the engineers in the right direction if they’ve gone off course, or change their minds frequently once they’ve seen the software. Delivering working software frequently will create transparency on the state of the product and transparency leads to trust. Trust between your customers and engineers is so massively important to the success of any project you should take every opportunity to cultivate it.

On top of trust, you have satisfied customers who have spent money and, lo and behold, have been given something of value. You’re getting the right business value with constant customer/stakeholder alignment and you’re getting it faster than if you’d just created documents. If you’re working in iterations and creating potentially shippable software, you’ve created value. Of course, there’s value in documentation, you just can’t sell it yet. 😉

Still, this doesn’t mean you should never create documents. If you’re working on software for a heart monitoring machine, then you’ll need to be careful and so create documentation to meet due diligence requirements (and, to make sure your software does EXACTLY what it needs to), if you’re required to create documents for legal reasons or maybe you’ve got an exceptionally difficult set of algorithms or data bindings that you should capture, that’s OK too.

Just don’t create documentation for the sake of it. Working software is always more valuable and far, far more useful.

One of the principles of Agile is that we measure our success with working software. How much software is working? That’s how successful you are. How much documentation have you got? Who cares, I can’t use or sell documents (unless of course I’m selling documents).

Agile core values: Individuals and interactions over processes and tools

Actual is not normal (a tribute to Edward Tufte) by kevindooley
Actual is not Normal

The four core value of the agile manifesto are values which I strive to live by, both at home and in my personal life (where it fits, my wife doesn’t care how I write a birthday card, just that I do (although, I suppose that fits too!)). It’s the very core of my job as an agile coach, so I though it was a bit time I wrote a few articles exploring them and what they mean.

I really should have posted this sooner, but, for some reason I haven’t. I think, mostly, because I realised that I needed to get a better understanding of what the values (and principles, but they’ll come later) really mean. While I recognise that being agile is not a destination, but a journey (cheesey, right? But true). I think my understanding of them is now deep enough to write about them, so, without further ado, I present the first in a set of four articles…

Individuals and interactions over processes and tools

I struggle to believe that, in any organisation, there are people that think there is anything that is more valuable than it’s people. If you’re in one of those organisations, then, it’s probably time to look for a new job.

People are the one most important asset in any organisation and the key word here is ‘individuals’, no one wants clones working for them and the more diverse the people you work with are, the more satisfying and fruitful your work life should be. Having an interesting and diverse set of colleagues makes it that much easier to get up and go to work in the morning!

One of the mistakes that I often see made (and, unfortunately, perpetrated by a lot of online and digital scrum tools) is forcing yourself into using a process. It’s interesting to note that the two most popular agile methodologies don’t prescribe any particular process to follow with software development, but people believe that they do. Kanban, for example, is not just a board with a ‘todo’, ‘in progress’ and ‘done’ columns. Each column marks a step in your process. The process you already have. Scrum also doesn’t tell you how to build your sprint backlog, instead, it just says you should have one and is quiet on what you should put on it (with the exception of the sprint burndown, but that isn’t a process, just a tool).

Most companies will already have a process for the way they write software before they begin their journey toward being agile. Sometimes it might be as simple as describe, develop, deploy. Other times it will involve review, QA, regression, analysis etc etc. When you start your agile journey stick with the process you have, don’t make things harder for yourself by changing too much. Introduce the framework of choice and use it to help you see where your problems lie. Then, slowly, organically and by small, incremental changes begin to adapt the process you have into one that allows you to align with the agile principles and create great software (or any other product for that matter).

The point of this is that, really, the process doesn’t matter so much as the people using and creating the process. The tools they use don’t matter as much as the indiviuals working together to create the process and create, or use tools which support their endeavours. Having a process is important, but not as important as the people in your organisation using your process and adapting it to suit their needs in order to attain the principles of being agile. Having tools is important, if they’re the right tools, but not as important as how you use them and what you use them for.

If you’re somebody looking to implement agile in your organisation, or someone trying to make your organisation adhere closer to the agile ideals, then empower your people to improve themselves and their process and then leave them to it.

Hire good people, then get out of their way.

So, that’s the first core value. Next time, working software over comprehensive documentation.