Flow Like

Automate • Explain • Trust

Automate your work — and see the full data story

Flow-Like is a visual workflow tool. Build with drag-and-drop blocks, and get a clear record of where data came from, what changed, and why the result looks the way it does — no black boxes.

Download Explore docs Star on GitHub

🧩 Drag-and-drop building blocks 🔒 Private by default ⚡ Fast & reliable ☁️ Works on your computer or at team scale

From renaming files to analyzing data to running AI — build flows once and run them anywhere.

Preparing something amazing...

Please wait while we prepare everything

;

Visual builder

Design workflows visually

Draw your flow and see your data’s journey as you build: what came in, how it was filtered and transformed, and what went out. Inline feedback keeps things usable, and snapshots let you reproduce issues and compare runs—no guesswork.

Connections that fit

Pins know what they accept, so you wire correctly and refactors don’t break flows.

Instant feedback

Miswired edges surface immediately. Fix mistakes as you go—before they ship.

See every input & output

Inspect payloads and timings at each step. Trace changes and explain results with confidence.

Inline feedback while wiring a flow — Inline feedback

Workflow overview with inspector showing inputs and outputs — Overview & inspector

Rapid prototyping (live)

Prototype → Ship

Zero-to-prod, without the rewrite

The flow you sketch is the flow you ship. Built-in checks keep connections valid, every change is easy to review, and each step records inputs and outputs — so you can move from first draft to production with confidence, not glue code.

Staging

Prod

Same flow, same visibility — from draft to run.

Ready to ship by default

Checks catch broken connections and mismatched data before you run. Flows stay shippable as they evolve — not just demo-ready.

Change with confidence

When something changes, Flow-Like shows what changed and whether it still fits. Review diffs, keep contracts intact, and avoid breakage.

Predictable in production

Each step records inputs and outputs, so issues are easy to spot as traffic grows. Runs stay steady and explainable — no black-boxes.

Why this matters

The hard part isn’t making something run — it’s knowing what happened.

Most tools show a green checkmark and move on. You’re left guessing where the data came from, what got filtered or transformed, and why the result looks the way it does.

Solution

Flow-Like adds a built-in data trail — every step captures inputs, changes, and outputs.

Outcome

Explainable results. Easier reviews, faster debugging, and fewer surprises.

At any scale

Start solo, share with your team, and run in production — the same visibility stays with you.

Lifecycle with context

Start offline. Go online later. Deploy with one click.

Manage the whole journey without losing visibility. Start a private draft, invite your team when it’s ready, and go live — with the same saved “what went in, what changed, what came out” at every step.

Solo

Team

Live

Same behavior at every stage.

Sketch privately

Try ideas on your machine. Each step saves what went in and what came out, so you can see what changed — no guesswork.

Make it Online & Invite

Flip the project online and invite colleagues. Roles and approvals come along for the ride.

Go live with confidence

Choose your target — Edge, Cloud, or on-prem. Click deploy. Same validated graph, different runtime target.

Create offline project — Offline Local-first → Share → Deploy

Invite teammates — Offline Local-first → Share → Deploy

Traces and timings — Flow-Like instrumentation

Reusable building blocks

Turn any system into a node you can trust

Connect APIs, databases, devices, or spreadsheets without guesswork. Each node has a clear interface, tests, and versions — so what worked yesterday works tomorrow, for you and your team.

APIs & Webhooks Databases Files & Storage Messaging & Queues Devices & Sensors AI & CV

Always compatible

Inputs and outputs are checked and versioned, so updates don’t break other flows.

Safe to evolve

Nodes ship with fixtures and tests. Change things with confidence — you’ll catch issues early.

Share & reuse

Publish privately or to a catalog with versioning, so teams can reuse and upgrade safely.

See how to turn an internal API into a node

Reusable node with clear inputs and outputs — clear inputs changes → result versioned

Under your brand

Add the editor or just the engine

Drop the visual editor into your app, run the engine behind the scenes, or combine both. Your logo, your colors — with the same visibility and audit trail.

Drop-in editor Run behind the scenes Edit here, run there

Drop-in editor

Mount the visual editor in any route and theme it with your tokens.

Design tokens & CSS vars

Map your palette; instant dark/light support.

SSO & secrets

OIDC/JWT and scoped secrets per tenant or app.

Usage metering

Per-tenant quotas, events, and audit trail.

SDKs & webhooks

Control flows via SDKs and a simple REST API.

Drag

Theme presets

Scroll →

LOGO

Your logo, your tokens

Craft your brand in tweakcn — paste tokens to apply instantly.

One flow, many views

One process, seen three ways

People think in steps. Systems run on data. IT cares about logic. Flow-Like shows all three together, so every role sees the same truth — just in their own language.

Your Business - Because it has Depth

Three interconnected views of the same process

Process view

The plain-English story of how work gets done. Who does what, when, and why — captured as one flow. Great for managers and business owners to align on the same steps.

Steps & Handoffs

From intake to outcome, see every stage of the journey.

Decisions

Approvals, gates, and routing made visible.

Storage & Search — Built-in

Files, tables, and search — right on the canvas

Save files, keep records, and find things fast — all inside your flow. No extra services to wire up. Plug a node in, and your data is ready to use.

workspace/project-files/ secure links

photo.webp 1280×720 • 84 KB
invoice.pdf shareable link
claim.jpg high-res • streams smoothly
notes.txt tiny • cached

Storage that comes ready to use

Upload a file, store a record, or search across both — without leaving the workflow. Everything stays connected to the steps that used it, so you can explain results later.

⚡ Stream files and process them in place

🧾 Checks that keep data shape consistent

🔐 Secure links & scoped access

♻️ Smart caching for faster runs

🧠 Keyword + vector search together

📦 Works local or with your cloud storage

∞ Files ∞ Tables Keyword + Vector Hybrid queries Inline in workflows

New & notable

Frequently Asked Questions

Search, filter, and deep‑link to answers. Built for individuals and enterprises alike.

Filter:

Where can I run Flow‑Like?

Locally on macOS, Windows, and Linux; in containers; on the edge; or in any cloud. Start offline on your laptop, move to production later without changing the graph.

Can I run fully offline / air‑gapped?

Yes. Flow‑Like is local‑first. You can run completely offline or in air‑gapped environments. Sync to cloud later if you choose.

How do I integrate with my stack?

Wrap systems as typed nodes with explicit input/output types. Embed or white‑label the editor, or run the engine headless inside your app.

What languages can I use for nodes?

Nodes are authored in Rust today. A WASM node SDK is planned to broaden language support.

Is there governance?

Yes — approvals, policy guardrails, roles, and versioned flows with audit trails are first‑class to meet operational and compliance needs.

How is data stored and searched?

Object‑store–centric by design (e.g., S3/local). For vector search we use LanceDB behind the scenes; graphs interact via nodes — no raw SQL required.

Does it support versioning & reviews?

Flows are versioned. You can stage changes, request approvals, and roll back safely. Git‑based workflows integrate smoothly.

How do I go from dev to prod?

The same typed graph runs locally and in production. Package as a container, deploy to edge/cloud, and promote versions via approvals.

How fast is it?

The runtime is written in Rust for high throughput and low latency. Many workloads run dramatically faster than typical scripting‑based stacks.

Is my data private?

You control where data lives. Local‑first by default, no forced telemetry, and encryption in transit. Keep everything on‑prem if needed.

Do you support SSO / identity providers?

Yes we support OIDC, just configure your provider in the flow-like.config.json

What license does Flow-Like use?

Business Source License (BSL) 1.1 with an Additional Use Grant, and a Change Date after which each version becomes MPL 2.0.

What does the Additional Use Grant allow?

You may use the software (including production use) as long as you do not use it to develop, offer, or provide a product or service that competes with Flow-Like or with products/services from TM9657 GmbH that are substantially similar to Flow-Like’s functionality.

Are there organization-size restrictions?

Yes. A Large Entity—defined as an organization with >2,000 employees or >€300M annual revenue—is not eligible to use Flow-Like under the BSL terms in any capacity and must obtain a commercial license from TM9657 GmbH.

Can agencies/consultants use Flow-Like for clients?

Yes, if neither the agency nor the client is a Large Entity and the delivered solution is not a Competitive Product or Service. Large Entity clients require a commercial license.

Do I need to code to use it?

No. Build visually with typed nodes. Coding is optional for custom nodes or advanced logic.

How do I back up or migrate?

Projects are file‑based with object‑store artifacts. Use your existing backup tooling and promote versions between environments.

How is Flow‑Like different from typical workflow tools?

Types on nodes & edges, local‑first design, Rust performance, and governance built‑in. Safer changes, faster execution, portable deployments.