My recent renewed focus on consulting with Foolish Software has lead me to a very disturbing conclusion. Web software development, particularly in the consulting space (but not exclusively), is broken.
If you think of a software as a car, it has many moving parts (an ever-changing selection of parts no less) and is bound to break down or need maintenance at some point in its lifetime. What’s worse is that it’s not a production car but a custom built machine. So when the creator goes out of business or moves on (which is usually fairly quickly) you are left with something that any mechanic can understand conceptually, but the specifics exist only in the head of the original creator.
A car is easier to quote accurately; you have certain parts at specific prices, and the labor is fairly predictable. So if someone asks for a Porsche for a Toyota price it’s easy to say no. It’s also easier for the consumer to understand why they can’t get it.
However, in software it is not uncommon for people to ask for the “Porsche” at “Toyota” pricing and if they are willing to sacrifice quality they can probably find some consultant whose price is low enough that they might get it. Or at least get what they naively believe to be it.
This is because the average consumer of software development services can’t comprehend the difference between quality workmanship in software versus a hack-job. And in some cases the hack-job is good enough.
But let’s assume that quality vs price is not a real problem. Which it is, but many people will argue with me that good enough is just enough and that you deal with the other problems later. But for the sake of argument if it isn’t a problem, software development is still broken in one more profound way.
Development is mostly looked at as a transactional service and not a partnership. This is probably the biggest area of concern. When software development is transactional, the client has a budget that usually only covers a portion of the initial development costs and little else.
The salesman working the deal needs to close, so she manipulates the finer points. No paired resources. Simplest possible solution (which often is just lip service, and code for “we’ll cram it in somehow”). No testing. This leads to cut corners, no predictability, and zero documentation.
If you cut corners at the onset, it may run fine for a while, but eventually, when people actually start to use the software in a meaningful way, its deficiencies make their way to the surface, and the initial developer is no longer around.
Nobody has kept the code up-to-date or optimized anything. Back to the car analogy, nobody has changed the oil, rotated the tires, or fixed the breaks. So what happens? Breakdown, crash, panic mode, and draining expenses to fix it.
Unfortunately, the industry is built around this transactional model and is very difficult to break. Established companies have the best chance at breaking out. They have a reputation and a bankroll to allow them to be selective. To be willing to say no the bad customers and have enough momentum to attract the good ones.
A new company just starting out is trying to pay the bills any way they can. They take the crappy work knowing the damage that is likely being done, in the hopes that they can get enough business to break through that ceiling. It rarely happens. And thus there will always be crap work to grease the gears of the endless cycle.
What can be done then?
If you are a company looking to hire developers or consultants, think about how you plan to maintain things a year or two out. What will happen when your team goes away? Is the software important enough to do it right? If so, remember that software development never ends. If your business relies on custom-built software you will always be working on it.
If you plan to offer software development consulting as a service, do right by your customers. Price it right. Include everything necessary to set your customers up for success and don’t bend. Delivering crappy software for a few bucks is not a sustainable business model and while customers may say they’re OK with cutting corners, they are lying.
When the software breaks, they will call you, and you will find yourself spending weeks or even months of non-billable hours fixing stuff they agreed to neglect. Because after all, they agreed to cut corners, not to non-functioning software.