Introducing Tiny Systems: Visual Kubernetes Automation
Build data pipelines, API servers, and automations by connecting components visually. No YAML, no custom controllers — just flows that run as Kubernetes operators.
We've been building Tiny Systems for the past two years. Today we're ready to share it.
The problem
Kubernetes is powerful, but building automations on it still means writing controllers, managing CRDs, and wiring up event handlers in Go. For every "when pod crashes, send Slack alert" you end up with a custom operator, a Docker image, and YAML you'll forget about in a month.
We wanted something different: a way to compose Kubernetes automations visually, the same way you'd wire up a circuit.
What Tiny Systems does
Tiny Systems is a flow-based programming engine that runs natively on Kubernetes. You design workflows by connecting nodes — small, focused components like HTTP Server, Router, Slack Sender, Pod Watcher — and the engine handles execution, scaling, and fault tolerance.
Each node maps to a TinyNode CRD. Nodes within the same module communicate via Go channels (zero serialization overhead). Nodes across modules talk over gRPC with automatic discovery. All state lives in CRDs — no external database required.
Key design decisions
Blocking I/O by default. When an HTTP Server sends a request downstream, it blocks until the response flows back through the graph. This gives you natural backpressure, error propagation, and transaction-like semantics without any extra code.
Modules are operators. Each module (HTTP, Kubernetes, Slack, etc.) deploys as a standard Kubernetes operator via Helm. You get native scaling, RBAC, and lifecycle management for free.
Expressions, not code. Data mapping between nodes uses {{$.field}} JSONPath syntax. No lambda functions, no embedded scripts — just declarative transformations.
No central database. Runtime state is stored in Kubernetes CRDs. Your cluster is the database. This means zero additional infrastructure and natural disaster recovery through etcd.
What you can build
- API servers with routing, authentication, and response composition
- ChatOps workflows — Slack commands that query and manage your cluster
- Monitoring pipelines — watch pods, filter events, send alerts
- Data pipelines — HTTP ingestion, transformation, storage
- Scheduled jobs — cron triggers with complex downstream logic
Getting started
You have two options:
- Desktop client (open source) — connects directly to your cluster via kubeconfig. Download from GitHub.
- Cloud platform — visual editor with monitoring, collaboration, and one-click module installation. Sign up at tinysystems.io.
Both use the same engine. The desktop client is fully functional offline. The platform adds team features and cluster management.
Open source modules
All modules are open source and MIT-licensed:
- common-module — router, cron, ticker, signal, KV store
- http-module — HTTP server and client
- kubernetes-module — pod watch, deployment scale, configmap patch
- communication-module — Slack, email
- encoding-module — JSON, XML, JWT, Go templates
You can also build your own modules using the Go SDK.
What's next
We're focused on stability and real-world use cases. If you try it out, we'd love to hear what works and what doesn't — reach out at hello@tinysystems.io or join our Slack community.