And Why it Helps Smaller Firms Level The Field
I went to a well-known hamburger chain yesterday and asked for something a wee bit different from what was on the menu (double cheese and an extra slice of tomato, as it happens). The conversation went like this:
Me: Can I have that with double cheese and an extra slice of tomato, please?
Waiter: Quite possibly sir. If you could put that in writing and send it to the kitchen, our hamburger development team will pick it up and consider it in the next hamburger development cycle. They’ve only just started one now, so it might be considered in the following cycle. If they manage to fit your idea in with the hamburger developments they’ve already decided on then it should be ready as part of the Snowleopard version of Hamburger at some point in early 2017. It might be a bit pricey though….
Ok, so that didn’t actually happen – at least not in terms of a hamburger and not yesterday. But something like that has been happening in the software industry for years.
The way it used to be
In the bad old days, businesses paid a small fortune for software that had to be installed (often by a techie at additional cost) on every machine in the office. The software was the way it was until the next version was released, which we’d wait for with crossed fingers in the hope that the bits we didn’t like would be fixed.
We had no input into the design process as closed software design companies decided what was best for us, even if it wasn’t (Windows Vista, anyone?).
Because the software had to be installed on individual machines (or servers) it often incurred additional costs. And because any technical fixes had to be implemented at different locations, it also incurred additional costs. And because it was installed at so many locations, there was a long time between updates. And because there was a long time between updates, the updates were big and complicated. Which required additional training. At additional cost.
The result of all these additional costs, on top of the cost of the software in the first place, was that the majority of smaller firms were often priced out of the market, giving the advantage of using the software to their larger competitors and letting them stretch their lead a little bit more….
Thank goodness the bad old days are gone.
Thank goodness for agile software development.
The way it is now
So what is agile software development?
Agile takes a different route. It focuses on talking to the community associated with the development project – developers, business actors and most importantly, users. Everyone gets a shout at what should be developed next and where they would like the software to go.
Developers then program in short “sprints”, developing iterations of functionality and delivering them to users quickly who then feed back into the loop.
Agile methodology has become the industry standard since the “Agile Manifesto” was put together in 2001 and is now the modus operandai for big players like Amazon, Seimens and Salesforce.
But why is agile so much better?
Well, let’s start with these:
1. Users/customers/us/YOU get what you want
The openness of agile and the high degree of collaboration between users and programmers means that as each project is scoped, developed and iterated to produce software that actually does what the user wants it to do – not what some techie thinks it should.
With traditional development, a huge project is planned from the outset, with each interlocking part having an effect on the next – change one piece of the development and the rest falls over. With agile however, we can build each section one at a time, collaborate and iterate. We still have an end vision in sight, but how we get there isn’t set in stone.
3. Better software
And because we don’t commit ourselves early to a huge, untested project, each smaller iteration is tested as we go – producing an end product that just works better.
Traditional software providers often baulk at this one. They like to keep an aura of mystique about their development process, ultimately so that they can charge higher prices. If the design of software is seen as an “experts-only” process, then software house can charge more for their “experts”.
But there’s absolutely no need for this process to be shrouded in anything other than a crystal-clear pane of glass. The real “experts” in the process are you, the users. You know your business best and you know exactly what you need from a piece of software to get the job done.
Of course, software developers may have technical knowledge that you don’t, but it’s their job to translate the needs of the user into something that delivers. Like a good dj, developers’ are there to keep you dancing.
And that’s why transparency is important – you can see what’s being developed, you can input to what’s being developed and because of this, in the end you get a piece of software that does what you want and isn’t blindingly expensive.
5. Lower cost
Because of the collaboration with users, agile more often gets the product closer to what’s actually required. Iterations can be done while developers are still working on a particular section and less money is required by development companies to secure huge, long-term projects.
Combine this with putting software on the cloud, so there is only one location where updates are added, and the cost of the resulting software product tumbles.
This means that those smaller firms that were priced out of the market before can now afford the advantages that allow them to compete with their bigger rivals.
Playing field levelled.
6. Better relationships
This is a fundamental one. Collaboration breeds understanding, and understanding breeds better relationships. In closed development we end up with a “them and us” scenario. With agile it’s all “us”.
And that’s the way the world should be.
Want to know a bit more about agile? Try these links: