Recently, we were working with a customer to migrate data to TownCloud and we noticed that the system we were replacing was built on a COBOL platform. This was only purchased two years ago so I was taken back by the fact that a major Govtech company still has front-line software built on a 1960s programming language. As a result , I feel compelled to share my reflections on the issue.
The Origin of Maintenance
When Govtech companies began charging maintenance in the 1980’s it was sold as a means to fund the R&D investment needed to keep the software current with Technology. At HTE, we absolutely did that. When we went public, I can remember our CFO lobbying the board for “cash cow mode”. This was a scheme to reduce all ongoing maintenance to the minimum (or below) what was needed to keep the software operating. The mentality was (and is) that shareholders and management were entitled to greater profits and that companies could make great profits without new customers and even with decreasing market share.
While Govtech companies were engineering bigger profits, customers became complacent and accepted higher “maintenance” fees for reduced service levels. The prevailing thought seems to be that systems will gradually decline and eventually a massive investment will be necessary to replace them with something new selected through the flawed RFP process. The high cost and pain associated with software replacement has allowed big software companies to profit greatly from outdated, inefficient, and insecure software.
There is an Alternative
Today, almost all systems can be integrated so there’s really no need to keep any component that’s not functioning efficiently. The big Govtech approach is to go out and buy something and then promote addons as a part of their “solution”. Instead of investing in R&D, they engage in M&A. They then financially engineer the acquired companies. What this really represents is a cynical attempt to charge for functionality that should be a part of their base systems.
Most governments don’t realize that it’s possible (and desirable) for them to seek their own alternatives to ineffective aspects of their systems. The best way to replace an outdated enterprise system is one piece at a time. New components can be integrated with existing systems easily and without significant disruption. Through this approach customers get to experience new technologies without being “locked-in” to a system that is often worse than the one being replaced.
Once a customer breaks the cycle of “addiction” to a bad vendor, they will realize that the entire system can be modernized in manageable phases and there will never again be the need for another painful “big bang” conversion.
Ironically, this competition will even be better for big Govtech because it will force them to innovate. Everybody wins.
Every city should have ongoing projects with multiple vendors to ensure the constant modernization of their enterprise software.