Two apparently distinct movements are in the process of disrupting the world of enterprise application development: DevOps and Low-Code.
DevOps is a cultural and organizational shift that empowers enterprise software teams to deliver better software quicker – in particular, hand-coded software.
Low-Code platforms, in contrast, provide a technology platform and visual tooling that empower enterprise software teams to deliver better software quicker — with little or no hand-coding required.
Two disruptive approaches with remarkably similar value propositions. Except that one emphasizes hand-coding while the other replaces it.
The obvious question: are we in for some kind of appdev battle to the death, as the two disparate approaches fight for supremacy?
Or are we somehow setting ourselves up for a delightful Kumbaya moment, where DevOps and Low-Code live together, happily ever after?
If we take a closer look at these questions, however, a number of subtleties emerge. Low-Code can help DevOps adoption – and vice versa.
And while Kumbaya won’t make it to our playlists any time soon (thank goodness), fleshing out the vision of appdev in the fully digital enterprise highlights important aspects of both movements we might have overlooked.
One of the toughest decisions any IT exec faces during their career is whether to buy a commercial off the shelf (COTS) software package or alternatively, get their team to build one from scratch.
The advent of the cloud split up the ‘buy’ part of this equation, adding various subscription options to the standard licensing models that have been around for decades.
Today, Low-Code is having the same effect on the ‘build’ part. It’s no longer build vs. buy. Instead, the ‘build’ option has now split into two: build with Low-Code vs. hand-code.
According to many of the Low-Code vendors, the hand-code option will soon be a relic of days past, as their platforms will cover the full spectrum of bespoke software solutions.
While this sweeping statement may very well become true at some point in the future, today’s Low-Code platforms don’t replace the need for enterprises to hand-code software entirely.
What is true today, however, is that the Low-Code platforms are maturing rapidly. As a result, the types of applications suitable for Low-Code are growing in number, while the number of applications an enterprise has no viable alternative but to hand-code is shrinking.
If an organization believes its DevOps efforts focus entirely on the hand-coding part of this equation, therefore, then the inescapable conclusion is that the need for DevOps in the enterprise is actually shrinking – with its demise only a few years hence, if that.
However, the assumption we based that conclusion on is deeply flawed. In fact, if IT leaders have focused their DevOps efforts solely on hand-coded applications, then they don’t understand the point to DevOps.
Depending on whom you ask, you are likely to get two quite different perspectives on what DevOps is and why an organization would want to adopt it.
First is the appdev-centric view: DevOps is a cultural and organizational shift for creating and deploying better software faster – with a particular emphasis on hand-coded software. Yet, while it’s difficult to argue with this perspective on its face, it’s not the whole story.
That brings us to the other view of DevOps: an approach to breaking down organizational silos by instituting a culture of cross-functional, collaborative self-organization in order to better align software efforts with customer needs and demands.
Software plays a central role in both perspectives, of course – but the first view centers on hand-coded software as DevOps’ central motivation. This perspective would lead to an eventual demise of DevOps as Low-Code matures.
The second view, however, centers on software as an enabler of an end-to-end focus on the customer: end-to-end in the sense of the customer at one end, systems of record on the other end, and the entire enterprise in between. In other words, this view of DevOps centers on what it means to become a digital enterprise.
Furthermore, when we say software in this context, we’re not referring to hand-coded software per se. Instead, we’re talking about the full breadth of software-based value in the enterprise, from the software-defined network to the infrastructure to the applications, all within the broad context of hybrid IT.
Digital enterprises, after all, don’t focus on how they build software. They focus on how they meet the needs of customers – and that focus drives behavior across the organization, rather than in particular silos.
In this context, Low-Code becomes an essential enabler of DevOps, because it both accelerates the time to customer value as well as facilitating the cross-functional collaboration among stakeholders and application creators so essential, not only for DevOps, but for Agile approaches in general.
Low-Code can thus be an enabler of DevOps by streamlining the application creation process while facilitating better collaboration. The combination of Low-Code and DevOps can also help to resolve the pushback against Low-Code so prevalent in IT shops today.
As I explained in a recent Cortex, many organizations are facing pushback against Low-Code/No-Code initiatives from the ranks of professional developers, who feel threatened by the simplicity of building apps with such platforms.
If such an organization is also transforming to a DevOps culture, however, then the reasons for the pushback against Low-Code stop making sense.
The essence of the DevOps culture is cooperation, and the key to cooperation is empathy. In other words, DevOps organizations favor and encourage the breaking down of organizational silos by fostering better human interactions among people who had previously fallen into different organizational units.
The root of the pushback against Low-Code, in contrast, is a fundamental ‘us vs. them’ mentality that pits the appdev team – or in some cases, the entire IT organization – against the ‘business.’
I put ‘business’ in quotes here because the belief that the part of the organization outside IT is the business part is itself a fiction that derives from this misplaced us-vs-them mentality. In reality, of course, the entire organization is the ‘business.’
The bottom line: for organizations to succeed in the digital era – that is, to become digital enterprises – they must dispense with such adversarial patterns across the board. The best way to accomplish this task? Move to a DevOps culture.
It’s possible to sum up the discussion in this Cortex into two concise pieces of advice:
If you’re moving to a DevOps culture, then implement Low-Code in order to further the collaboration and rapid development goals of DevOps.
If you’re implementing Low-Code, then move to a DevOps culture in order to facilitate the collaboration and customer-centricity necessary to break down resistance to Low-Code.
To these two core tenets, we could add a third:
If your organization has yet to implement Low-Code and has also not begun its DevOps journey, then moving forward with both efforts at once will lower risk, accelerate your time to value, and bring you closer to the goals of digital transformation faster than implementing either in isolation.
What are you waiting for?
Copyright © Intellyx LLC. Intellyx publishes the Agile Digital Transformation Roadmap poster, advises companies on their digital transformation initiatives, and helps vendors communicate their agility stories. As of the time of writing, none of the organizations mentioned in this article are Intellyx customers. Image credit: Deb Nystrom.