THREE WAYS

THREE WAYS LOW-CODE NO-CODE CAN INCREASE ROI

Dan Matthews, Chief Technology Officer at IFS discusses the key to enabling successful lowcode no-code environments and how the vendor is working on a more intuitive no-code way

Low-code or no-code is something enterprise software companies have been moving towards for obvious reasons—the chief one being that it empowers customers to quickly do more with their software. TechTarget defines a low-code, no-code development platforms as “a visual software development environment that allows citizen developers to drag and drop application components, connect them together and create a mobile or web app.” This is the effect of democratizing software development so a business analyst or line manager can structure new process flows and functionality without the external expense or time drag of involving a team of developers or programmers.

It is no wonder that IDC Analysts Joe Pucciarelli and Serge Findling predict that by 2025, 60 percent of CIOs will implement governance for low/no-code tools to increase IT and business productivity. Gartner predicts that over 65 percent of all application development will take place in low-code, no-code environments by 2024.

Part of the plan

IFS has prioritized openness and configurability throughout our history, but with our coming release and to a certain extent in IFS Applications 10, we see an immediate future where a company can drive more value more quickly with enterprise software than ever before. I think we will see three ways for an executive team to achieve this type of return.

Behind each of these three routes to higher return on investment (ROI), we see that successful low-code no-code environments do not just happen. The ability to provide simple and graphical ways to draw relationships between systems and transactions and events is dependent on underlying software that is good at working and playing well with other systems. Some vendors will talk about how they have open application programming interfaces (APIs), but these are often few and designed for specific, pre-determined integration scenarios. The application in the meantime internally communicates (for example between the user interface and the business logic) in a proprietary fashion that cannot be leveraged by external systems.

To maximize the agility delivered by lowcode, no-code tools, the entire application should be built on open APIs, and those APIs should be used internally by the application as well. As for the exact technology to use--that varies over time. A decade ago, it would have been web services technology, but today the most appropriate is use of RESTful APIs—based on the REpresentational State Transfer architecture. Enterprise applications can go a step further by relying on the ISO/ICE-approved OASIS OData (Open Data Protocol), making things even more interoperable. When the application is built on the same set of RESTful APIs it exposes to other systems, it is a lot easier to access the precise spot in a value flow with which you need to integrate.

1. Faster external integrations

A robust architecture built on RESTful OData APIs, documented according to the Open API Initiative specifications, gives customers the ability to use a low-code solution to extend enterprise software on the outside to create task specific apps or connect to other systems.

This may be used for something as simple as automating steps to take around a new hire. Creating a new employee number may, for instance, fill in a desk number for new employee in an office floor plan, initiate payroll activities in a human resources creating an account in Outlook and ordering flowers from the local florist and having them delivered to the desk on an employee’s first day. It may also populate in a serialized part structure from a machinery manufacturing process into the software that will be used to manage service of that piece of equipment under an annual maintenance contract. Any data, action or event in an enterprise software system should be accessible in a clear and thorough API library.

With enough of these RESTful APIs, any number of low-code, no-code tools can be used to create targeted apps that interact with IFS software and other systems running in a business. Commercial software offerings including Microsoft Power Apps and offerings from Snaplogic, Mendix and Outsystems can be used to build an experience and drive processes in enterprise software using APIs.

We have already ensured that in IFS software, anything you can do internally to the software you can also access and automate using external tools. This will become more and more important as our customers who may be using these external low-code, no-code platforms want to use them to orchestrate processes across multiple applications, including those from IFS.

2. Low-code, no-code approaches to configuring and automating internal to the software

Low-code, no-code tools are also more commonly used to tailor how IFS software works internal to itself, giving customers more control over their software. Already we offer the ability to extend the data model, tailor the user interface and user navigation flow through a process using no-code tooling IFS Page designer, which also enables customers to create net new fields and screens.

While there have long been ways to do this in IFS Applications, what we are working on now is a more intuitive nocode way that will not only automate process steps or user actions but add machine learning capabilities for intelligent process automation (IPA). Our coming release democratizes creation of intelligent systems by putting it within reach of business analysts, line managers and through a simple what-you-see-is-what-you-get (WYSIWYG) interface. Combined with the library of RESTful APIs, this visual editor will present endless possibilities for IPA that will automate processes.

As an example, imagine that for products of a certain category you want to send an installation technician, with the right skills, arriving at exactly the right time, to your customer site to help them get set up with using your product. Because the IPA capability is embedded in our software it can capture any additional input needed from users as part of the existing business transactions, rather than relying on users to find and perform tasks in other systems. As we add in the intelligent parts, we’ll see AI and Machine Learning models being used to make choices inside the automation about what to do next (branching decisions), or predicting values to be filled in. Further down the line, we will see automated continuous improvement of processes as machine learning recommends or even proactively makes process changes to improve outcomes.

3. Built from the ground up with lowcode, no-code

IFS has already executed on a plan is to make low-code, no-code easy by re-architecting our products on RESTful APIs so external and internal systems can automate process, access any data, and create extensions to our software on the outside. Regardless of whether a customer is using our internal IPA tools or external low-code, no-code process orchestration software, IFS software offers transparent access to precisely the right part of the system to support a given integration or process automation.

IFS is also using a low-code, no-code approach to developing new functionality, so that we can build new solution and industry specific functionality faster, cheaper and with higher quality. To this end we have adopted a low-code Domain-Specific Language (DSL) to produce our standard solution. Not only does this low-code approach help us create value faster, it also helps to insulate us from technology changes in the future.

Moving away from a technology used in our middle-tier, for instance, goes faster and easier because the DSL describes the intent of what something in the application (for example an API) should do, rather than how it is technically done. Or the fact that we are able to use the same DSL definition of pages in our user interface to provide across web browsers as well as in the form of native apps on Android, iOS and Windows.

Combined, this means we can make changes with less disruption, evolve the software faster and get it into customer hands so they can begin to realize value. And we will naturally think more about how our enterprise software looks not only through the user interface, but to those who are accessing it through RESTful APIs from other systems and platforms.

IFS software is already far down a path to low-code and no-code—one that we’re set to continue on for years to come as well.

Dan Matthews

Chief Technology Officer, IFS