For better or (more likely) worse, healthcare.gov is the most visible aspect of what seems to have become the white elephant of the 21st century, officially named the Patient Protection and Affordable Care Act, also known as PPACA, Obamacare and ACA. It certainly didn’t help that healthcare.gov had massive performance issues from the very beginning. And while performance has improved over time, things still aren’t really looking up, as “conversion” rates are very poor, actual payment for policies is not yet implemented, and there are significant concerns about the potential for (and some claimed actual) security failures in the site itself. But given that this is a software project, and that we’re a software company that has made mistakes just like everyone else, what learning experiences can we draw from it?
Given that I’m writing this post, it’s obviously my view that there is plenty to learn in the healthcare.gov debacle, even if one has to emphasize in bold and underline the disclaimer that we aren’t on the inside and all of our observations are based on what others are saying about it. With that, let’s go for a count-down style postmortem, setting aside the literal meaning of the word as the patient isn’t dead (yet?).
5. Top Level Executive Meddling
I know from experience that the best projects have a clearly articulated goal, a measure for success, and top level management that steps out of the way for the implementation. Considering the political hard ball that was played to get ACA enacted, it’d be surprising to not see top level meddling in its implementation.
But it’s fair to expect some categories of interference to be off-limits, such as messing with the timeline. After all, shouldn’t it be obvious that one can’t randomly push intermediate milestones and expect both the release date and functionality to remain constant? Yet that’s what the White House seems to have done to ACA and healthcare.gov in the run-up to the 2012 elections, with delays to regulations that impacted the implementation of ACA and hence healthcare.gov.
4. Design By Committee
The more cooks the worse potage is an age old idiom. Given massive complexity, multiple players, and outsourced development, it’s frankly surprising that anyone had time to actually work on the code for healthcare.gov after sitting in one design meeting after another.
Design by committee doesn’t have to be bad by its very definition. For example, the Apollo space program placed men on the moon even though it seems to also have been one massive design by committee session. Perhaps the difference was that everyone at NASA knew the easily articulated goal and the risks to be managed, not to mention that those working on the program were perhaps the best and brightest in the nation.
Hence we can draw the conclusion that healthcare.gov probably did not have the benefit of those same factors and might’ve been better managed by a smaller more targeted team.
3. Outsourced Development
Outsourced development can be a massive cost savings if implemented correctly. But that “if” is a massive one, requiring clear specifications, ownership of the big picture by all parties, and extra time for the inevitable delays.
It’s unclear exactly how much outsourced programming impacted the result, but having observed other outsourced projects over the years it’s easy to say that a small focused development team is a much safer bet when specifications are loose and ever changing.
2. Complexity
The problem with complexity is that it becomes more difficult to see the big picture, let alone the goal. Hence, difficult problems require simple answers.
When Burt Rutan – with a hat tip to financing from Paul Allen – built SpaceShipOne (SSO), it only cost $25 million, and is an excellent example of simplicity overcoming big challenges. Complexity of multiple stages? Airdrop instead. Complexity of atmospheric re-entry? Feathering wing design. Complexity of landing gear? It doesn’t get simpler than a front nose skid. The Rutan touch was likely found in every major system of SSO.
To retain the safe impacts of the drug and results in http://amerikabulteni.com/2011/12/25/apples-new-plans-to-use-hydrogen-in-batteries-revealed/ buy cheap cialis delaying action. Although viagra tablets 100mg originates from trustworthy source, still you need to seek doctor’s consultation to determine the negative effects. The treatments usually on line cialis sale depend on the cause of ED. Here generic tadalafil online are few new techniques to build up massive muscle, which is really amazing. Contrast that with my favorite, the baggage handling system at the new Denver airport that suffered from complexity (and other) problems until the system was finally euthanized after 10 years of not delivering the savings and performance it was supposed to.
Healthcare.gov clearly suffers from the fact that the ACA law is a 1,000 to 2,000 page monstrosity, and the related regulations are said to be 10,000 to 20,000 pages. (Note that there is some dispute about the exact page count, hence I am quoting generally accepted book ends to not detract from the fact that the law is massive.)
Trying to incorporate requirements of that magnitude into a workable site is always going to be a long shot, regardless how much time and resources are available to do it. In the case of healthcare.gov, the NY Times provided a poorly substantiated size of 500 million lines of code for the site, which is likely off by several orders of magnitude, considering that the Boeing 787 flies with only about 1% of that.
There are examples of how simplifying the problem allows a disproportionate reduction in the resources needed, such as healthsherpa.com. Naturally the HealthSherpa site would’ve been completely inadequate for the requirements imposed by ACA, but illustrates the benefits of approaching the problem differently.
1. Starting Off With Too Much Money
Healthcare.gov has cost $677 million through October 2013, and it’s not done yet. To put that in perspective, Facebook took 6 years to hit the half a billion mark, and LinkedIn and Spotify have raised less than that for their operations combined. Another way to look at it is that, assuming that about half went towards headcount and those heads were an average of $150,000 per year, some 2,257 work years have been spent on the project through the end of 2013.
It seems that whoever was running the show didn’t know, or ignored the fact that in the tech industry there is an unusual phenomena that exhibits itself with startups that are too well funded. In effect something that gets too much funding is more apt to fail because it had too much funding.
How does that work? It’s all about inefficiency and lack of a need to find elegant solutions due to limited resources. When resources are effectively limitless, the “safe” solution is an ever increasing avalanche of slideware and additional management layers, with little time spent on details and how things will actually work or get implemented. Before long the monstrosity grows to dimensions where no single individual or focused group can keep track of it all. This is inevitably followed by failure in the implementation phase when things just don’t work.
Don’t believe me? Ask those who worked on Windows Vista about it. Or the guys who did Intel Itanium. Or Taligent.
The Learning Experience
One of the people who read a draft version of this article appropriately pointed out that the points are less about software development and mostly about project management and the underlying business purpose. That is probably the best summation of the problem faced by healthcare.gov. A large but seemingly straight forward software development task was made difficult by the way the problem was approached at the “business” level. Many a blog post have been written about it.
The problem with healthcare.gov is that it’s tied to the ACA not just at the hip, but at every level. This isn’t like building a luxury hotel the wrong way around, with the kitchen towards the best views, where a reasonably workable solution was to simply extend the hotel to restore at least some of the view (Banff Springs: The Story of a Hotel, page 18); or the bridge in Chile that had its decks built upside down, but was apparently saved by a design where the sides of the deck are symmetrical.
At this point it seems that the future of healthcare.gov will not be decided by the functionality of the site, but the product that it offers. The requirements, regulations and new taxes that were introduced with the ACA are driving the cost of insurance up significantly, and this is especially pronounced in the individual insurance marketplace that usually provides lower premiums in exchange for lesser coverage. Now that ACA mandates higher coverage minimums regardless of individual preferences, the costs for “equivalent” insurance can easily be double what an individual paid up until last year. Given that insurance companies can no longer offer non-conforming insurance at their traditionally lower rates, it is no surprise that the business aspect of healthcare.gov is suffering as a result.
Perhaps the real learning experience with healthcare.gov has little to do with software development, but more with pace of change. It’s usually best to shy away from revolutions, as they tend to devour their children, even if the subject matter is a section of the economy.
