I think the one thing that really ticks me off about this industry more than any other is the fact that we constantly treat our end users very poorly. Now those of you reading this are likely of one of two minds: Some amount of you think this is a very true statement and the rest of you think its complete and utter bollocks. Which group are you in?
Let me start off by explaining why I’m part of the former group. To put it simply I think despite the endless hemming and hawing around user experience we actually treat our users very poorly. Consider the consequences when anything goes “down” in tech. Does the provider who kicked off the unforced error pay the price? Not based on their contractual obligations, no. Do they lose money? Generally not. Do they lose productivity? Maybe. Their end users on the other hand suffer in all of these ways. Do the providers find a way to compensate their end users for the chaos their unreliability injected into their day to day existence? Almost never.
But okay I hear you saying, “It’s easy to feel this way after watching CrowdStrike rip the world to shreds a few weeks back and experiencing a very long and painful Azure outage just this very morning.” Well sure it is, but that’s why this post is going to go a little deeper than that. Probably deep enough to leave a bad taste in the mouth of everybody who made the choice to click through and read it. Strap in because this ride is going to get very bumpy. Suffice to say, that the idea for this post popped into my head almost immediately after reading this article on CNBC which states that Delta Airlines (very hard hit by CrowdStrike) is now lawyering up in preparation to sue for damages. I think this news is amazing and I want to see more and more of this kind of consequence applied to these sorts of incidents.
But let’s be clear: this isn’t just about cloud providers and security snake oil vendors. It’s about software in general. Those of you who read this blog already know that I think “Proprietary Software is a Dead End” and can easily surmise that I feel even more strongly about that after these recent incidents. Those of you who are new, consider yourselves informed. However I am like most of you a hypocrite of the highest order imaginable. That’s because I spend my Mondays thru Fridays writing proprietary SaaS software for my employer. It’s not particularly great software but it works. Mostly. But it is old and cumbersome and parts of the UI are absolute trash.
Like most Saas Providers with a legacy software stack, we are slowly attempting to update our User Interface. While on the surface this sounds really good, it actually represents a shot across the bow of our existing users. While some of them may approve of the new UI, the reality is that change of this sort isn’t free. Changing out the UI takes time and effort both from a developer standpoint and an end user standpoint. We in the industry ignore that second part because we are convinced that a “better” (such a terribly subjective and ultimately meaningless term) UI will always yield a net positive benefit.
Is this actually true? I think in a lot of cases it actually isn’t true. I think when it comes to existing users, they generally will resent a new coat of paint on an application which forces them to rebuild their tried and true workflows. This of course is hard to generalize as there are UI changes which are purely visual and UI changes which shift the entire workflow. The visual ones are probably mostly fine for existing users whereas the workflow ones have a tendency to incur massive productivity losses, at least in the short term.
But here’s the thing: We as an industry don’t give a shit. At all. “Adapt or Die” seems to be our mantra and over the years I have been very sympathetic to that idea. But the truth of the matter is that as I get closer and closer to never working in this industry again, I am beginning to realize that a lot of these changes that we shove down the throat of our end users are mostly bullshit. We just like to endlessly fiddle with things. When it comes to maintaining a tried and true tool, we as developers have a deep-seated need to justify our existences. Without incurring some level of change, we really can’t do that effectively.
I think companies that keep a large contingent of UX people and software devs on hand will always be in the side business of exporting chaos to their end users. Because unless they do that, most of those people don’t really serve any purpose beyond satisfying Wall Streets inane and ultimately unsustainable demands that revenues and profit margins always be growing between one quarter and the next. In the SaaS business, especially in the publicly traded portion of it, we just can’t help ourselves. We have three ways to increase revenue:
- Charge Existing Customers More
- Sell More Services to Existing Customers
- Sell Services to New Customers
Now lets be clear, I’m not arguing that user interfaces should NEVER be updated. I’m merely arguing that the way in which we do it is needlessly disruptive. As part of a major UX revision, have you ever seen any tech company ever offer free training sessions to their existing users? Maybe once upon a time decades ago, but certainly not now. In today’s world users can go to bed knowing that their internet connected electric car UI worked one way only to wake up and discover that it now works in a completely different way. That’s surreal to me. As an end user, I have found it to be very frustrating in the past especially when I’m caught unawares and just need to get something done but instead have to deal with my reliable workflow now being in shambles. The reason its this way is because we can get away with it. The reason it remains this way is that this is just one of many ways that Big Tech keeps its profit margins high which keeps their leprosy ridden puppet masters in Wall Street Banks (aka Institutional Investors) happy.
Users need better representation in this system of ours. As of right now they are getting the short end of the stick. As this screw job basically represents the status quo, everybody including the end users, mostly seems fine with it. Hell even us developers get nailed with this kind of thing all of the time. Every time a new version of React or Redux hits, it can incur massive pain. The same goes for new versions of C# and NodeJS. It will never cease to amaze we how willing we are to tolerate this kind of thing either. What did we gain for the time we wasted adapting to these changes? Generally the answer to that seems to be, “We figured out how to make shit work again”. That’s really not good enough.
In any event this is the line of thought that led me to conclude earlier today that “Our Users Deserve a Bill of Rights”. What’s most shocking to me is that this perfectly sane and rational thought had never once occurred to me before. In retrospect it seems like such an obvious thing.
Let me be clear: I’m not prepared to propose what should in this Bill of Rights, at least not yet. Even some of my initial spit ball ideas are rife with all kinds of unintended negative consequences so crafting a list of rights that doesn’t also permanently neuter the field of software development is going to be challenging. Take this one as an example:
Users should be compensated in the event that the software fails through no fault of their own
Well on the surface this sounds pretty great… but once you start to consider that a lot of the software in use today is Free or Free and Open Source software, this actually doesn’t seem that great because this rule would turn producing such software into a massive liability. Well okay then, let’s revise it:
Users who pay for software should be compensated in the event that the software fails through no fault of their own
Well that compiles, so let’s ship it, right? Well not quite yet. So what about software we don’t pay for? Does this mean that Fedora can ship me a terrible kernel update that destroys all of my hardware and effectively be left blameless because I didn’t pay for it? Well that doesn’t seem fair. That’s not even taking into consideration that every single dev tool I listed a few paragraphs back is basically freely available software, so giving them a free pass doesn’t seem right either.
This is not a simple task. In any event this is something I’m going to think on and if I ever manage to produce a list of basic rights (aiming for something similar to the Agile Manifesto here in terms of approachability) then I will certainly publish it here and delightfully feast on the river of internet hate that would be sure to follow.
My gut tells me that composing a list of rules that cover remediation for disaffected end users probably won’t fully solve the actual problem. The reason for this is simple: We as an industry are obsessed with switching out our preferred set of abstractions every few years and the negative impacts of this obsession resonate throughout the entire world. We have to find a way to cut loose of this obsession. I realize that this level of pointless change tends to keep most of us employed and theoretically happy (well except me and 80% of the other devs out there according to the most recent Stack Overflow survey that presumably wasn’t just filled out by an army of LLMs).
Let me close by sharing this thought with you: Imagine if we lived in a world where the manufacturers of carpentry tools decided to change everything for no good reason every few years. “No sorry, that hammer won’t work for you anymore, you now need this new-fangled widget manipulation device”. That’s a scary thought. But like so many other professional crafts, I still maintain hope that our craft will one day grow up and recognize that there is an important and salient difference between actual innovative change and merely disruptive change. We are mostly in the business of generating the latter and not so much the former. I believe that we can and should do better.
With that, I promise you there is more to come on the User Bill of Rights. It’s one of many threads that I’m tugging on here, but I will return to it. Stay tuned!