Think about it, if you will. Over the recent years fundamental changes in how business operates have moved technology from being a cost center to a vital competitive enabler.
Customer expectations, both B2C and B2B, have grown to include instant communication and brand engagement across a range of channels, product flexibility and competitive pricing. Supply chains have grown from being a global manufacturing reality to a massive flow of data, powering company-to-company collaboration between industries and across geographies. Products and services cannot be delivered without it.
This fundamental notion of how business perceives and leverages technology will determine who survives and who doesn’t. The winners will be those that master technological innovation and can respond rapidly to changing conditions. Those that are slow to adapt will fail, as will those that don’t embrace the innovation imperative.
Unfortunately, this growing need for technological prowess also comes at a time of growing technology inequality. The newer generation of high growth companies are inherently more agile; free from legacy technology decisions and monolithic and expensive initiatives. While older companies are stuck with dependencies on creaking old systems, can’t attract key new talent, and all too often they lack the culture and will to change.
The Computer Says No
Originally intended to be labor saving productivity tools, technology has all too often turned out to be a major impediment to business growth and agility. This has happened gradually and in plain sight, often through lack of executive engagement, failing to comprehend how their business was becoming dependent on systems which they often resented investing in from the start.
Traditional software architectures gave birth to monolithic, closed systems, which made changes difficult. Heavy customization of packaged software meant that updates to new versions became impossible. Fragility increased as internal complexity grew, as more and more features were bolted on, making changes fraught with peril.
Risk-averse design methods and over-cautious deployment push out schedules for what could be delivered in time frames that supported strategic business initiatives.
When combined, these constraints mean that IT departments are forced to spend most of their budget and time on “stand still”, while they continually focus on keeping legacy systems alive and running. It also results in much of this heavy enterprise technology lagging behind what was and is available commercially.
As an example, I was delivering mobile apps in 2004, and fifteen years later many companies still offer no mobile access to their systems. This generational lag has both short- and long term impacts, not the least of which is a serious impediment to the adoption of potentially game changing and business differentiating technologies such as blockchain.
Many modern software approaches have been specifically designed to prevent the progressive ossification of systems. Cloud infrastructure provides astounding hardware flexibility, allowing for software to expand and contract as loads vary. Containerization dramatically simplifies deploying and scaling software.
APIs link systems anywhere, often with automated discovery simplifying the technical aspects of integration. Microservice architectures and event-driven paradigms break apart large blocks into reusable chunks, allowing systems to be decomposed and recomposed rapidly via well-defined interfaces.
Unfortunately, these techniques frequently get entangled in the lag trap that they are designed to prevent; with any number of poor excuses preventing their adoption. The mainframe workload can’t be moved to the cloud, the in-house warehouse management system lacks any APIs, security won’t let us open our existing interfaces to the internet, we don’t have the skills, our policy dictates Oracle for all database applications, or we’ve lost the source code. All of these can be overcome with the right tools and techniques when backed by executive engagement.
The path to faster delivery of systems starts with a clear bottleneck: translating what needs to be done into executable code. For most organizations this still means written specifications hand translated into a systems language such as Java or C++ which was not originally designed for the task. Inevitably the coder lacks the required domain expertise and mistakes creep in, requiring tedious, costly debugging cycles to fix.
Agile processes look at desired business outcomes and seek to minimize the inevitable drift from what is needed by taking small steps and getting working code in the hands of real users quickly. Lean methods move away from the complexities of complex architectures by focusing on what is needed immediately, not what might be potentially needed in every eventuality. Both are important steps forward, however as normally implemented they still require manual coding by specialists.
Suppose that domain experts could construct the software they need without relying on software specialists. This idea is logical and has been around for many years with various names. Indeed, venerable programming languages such as COBOL were designed to remove the need to understand machine code and to think in business terms. Low- and no-code tools aim to remove the need for coding completely.
They key is to change the level of abstraction away from expressing a problem in terms of how the computing machinery works towards how the problem is understood. There have been two streams of innovation in this area. The first is making programming easier by providing bigger building blocks and simplified ways of connecting them. A good example of this comes from OutSystems, who delivers an IT-focused tool, which helps developers without front-end skills to build workflows and user experiences.
This approach to low code is essentially aimed at allowing more people to program. Yet, while systems such as these may democratize programming, they still miss the point that those people do not know how to move from the business problem to a program that delivers the required outcome. In summary, useful, but not democratization.
The second, and more important, approach to democratization is to focus on building domain-specific ways of expressing aspects of systems. The abstraction varies by domain area and phase of creation and deployment, adopting the conceptual models of particular roles rather than some amorphous concept of a generic citizen.
Software development tools must address their target audience in a language that they understand, preferably using familiar terms and visuals, to make expressing intent easier. This can vary from complex computer-science approaches to simply using vocabulary and graphics that correspond to the target area, including customizing CRM and ticketing systems, or more general business processes.
Mendix is an example of this second category, with a platform that is focused on being intuitive for the business user.
Having said this, their strong focus on business appears to have come at the expense of technological capabilities that are crucial for the delivery of scalable, integrated, enterprise applications. The type that you could enable with more IT focused and tech centric offerings.
Roles and Responsibilities
IT projects can be categorized in many ways, but a key aspect is that scale and importance are not always synonymous. Some very small applications can make a huge business impact, but traditional management structures and budgets tend to favor large, expensive projects. This means that very often the small-but-critical apps end up being built badly and insecurely through necessity using whatever tools are available to those with the need, often spreadsheets.
This is the classic definition of shadow IT and does genuinely bring risk to the business, especially when use of the resulting apps grows beyond expectations to become a business-critical component. A much better approach is for IT to provide a means where business people can create their own apps safely, whether small, medium or large.
Such a platform encapsulates all the IT concerns of reliability, scalability, security, compliance and performance, leaving the organization free to build what it needs, when it is needed, and easily change as often as required.
This separation of responsibilities can be broken down further, allowing different ways of expressing different tasks. The most common custom business application is for workflow, tracking and managing a task from inception to completion. From the point of view of a business analyst a workflow specification will typically be broken down into the following parts:
- Process flow
- Business rules
- Data captured
- External Actions
None of this would be useful without a user interface, API links to other systems, mechanisms for testing that the process works as intended, places to store and protect the data, as well as to ensure reliability and scalability. Different people will be responsible for all these aspects, within an overall low-code platform.
A truly democratic low-code enterprise platform will operate as described above, prioritizing the needs of the domain experts, but supporting other types of users too.
Each stage will have its own capabilities and users that together deliver complete apps, whether large or small, easily and quickly without the need for recourse to IT schedules and dependencies.
Enter the Trust Economy
One of the major advantages of separating out the elements of any kind of system is the ease with which parts can be replaced. A traditional hammer, for example, can have the head and the handle replaced independently as required.
Classic, monolithic IT systems do not have that luxury, as components have been built to lock together making changes slow and potentially dangerous: integrating new technologies is difficult and expensive.
Separating out specification and implementation with high-level abstractions means that democratized systems can more readily adopt new technologies such as blockchain. Since the data model has been specified by a business analyst without recourse to how it is implemented, it is essentially “blockchain ready” as the tooling can take care of the details.
Further, because we can tell logically how the elements interact from the explicit process model, we can start to deploy smart contracts where they are needed.
As mentioned above, most business is now conducted between networks of companies, forming data supply chains to support the physical supply chains. Often these data supply chains must operate in untrusted or partially trusted environments and this is currently the best application of blockchain.
We can all this the trust economy, where trust is scarce and valuable but the blockchain technology ensures that transaction records are immutable and smart contracts ensure that those transactions only occur when the required criteria are met.
Adapting a system that was not originally intended to support blockchain to use distributed ledger is extremely difficult. Finding the developers with the required skills to make it work is also hugely complex.
Both challenges vanish when the technical aspects of implementation are abstracted away by the platform, enabling adoption with a minimum of effort.
Blockchain is beneficial where a workflow process spans multiple suppliers operating together, forming a trusted data supply chain. Where an organization is using a blockchain capable low-code platform, all they need to join the supply chain is to switch from blockchain ready to blockchain enabled.
Instead of storing transaction records in a conventional database the platform will now record them a blockchain, gated by the specified smart contract constraints. No new programming or development required.
Encapsulating blockchain execution within a platform that makes it easier and faster to enter the growing trust economy. Sticking to the traditional IT approach will delay blockchain adoption for years, by which time your opportunity will have been grabbed by other, more nimble organizations.
Technical Agility Enables Business Innovation
A modern business seeks agility without compromising its need for security and performance. The required techniques and methods exist to achieve this, but traditional IT approaches cannot readily adopt them, and our approach to delivery of software systems must change.
What is needed is an enterprise low-code platform that supports different views of a problem, enabling multidisciplinary delivery of software, and is built using modern software techniques and cloud-native architecture. Such a platform enables apps to be described in terms of business outcomes, and since it is built using modern software techniques, it enables those apps to scale and be naturally resilient, as well as being deeply integrated into existing systems.
An open, event driven system allows a business process expert to define a blockchain-based system that exposes APIs to IoT devices that can record a transaction without the need for technical skills.
In a crowded market one platform stands out as checking all these boxes: Aurachain. Significant thought has been put into how real-world enterprise applications are specified, identifying the key roles in that process and how best each can express their intent. Visual tools were then developed to provide familiar environments to capture the intents, without the reference to implementation.
The result is not so much a form of programming; it is effectively an executable specification. The engine that does this execution is also brand new, making the most of modern architecture: cloud native, elastic, secure and integration ready.
Push-button deployment steps safely through test, staging and fully scalable production without the need for IT intervention.
While alternative tools are designed to enable either point solutions or grand designs, they follow an IT focused agenda. It is its focus on intent that makes Aurachain the ideal mechanism for business transformation.
Despite digital transformation being front and center of most executive strategies, many businesses fail to make the cultural shift required to truly embrace digital. Aurachain makes this significantly easier by removing the technical impediments without breaking compliance requirements, making adoption of new, digital processes simpler and surer.
Since the platform makes it quick and easy to build and test new apps it also enables digital experimentation, providing a testing ground and validation of transformational concepts without big investment. Even without the ability to create blockchain applications, Aurachain merits inclusion on your evaluation list if you are looking to enable digital transformation through low code. Add in blockchain and it becomes the clear leader.