
To start off I would like to give a few facts on software projects, derived from my own observation in the past 7 years as an IT project manager:
* In many a software project the only discipline that has more than 1 person is the development team
* The development team is the only team directly producing the end product
* Development takes the biggest % of hours and cost of the project (on average 55%)
In a previous post I have already mentioned two general causes on project failure i.e. people are not robots and doing things for the first time is notoriously difficult.
Since the above aspects are hard to avoid in the real world, I have been looking deeper into these 2 factors to discover some concrete aspects that can be controlled.
A logical conclusion from the above mentioned facts is that, when trying to control a project, the most urgent question to be asked & answered is "what has to be done before the development team can start producing at fast rate".
I want to put in perspective the usual culprits of project failure as Well documented by the Standish research Group:
* End user involvement
* Backing of the executive management
* Quality of specifications
* Expectation management
Indeed, I have rarely seen a project where the lack of requirements or specifications are the sole or main cause of failure. In most projects the main goal is reasonably clear. The fact that project success requires not just having the cake but having a cake with a red cherry on top, I just mention here for the sake of being complete.
Let me get back to my statement that more focus should be put on the development.
To get to a point where one can produce at a fast and steady rate you need to build a production facility first, yes?
So to get a software application at a reasonable fast rate you need first to design and build a factory that spits out lines of code. Have you ever seen a factory being designed & build and producing end products from the first day that construction starts??
So pay respect to this first important step "building and testing the factory", before embarking on wishful planning for releasing code fast.
The RUP methodology calls this the Elaboration phase.
This phase is very critical and elusive and determines for 90% whether the project will still have time, money and the desire of the stakeholders to have its cherry or even finish it.
Following the above, I give you some important causes of project failure (again derived from my own observation):
* a difficult decision making process on a complex architecture with many external interfaces
* a considerable sized project (starting from 100 function points) (implied here is a lot of work to build the backbone of the system)
* the use of tooling or techniques that just been invented and still has growing pains
* resources that lack experience (but usually not the interest) in the tooling or techniques being used
Expect a slippery slide for your budget and timeplanning when these statement are made by your architect and other team members:
* it is nice because we can use the latest tooling and learn a lot
* there is a part that requires the new tooling but it's not going to be much
* a lot needs to be decided still but we cannot plan too much in advance or into much detail.
* its not useful to invest in a detailed work breakdown for building the architecture, that will come along when the project advances In many cases the gloomy fate of the project is even more exacerbated due to lack of recognition for the need for a technical team lead that micro manages the developers.
For example, in the designing and building the factory phase many ideas come from each developer on how to best do things, these ideas have to be consolidated and synchronized through coding techniques. If not done (properly) the factory will be dysfunctional for sure and lead to an overrun on the elaboration phase.
In summary.Consider well beforehand the technical choices that have been made by your teammembers or by your supplier. Be realistic about the impact of the choices on the cost of the learning curve i.e. the likely overrun in the elaboration phase.
Be also aware that many suppliers underestimate or are not aware of the cost of the learning curve.
So the best thing you can do as a customer embarking on a new technology project (e.g. SOA, Business intelligence) is to ensure that your team or supplier is providing a pool of resources that have already made it through the learning curve.