Let’s talk about sustainable software
For too long, enterprise software applications have been treated as disposable products. Considering the consequences of this mentality, it is clearly time for a radical change towards more sustainable software.
A software application is much more just than some thousand lines of code running on a computer. In the modern enterprise, functioning software is the foundation of efficient operations, and sometimes the basis of the entire business model. Further, many employees spend their entire day in front of a computer, solving their tasks through different types of business software. And even employees who don’t have typical desk-jobs are expected to master a variety of software with varying user interfaces.
What I am saying here is that, for better or worse, both companies and their employees depend on and are affected by the software that is used in their organization.
The ever-changing organization
The main problem with this tight relationship between traditional software and the enterprise itself is the differences in speed of change. Just as in the theory of biological evolution, the business world is shaped by companies’ ability to evolve and adapt to change.
There may be a new competitor that you need to fight off by offering new services or cut your prices. There may be challenges with your suppliers, forcing you to vertically integrate your supply chain. Or there may be requirements to cut spending and automate entire business processes. While these are business decisions, they also affect the software in your company that is supposed to support your employees, business processes and operations.
The traditional response
Software, the modern medicine for business productivity, works great in times of stability. However, facing rapid change, software itself can become a restraint for corporate ambitions. The reason is that the two traditional ways of software delivery, off-the-shelf and custom-coded, are built based on the premise that software applications will remain immutable for a certain period of time.
Some software applications are expected to live for as much as 10-15 years, whereas others have an expected lifespan of just a few years. Further, the initial investments in these systems often reflect their expected lifespan, meaning that the biggest investments go toward the longest-living, whereas the short-living applications are often based on simple, generic, or rudimentary technology. This also means that some systems need to live longer to provide the expected return on investment (ROI) that was promised.
Once put into production, software applications meet the ever-changing organization. The applications you expected would live for several more years suddenly become outdated prematurely. The most common response to this is unfortunately to reboot and make the same choices all over again. After all, the previous software applications were most likely procured by the long-gone previous managers, and this time we definitely know more about how the future will look like. Right?
The response is thus to gather requirements once again, describing what kind of functionality the new solution must have. Then you must evaluate whether to buy or build, source suppliers for this kind of software solutions, evaluate the most promising solutions and suppliers, secure funding of the project, hire project managers and implementation teams, and ultimately wait for the delivery of a brand new application that is expected to live for several more years. After all, this process is inevitable since the “business people” have decided on making changes that were not expected in the requirement specification a few years back.
The consequences of disposable software
Swapping entire software solutions represents a radical change to meet the organizational changes that are often incremental or evolutionary. From the first day a software solution is put into production, the organization will continue to evolve, implementing several changes with varying impact on the software. Sometimes, there are smaller adjustments to business processes. Other times, there are ground-breaking, major revitalizations. The static software supporting your organization becomes less and less useful, until the day when there is no way back and you must dispose the current software and start over.
So, how does it affect the business when you replace the software that the organization and its people depend on with something new?
The human perspective
The people in your organization depend on these software solutions. They have often used a lot of time to learn all the functionality, features, workarounds and bugs of the existing software. Some of them may even be super-users, training others on how to utilize the software for maximum productivity.
When you introduce new solutions with new user interfaces and functionality, the people in your organization must be rebooted and trained once again. This will require both time and money, and it will take time to reach a satisfying level of productivity. In addition, they will most likely find that after some time – even the new solution no longer fits how they work! If you repeat this enough times, disposable software will affect the motivation of your employees.
The financial perspective
Changing the entire software application will also put a dent in your wallet. As described, the process of specifying and sourcing new software is both costly and takes time. In addition, there are costs associated with developing or implementing the new software and costs of training. In addition comes the (more hidden) future costs of yet a new software that is not adapting to changing business realities.
The technological perspective
Changing technologies, especially when it comes to core systems, is associated with high risks. This is also why the process of sourcing and evaluation takes time. However, there are almost always risks that will not be found during this initial evaluation process, and rapid changes of technology means that new risks are introduced more often.
You will also find that you must customize the software, even though it is “off-the-shelf”. This customization itself will most likely mean that you cannot easily upgrade the software a few years down the line. Further, these software solutions are not isolated, and the costs and risks associated with integrating them with the rest of your IT architecture are often underestimated.
These are just a few of the consequences, to give you an idea of why this is important.
Let’s talk about sustainable software
So let’s talk about a sustainable alternative to this “disposable software” mentality.
What is sustainable software?
When we say sustainable software, we mean software that is built to absorb change over a long period of time. Since change is inevitable, we believe that no business-critical software should be built with expectations of a stable, immutable organization. The software used by the organization should at all times, as far as possible, reflect the people, organizational design, processes, and strategies of that specific organization – all of which will change!
The ideal model for sustainable software is actually quite simple: The underlying technology and the business functionality must be separated from each other in the software solution! The way to achieve this is to describe the business functionality (data model, logic, user interface, and integration) as metadata, and then let the technology interpret this metadata at runtime.
The concept behind sustainable software is well-known
This model of separation between functionality and technology is well known from several products. For instance, spreadsheet software (e.g. Excel) use it to separate the individual spreadsheet models from underlying software. Content Management Systems (CMS) use it to separate the content of web pages from underlying software. It would be unsustainable to require a new version of the spreadsheet software to add a function to your calculations, or a new installation of the CMS software to add or modify a new webpage. The same way, core business applications can be made sustainable by separating the description of the application from the underlying (hard coded) technology.
Metadata-interpreting low-code for sustainable enterprise applications
Low-code platforms have been on the market for a while now, and metadata-interpreting low-code platforms (like Genus) are attacking this exact challenge of sustainable software! We built Genus to enable businesses to build sustainable core software applications that can be changed and modified without the need for new versions of our platform. Whether it is a change in business logic, user interfaces, data model, or integrations – all this can be modified by visually altering the metadata without the need for traditional programming!
As a bonus, the underlying technical platform is updated regularly and independent of the metadata. This means that security patches, new building blocks for metadata, and upgrades to support other technologies can be added without affecting the application you have built and changed over the years. In fact, we have customers today who started with their low-code applications back in 1996 – and who have continued to modify their metadata to reflect the changes in their organization. As a result, they always have a completely customized solution that is both technologically up-to-date and directly reflects their organization.
This is what we call sustainable software, and this is why we go to work every day: to help the adaptive organization through better software.