Skip to main content
Lemline - Event-Driven Workflow Orchestration

​
What is Lemline?

Lemline is a modern runtime for the Serverless Workflow DSL version 1.0, enabling the execution of complex workflows defined in YAML or JSON on top of your existing infrastructure. It leverages modern best practices for performance, reliability, and extensibility.
Lemline runs on top of your existing infrastructure. All you need to deploy are stateless Lemline Runners that connect to your event broker and your database.

​
Key Features

Serverless Workflow DSL

Faithfully implements the Serverless Workflow specification for defining and running workflows with YAML or JSON

Event-Driven Orchestration

State transitions are carried within broker messages, minimizing database load and improving throughput

Stateless Workers

Horizontal scaling is as simple as starting more Lemline workers. No sticky sessions, no shared state

Native Binary Support

Deploy as a lean, self-contained binary built with GraalVM/Mandrel. Startup in milliseconds with reduced memory footprint

Resilient Error Management

Automatic retries, failure tracking, and clear separation between infrastructure and business logic errors

Built-in Observability

Micrometer integration with Prometheus-compatible metrics, health checks, and lifecycle events

​
Why Lemline?

Lemline is designed to be an extremely fast and efficient workflow orchestrator. It uses an event-driven approach, primarily communicating via messages rather than constantly reading from and writing to a database. This allows Lemline to orchestrate business processes that would typically be implemented through choreography (peer-to-peer communication between services) without needing a database for every interaction.

​
Performance-First Design

1

Workflow state compressed in messages

The workflow’s current state is compressed and included within event messages, eliminating constant database reads
2

Database used strategically

The database is only used when strictly necessary: time delays, retrying failed tasks, or waiting for parallel tasks to complete
3

Stateless workers scale horizontally

Any worker can process any message, enabling linear scaling without coordination overhead

​
Architecture Overview

Lemline runs on top of your existing infrastructure with three main components:
  • Event Broker (Kafka, RabbitMQ, PGMQ) - Transports workflow state through messages
  • Database (PostgreSQL, MySQL) - Used only when strictly necessary: timers, retries, and checkpoints
  • Stateless Lemline Runners - Orchestrate workflows, make calls to your services, and scale horizontally

​
Quick Example

Here’s a simple workflow that sets a greeting message and logs it: 
document:
  dsl: '1.0.0'
  namespace: tutorial
  name: hello-workflow
  version: '0.1.0'
do:
  - setGreeting:
      set:
        message: Hello, Lemline!
  - logMessage:
      call: https://raw.githubusercontent.com/serverlessworkflow/catalog/main/functions/log/1.0.0/function.yaml
      with:
        message: ${ .message }
Workflows are defined using the standard Serverless Workflow DSL, making them portable across different runtimes.

​
Supported Infrastructure

Databases

  • PostgreSQL
  • MySQL
  • H2 (for testing)

Message Brokers

  • Kafka
  • RabbitMQ
  • PGMQ (PostgreSQL-based)

​
Next Steps

Quick Start

Get up and running with your first workflow in minutes

Installation

Learn about different installation methods and deployment options

Architecture

Dive deep into Lemline’s event-driven architecture

Workflow DSL

Understand the Serverless Workflow DSL and task types

​
License

Lemline is licensed under the Business Source License 1.1.

Build docs developers (and LLMs) love

Get started for freeTalk to us