Kubernetes-native workflow engine for building data pipelines, API servers, and automations.

Design flows visually. Deploy as Kubernetes operators. Scale with your cluster.

Each flow is a graph of connected nodes. Each node is an instance of a component — a small, focused piece of logic (HTTP server, router, Slack sender, K8s deployment scaler, etc.). Components are packaged into modules that run as Kubernetes operators.

HTTP Request → Router → Slack Notify
                     → Scale Deployment

• Nodes within the same module communicate via Go channels (zero serialization)
• Nodes across modules communicate via gRPC (automatic discovery)
• State lives in CRDs — no external database required in your cluster
• Blocking I/O — responses flow back through the same call chain

1. Use the platform — tinysystems.io provides a visual editor, module directory, and cluster management
2. Use the desktop client — open-source Wails app that connects directly to your cluster
3. Build your own module — install the SDK and implement the Component interface:

func (c *MyComponent) Handle(ctx context.Context, output module.Handler, port string, msg any) any {
    req := msg.(Request)
    result := process(req)
    return output(ctx, "response", Response{Context: req.Context, Data: result})
}

helm repo add tinysystems https://tiny-systems.github.io/module/
helm install my-module tinysystems/tinysystems-operator \
  --set controllerManager.manager.image.repository=myregistry/my-module

• Flow-based programming — each node does one thing well (Unix philosophy)
• Blocking I/O — HTTP server blocks until response flows back through the graph
• No central database — all runtime state in Kubernetes CRDs
• Modules are operators — standard Kubernetes deployment, scaling, and RBAC
• Expressions, not code — data mapping between nodes uses {{$.field}} JSONPath syntax
• Leader-reader pattern — horizontal scaling with leader election for stateful operations

• Documentation
• Platform