Our previous articles explored the messy middle and how business architecture is integral to a business transformation strategy. Thanks to the pandemic and its aftermath, almost every organization launched transformative initiatives, but the success of delivering customer delight has varied. Enterprise agility has rapidly become a crucial differentiator in a business’s long-term resiliency.
While the rewards of agility are high, organizations are struggling to implement critical technologies and adhere to the methodologies that can get them there. The 14th Annual State of Agile Report notes that 59% of organizations follow agile principles, but only 4% of these organizations are getting the full benefit. But the ability to adapt quickly, seize new opportunities, and reduce costs is critical for survival in the ever-evolving and hypercompetitive digital age.
Agility is about adapting quickly to changes and increasing productivity. It is a mindset first, and embracing agile methodologies and going through the motions will not magically transform enterprises into agile organizations. Instead, the focus needs to be on practicing the correct principles to become truly agile. There are two essential principles—programmability and observability—that increase productivity and allow for innovation. We explore programmability in this article and observability in the next.
Programmability describes the capability of hardware and software to change and accept a new set of instructions that alter its behavior. There are two predominant approaches to programmability.
The first approach is to connect analog devices with software. A popular example is networking software, firmware, and plugins to control hardware (such as switches, routers, and other analog devices) and bridge software systems. The rising popularity of infrastructure-as-a-service (IaaS) has increased the demand for programmability and instituted concepts such as infrastructure-as-code (IaC) and software-defined networking (SDN).
The second approach is to extend existing software capabilities. The two most widely known examples of this are application programming interfaces (APIs) and software development kits (SDKs). Using both approaches, a developer can extend the default capabilities of an existing system. The evolution of APIs from functional to business APIs has significantly championed the introduction of programmability into application software systems. This approach is particularly popular with application service providers and enables end-users to extend and customize core capabilities provided by a product or service.
Connecting Agility and Programmability
So how are these two concepts connected? Leaders with an agile mindset should strive to create the right environment for agility to blossom and become a part of the organization’s culture. We need to have the correct change agents to drive agility at every level of the enterprise. Then, we can leverage programmability to deliver value through the organization in a consistent, repeatable, and predictable manner.
An enterprise with highly programmable components reduces the time to respond to volatile market conditions, improves productivity, efficiency, and happiness in its workforce. We can achieve this by having strong business and technology alignment as we drive programmability in an agile transformation.
Programmability in Business
Let’s consider a typical business use case of procurement. When a purchase order (PO) is received, the customer care representative must verify the organization’s ability to fulfill the request and create an order in the back-end customer relationship management (CRM) system. Traditionally, this process has required a good deal of manual effort:
- Extract the PO data.
- Verify the details using other systems, techniques, or spreadsheets.
- Enter the data into the CRM system.
Programmability in a Technical Environment
In a legacy organization, the software development life cycle is predominantly waterfall in nature:
- Software developers write code.
- Quality assurance (QA) engineers test the release.
- Release engineers or a change control board verifies it.
- Operations or DevSecOps team has to deploy the released artifacts.
Like the business use case, this technical workflow traditionally requires extensive, tedious, manual toil and is prone to delays and errors.
However, this process becomes significantly more streamlined when the development organization makes the environment programmable. In this case, once developers commit the code, automation kicks in, exerts the committed code, runs through the life cycle stages, and deploys it into production. Programmability enables continuous integration, delivery, and deployment. These techniques allow teams to streamline repeatable tasks, empowering the workforce to focus on high-value innovation and customer-centric design.
Let us look at the implementation details in these two use cases.
Programmability in the Digital Supply Chain
Workflow automation, such as PO processing, is treated as part of a modern digital supply chain initiative in the business use case. The systems, messaging, and data involved in such a flow are linked together using integration technologies.
Integration approaches first involved point-to-point connections and then evolved to use centralized enterprise service buses (ESBs). More recent, modern approaches have centered around API-centric, integration microservices, and integration platform-as-a-service (iPaaS) solutions that use decentralized models and cloud-native technologies.
Nowadays, organizations build or acquire digital platforms by combining APIs, integration, and security technologies to create digital supply chain flows. Critical to the success of any digital supply chain is the ability to select systems with built-in API capabilities and enable existing systems to expose applications and services as APIs and make the entire enterprise programmable.
Programmability in a Secure Software Supply Chain
In our technical use case, DevSecOps automation provides the foundation for automating various aspects of the software life cycle. Here, development, testing, and governance-related tools are connected using a pipeline-based approach called a secure software supply chain.
IaC and automated build servers are two popular technologies used in automating such flows. Puppet, Chef, and Ansible are widely adopted IaC scripting languages, while Bamboo and Jenkins are popular build servers. As the DevOps space has evolved with cloud-native and decentralized technologies, GitHub and GitOps play a vital role in building effective pipelines. Declarative pipelines are the preferred route for maintaining programmability in secure software supply chains. We must incorporate programmatic approaches to assessing code quality, unit testing, automated testing, infrastructure provisioning, artifact/image building, dependency management, and deployment to make the secure software supply chain valuable.
Enterprise agility—the ability to adapt quickly and innovate while reducing costs—is critical for an organization to survive and thrive in this hyper-evolving digital age. While the rewards of bringing about agile transformation are significant, less than 10% of companies successfully achieve their objectives and key results. Even organizations that follow various agile methodologies do not adhere to them across the board, resulting in what’s known as waterfall-agile or wagile approaches.
A pragmatic approach to becoming genuinely agile is by embracing programmability as the primary approach to value creation.
With programmability and secure software supply chains, mundane and repeatable tasks are automated and become systemic.
Teams increase their productivity, reduce manual toil, and focus on high-value activities such as innovation and customer-centric design.
As we implement programmable approaches in the organization, we must clearly understand how this value is managed. This emphasizes the need for enterprise observability, and we will examine observability in our next article.