Building low-code libraries

First you have to decide what scope you want to start with. You may start with a simple stand alone function or your implementation may be part of a large project.

No matter which, we believe it is worth the effort to start thinking about which modules can be reusable and which are most likely unique to the project.

If you start small scale you may just have 2 libraries. One with project specific plugins and one with plugins with some common functionality. For larger projects you may have a number of common libraries.

We believe it is often the case that you start small but quite soon realise you want to have more functionality. It does not take long before the solutions grows and becomes more complicated. Therefore our advice is to plan for the possibly of growing libraries right from the start. It pays to start working in a orderly fashion.

1: Decide what needs to be done

The next step is to understand what you need to do. One way is to write down the different use cases or data flows that need to be implemented. Find out what use cases there are and what actors participate.

2: Define modules or plugins to be used

When you know what needs to be done it is time to brake down the use cases into modules or plugins. What modules do you need?

Modules should have a specific functionality and not be doing many things at once. A module may be complex but it should do a single thing. For instance a connection to some proprietary system may be quite complex but it still just have this single function.

It is better to group a number of plugins to a "sub-flow" that can be reused by other flows then to implement the entire flow in one single module.

3: Build modules you don't have

In case you need to build some custom made plugins you specify what they are. Define their interfaces specifying things like what configuration parameters are required to modify the plugin behaviour.

Now you have a specification that you can send to developers.

Our recommendation is to write automatic tests for the plugins. This allows each plugin to have its own set of tests which can be run every time the library or libraries used by the library are modified. Running automated tests on plugins is great since it allows you to have full confidence in the plugin library.

4: Build your solution

Now you have all the plugins you need to start building and configuring your solution. One thing to consider is the possibility to quickly build a mock-up of plugins just returning som kind of "correct" data. This allows you to quickly get a mock-up solution running while the plugins are still being implemented. When speed is important this is great. This will allow UI (user interface) developers and designers to configure or build the user interface part before the backend solution is fully implemented.

Note that you can start small with just a simple flow and a few modules. Soon you will come up with another flow you want to build. You can build and verify your installation step by step, flow by flow.

Where to go for more information?

We have provided some examples of possible implementations and use cases in How it works.