Want to “just have a quick look” whether it is possible to prevent the system from accepting express orders before public holidays that can no longer be delivered? This (or something similar) is certainly the wish of many project managers. Normally, there is no such thing as “just a quick test”: especially with the complex software solutions used in logistics, it is not entirely trivial to add new rules and functions at short notice. To make matters more difficult, processes in logistics are often highly individual. The desired change must therefore be described in detail and passed on to the software service provider. It takes time for the code to be written, the new requirement to be integrated into the tool and tested. The situation is different when working with low code within the software. Read on to find out how this works without any development or programming knowledge.
The EIKONA Enterprise Platform uses Blockly to flexibly map logistics processes using low code. Its major advantage is that it can process a large number of events in a very short time, enabling data and information from a wide variety of sources to be efficiently linked together. This makes it ideal for complex supply chains where numerous processes run in parallel. Citizen developers can thus directly implement, test and adapt rules and processes without compromising the performance of the platform. With EIKONA, low code in logistics becomes a powerful tool for speed, transparency and flexibility.
Customising software and adding rules without any software development – it's possible! This is possible thanks to low code and no code technologies. What are the differences between them? The name says it all: no code involves no programming whatsoever, whereas low code requires a basic technical understanding, as certain scripts or commands are used.
Low code differs from agile software development. The latter is also about being able to react quickly to changes and developing software updates in short sprints. However, the low-code approach does not require any software development at all.
Many low-code editors are based on a specific technology: Blockly. This is free, open-source software from Google that anyone can use. Developers can use it to add a visual, block-based (as the name suggests) code editor to their applications. The puzzle-like blocks, which can be interlocked, are moved around on the straightforward user interface using drag and drop, programming logical expressions, loops and the like. The visual approach – in contrast to written code, which is otherwise used – ensures that users do not have to worry about the complex syntax of code. It is possible to incorporate user-defined blocks into the low-code editors so that they best suit the requirements of the respective company.
How can you imagine such a low-code environment? Perhaps thinking about Lego bricks will help. Just like when playing with the popular interlocking bricks, low code involves placing one block on top of another. The blocks cover different categories: for example, there are logic blocks that can be used to implement commands such as “if ...” or “do ...”, data fields in which things like “order value” or “tax amount” are entered, rules, arithmetic blocks and text fields for displaying a message (also in different languages).
Once a rule has been created, it can easily be copied for another use case. This is extremely helpful, for example, when the same processes are to be triggered for different network partners, but the numerical values differ slightly. Simply copy the rule into the new case, adjust the individual fields, and you’re done.
You can practise using low code on websites such as code.org. There, interested parties of all ages can learn basic programming skills – for example, in an Angry Birds game in which the bird has to be brought to the piggy with the help of code building blocks. Basic principles such as “repeat movement XY three times” instead of inserting the same arrow several times in a row can be learned quickly there.
“Citizen developer” is the technical term for people who have no IT training but who, as end users, work in development environments. As software developers who develop low code platforms say, “You do need a basic understanding of programming to work with the rule blocks.” So if you are interested in logical questions, have a clear idea of how to skilfully get from problem A to desired result B, and are not afraid of trial and error processes, then low code is right for you.
Low code environments are often entrusted to project managers who are very familiar with the many processes along the supply chain and employees with an interest in IT. No one needs to be afraid of breaking anything: when setting up the visual editor, software service providers deliberately set certain “guard rails” and limits to ensure that no damage can be done to the actual tool in the low code environment.
Whenever something happens (or doesn’t happen) along the supply chain, it is an event that requires a specific response. Whether a shipment is delayed (i.e. nothing happens), a new order comes in, a request is sent or a delivery attempt fails: all of these events trigger further actions, which in the best case scenario are automated.
Let's take order entry as an example. If all the necessary data is requested, errors are flagged and special conditions are taken into account during the order entry process, this saves a lot of time and hassle later on. If, for example, a public holiday is coming up, it is important to specify in the booking system that, from a certain point in time, collections can no longer be booked for the same day. Incorrect numbers and other errors can also be easily avoided with low-code rules. For example, users could create a rule stating that the value of goods must not exceed £100,000, because insurance issues then arise. The system will now refuse to accept bookings where there is perhaps one too many zeros in the value of goods.
The big advantage is that all these rules can be tested ‘on the fly’, in our case with a trial booking for a shipment worth £1,000,000. If it turns out that a rule does not yet work as planned or is no longer needed, the blocks can simply be deleted. Low-code environments therefore play a major role in the digitalisation of the supply chain, as they give users control and flexibility in their daily use of their own applications – without any programming knowledge.
You might think, “Do we even need software service providers if IT-savvy people in the company can build in rules and additional functions themselves?” The clear answer is “Yes!”. In order to work within the low-code platform, the right integration is crucial for application development. Without context and a suitable starting point, citizen developers would not know where to begin or how to best implement the requirements.
The task of a software service provider is therefore to deliver the appropriate framework and build all the necessary interfaces. Let’s take a simple example: when an express shipment is entered into the order management system, a specific group of people should be informed of the urgent order directly via Teams message. However, in order for the low code user to be able to create such a rule, the appropriate building blocks are important. The software service provider must therefore have created the block “Send a Teams message to ...” in advance and linked the logistics software to Teams so that the function can be used in the low code environment.
It is also important to find the right correlations: emails must be assigned to the corresponding shipments, data must be extracted and matched with the order, and so on. Because one thing applies here too: knowledge is power. If all the data for a shipment is available, the rules created around it can ultimately trigger much more complex and comprehensive actions. It is worth relying on a software provider that specialises in the logistics industry and always knows the right context.
Software developers know that documentation plays an important role in programming. When changes are made to the code, it is important to comment on why this or that decision was made. Otherwise, chaos will quickly ensue when the programme is revisited months later, perhaps even by other people.
The same applies to low-code users: anyone who can make changes to the software (always within the guidelines set during development, of course) must also handle it responsibly and document which rules were incorporated and for what reason. This allows different people from different areas to work together conveniently within the platform. Software service providers therefore have the task of handing over the low-code environment in a meaningful way and helping users understand the complexity of the tool.
Of course, low code editors are not suitable for all requirements. Thanks to the puzzle-like blocks, minor adjustments and rules can be implemented quickly and flexibly without the need for anyone from application development being involved. However, when it comes to highly complex requirements, it is always better to use handwritten code from the developer, as this is usually more efficient. Large software platforms process 250 events per second at peak times. Whether the response takes a millisecond longer or less makes a big difference to the platform’s performance.
At a glance: the advantages of low code
Digital transformation is a major topic in logistics. The desire for automation and acceleration of processes is not new – whereas in the past there were tools such as decision tables that were used in task management, for example, today many are calling for an AI solution. “Develop logistics software quickly” is a common search query. The solution: low code! Once the appropriate framework is in place, non-IT specialists can use the visual editor to quickly and flexibly adapt their logistics software to the needs of their company.
This benefits all sides: companies save money and can act more spontaneously because they implement small software requirements themselves. Software service providers, in turn, take care of creating reliable and high-performance connections that perfectly embed the low-code environment into the rest of the software. Development resources are thus used in the best possible way – a win-win situation for everyone involved. Sounds like a good thing!
