TinySystemsDocumentation

Kubernetes-native, flow-based application development platform

Flow-Based Development

Build applications visually by connecting reusable components. Design complex workflows without writing boilerplate code.

Learn more

☸️

Kubernetes Native

Components run as Kubernetes resources with automatic scaling, service discovery, and state management built-in.

Architecture

🔧

Build Custom Modules

Create your own components using the Go SDK. Define ports, handle messages, and publish to your team.

Create a component

📊

Scalable by Design

Leader-reader pattern and CR-based state propagation enable horizontal scaling across replicas.

Scaling guide

🔌

Rich Module Ecosystem

HTTP servers, database connectors, message queues, and more. Install modules or build your own.

Browse modules

🛡️

Enterprise Ready

Self-hosted on your infrastructure. Secure secrets management, RBAC, and full control over your data.

Requirements

For Users

Build automation flows using the visual editor.

Creating Your First Flow - Step-by-step guide
Understanding the Editor - UI walkthrough
Expression Syntax - Data transformation
Available Modules - Component catalog

For Developers

Create custom modules and components.

Prerequisites - Setup your environment
Hello World Component - Build your first component
Component Patterns - Best practices
Publishing Modules - Deploy your modules

Reference

Complete API and configuration reference.

Kubernetes API - CRD specifications
Component Interface - SDK interface
Struct Tags - Schema generation
System Ports - Built-in ports

Examples

Learn from complete working examples.

Simple Transformer - Data transformation
HTTP Server - Web endpoints
Webhook to Slack - Complete flow example
API Integration - Multi-service orchestration

Core Concepts

+-------------------------------------------------------------------+
|                        TinySystems Platform                       |
|                                                                   |
|   +----------+    +----------+    +----------+    +----------+    |
|   |  Module  |    |  Module  |    |  Module  |    |  Module  |    |
|   |  (HTTP)  |<-->| (Common) |<-->|(Database)|<-->| (Custom) |    |
|   +----------+    +----------+    +----------+    +----------+    |
|        |               |               |               |          |
|        +---------------+---------------+---------------+          |
|                                |                                  |
|                      +---------+---------+                        |
|                      |    Kubernetes     |                        |
|                      |    Controller     |                        |
|                      +---------+---------+                        |
|                                |                                  |
|    +-------------+    +---------------+    +-------------+        |
|    |  TinyNode   |    |  TinyModule   |    |  TinySignal |        |
|    |    CRDs     |    |     CRDs      |    |    CRDs     |        |
|    +-------------+    +---------------+    +-------------+        |
+-------------------------------------------------------------------+

Components are reusable building blocks with defined inputs and outputs.

Modules package related components into deployable Helm charts.

Flows connect components visually to define data processing logic.

TinyNodes are Kubernetes resources representing component instances.

Getting Help

FAQ - Common questions and answers
Glossary - Term definitions
GitHub Issues - Report bugs

TinySystemsDocumentation

Flow-Based Development

Kubernetes Native

Build Custom Modules

Scalable by Design

Rich Module Ecosystem

Enterprise Ready

Quick Navigation ​

For Users ​

For Developers ​

Reference ​

Examples ​

Core Concepts ​