Welcome to Lolo!

Lolo means lo(w) lo(w) code as our aim is to make every data stream, API and network programmable with an awesome developer, deployment and operations experience.

Lolo is an Integration Function as a Service (iFaaS) platform that allows you to build visual cloud agnostic serverless applications and reusable functions in a NodeJS environment with one-click multi-cloud deploy. The platform also allows you to deploy Programmable Virtual Private Cloud (VPC) that can create networks which span cloud providers, data centers, on premise infrastructure, devices (laptop/computers/servers) and IoT devices.

Lolo's iFaaS integrated development environment (IDE) consists of Applications, Functions and Runtimes. An Application consists of Functions which are then deployed onto a Runtime.

The workflow is inherently more visual than other serverless platforms, which is good for beginners and experienced coders alike. To illustrate, see what a CRUD API created by Lolo could look like in the IDE below.

Applications

Lolo Applications are a directed graph of functions which are triggered by an event. An event may be a timer, HTTP call or similar. All of the functions in a Lolo Application have access to a shared state which can be used through the entire application in order to keep functions small, focused, performant and maintainable.

Applications (and Functions) may use Node.js packaged from npmjs.com. Applications may be manually and auto-documented through the Application Settings tab in the IDE.

More information about Applications can be found in the Applications and Functions pages.

Functions

A Function in Lolo is either in the form of inline code written in an Application or Function, or in the form of an independent Library Function. Lolo supports (and encourages) the notion of function composition whereby a number of Functions are composed together into a single function referred to as a Composite Function.

Library Functions are made either by using the 'New function' button on the Functions page, or by exporting an inline code Function or Composite Function to the Function Library from an existing Application or Function, using the 'Export' button in the graph editor. Once created/exported, a JSON Schema should be created for the Library Function such that it can be more easily reused and visualized within the IDE. Moreover, when a schema is applied to a Library Function, it can be used by No Code Visual Builder style applications for uses cases such as building Conversational / Chatbot Platforms, Automation Platforms or Integration Platform as a Service (iPaaS).

Each Function may have any number of input and output ports and control of the ports is done through the context variables within the function event handlers.

More information about Functions can be found in the Applications and Functions pages, but an example the function event handlers is as follows:

// Example of using the shared state to count events
exports.handler = async(ev, ctx) => {
  // ev - JSON event
  // ctx - context which contains:
  //     route in order to determine the output port;
  //     shared state and;
  //     log,
  const { route, state, log } = ctx;

  let count = state.get('count') || 0;
  count++;
  state.set('count', count);

  route(ev);
};

Deploying Applications

Lolo applications are deployed onto a Kubernetes runtime in your preferred cloud provider such as Amazon Web Service, Google Cloud Platform and Microsoft Azure. Applications deployed via one-click from the Lolo IDE (or programmability via the Lolo API).

As Applications are running in your cloud provider, logs and telemetry information are transmitted back to the Lolo platform and accessible via the Lolo IDE.

Configuring Runtimes

A Runtime is a Supported Kubernetes cluster as set out in the Runtimes documentation.