Flowtinus Self-host →
Visual data integration · self-hosted

Draw the flow.
Every envelope arrives.

Flowtinus is a visual editor and runtime for moving data. Wire databases, APIs and scripts on a canvas, test the draft against real data, deploy it, and let your own supervisors run it.

Run it with Docker → See the 34 components
Start → Redshift Query → Mapper → Router → HTTP Request → End 1,240 envelopes in · 1,198 delivered · 42 routed to Discard
34built-in components
17connection types
MCPfor your own AI agent
1 cmdDocker Compose to run it all
PostgreSQLSQL ServerMySQLMongoDBAmazon RedshiftAmazon S3Azure Blob StorageGoogle Cloud StorageSFTPKafkaRabbitMQAzure Service BusAmazon SQSREST OAuth 2.0REST Basic AuthSOAPHTTP Client
The editor

The canvas is the spec.

A flow is a drawing anyone on the team can read: where the data comes from, what happens to each record, and where it ends up. Every record travels as an envelope, so you can count it, open it and follow it.

Finance›Exports›Send orders Saved default ▶ Test run
1 1,240 1,240 1,198 42 1,198 Start Redshift Query orders, last 24 h Mapper Router HTTP Request POST /v2/orders Discard End envelope 1,031 of 1,240 { "order": 88412, "total": 219.9 }
  • →

    Test the draft on real data

    A test run goes to a supervisor like a real one. Each component shows how many envelopes came in and went out.

  • →

    Open any component

    Page through the envelopes a component produced, one by one, with its log next to them.

  • →

    Pin an output

    Freeze what a component returned in a run and keep building downstream without querying the source again.

  • →

    Deploy when it is right

    The draft is yours to break. Schedules, webhooks and real runs always use the deployed version.

Components

34 components. One envelope format.

Every component reads envelopes and writes envelopes, so any of them can follow any other. Settings take fixed values or expressions on the envelope, like $order.total.

Databases

13

Query, insert, upsert, update, delete or run any SQL, once per envelope or in batches, each statement in its own transaction.

SQL Server QuerySQL Server InsertSQL Server UpdateSQL Server DeleteSQL Server Execute Redshift QueryRedshift InsertRedshift UpsertRedshift DeleteRedshift Execute MongoDB PipelineMongoDB UpsertMongoDB Delete 
-- Redshift Query, once per incoming envelope
SELECT id, customer_id, total
FROM orders
WHERE created_at > $since

Transformation

10

Reshape, route and combine envelopes without writing code.

MapperFilterRouterLookupAggregateSplitSortDistinctLimitData Grid

Flow control

8

Loops with Next, Break and Continue with; call other flows and wait for them, or fire and forget.

LoopNextBreakContinue withFlow InvokerWaitLogDiscard

APIs

1

HTTP Request sends one call per envelope: method, URL, headers and body from the envelope, secrets included, through REST, OAuth 2.0 or SOAP connections.

HTTP Request

Scripting

2

When one expression is not enough, write TypeScript, or call a function from the project's own scripts.

async function process($input) {
  if (!$input.email) throw new Error("missing email")
  return { ...$input, email: $input.email.toLowerCase() }
}
Runs

From the queue to the last envelope.

The API never runs a flow. It queues the run in Postgres, and supervisors, each with its own pool of worker processes, take it from there. Add more of them when the queue grows.

I

Queued

A test run, a schedule, a webhook or another flow puts the run in Postgres and wakes the supervisors.

II

Claimed

One supervisor takes it with FOR UPDATE SKIP LOCKED. Never two at once.

III

Prepared

The flow's secrets are decrypted on the supervisor, for this run only.

IV

Executed

A worker process runs the engine, and envelopes move through the components.

V

Recorded

Status, timings and envelope counts per component land on the run's record.

Worker tags

Send heavy flows to a pool with more memory. A flow's tag decides which supervisors may run it, and the editor tells you when no live supervisor has it.

Scale by adding supervisors

--scale supervisor=3 in Compose, or a Kubernetes Deployment per pool. They share one queue and each run goes to exactly one.

Nothing hangs as "running"

Supervisors send a heartbeat every few seconds. When one goes quiet, its runs are failed with the reason, so you can re-run them.

Triggers

Four ways a run begins.

Schedule

On a timetable

Any supervisor may fire a due schedule, and each time slot becomes exactly one run. Choose what happens to slots missed while everything was down.

Webhook

When a system calls

Each webhook has its own address and token, so other systems can start a flow with a POST.

Flow Invoker

From another flow

Wait for the called flow and get its envelopes back, or fire and forget in batches that run on their own.

By hand

When you say so

Run the deployed version for real from the editor, or re-run a failed run with the same input.

Agents

Bring your own agent.

Flowtinus runs no model. Its MCP server gives Claude, Copilot, Cursor or Codex the tools you use in the editor: read the catalog, write a draft, validate it, test run it and read what came out.

  • Personal access tokens with scopes. Give an agent flows:read and runs:test and nothing else.
  • Never more than your role. A viewer's token reads, an editor's writes and runs.
  • Real runs need your yes. Running a flow for real or archiving it asks for your explicit approval.
  • Secrets stay in the editor. An agent sees the names of secrets and connections, never their values.
{
  "mcpServers": {
    "flowtinus": {
      "url": "https://your-host/mcp",
      "headers": {
        "Authorization": "Bearer dfp_…"
      }
    }
  }
}
YouBuild a flow that sends yesterday's orders from Redshift to the billing API, and test it.
Your agent list_connections · describe_component redshift · create_flow · validate_flow · test_run
The test run finished: 1,240 orders read, 1,198 sent, 42 without a customer went to Discard. Want me to deploy it? You'll need to do that in the editor.
Self-host

Runs where your data already lives.

One Postgres, one API, as many supervisors as you need. Everything ships as a Docker image, so it fits a single VM, a home server or a Kubernetes cluster.

DockerPostgres 17BunKubernetes, optional
# Postgres, the API and one supervisor
docker compose --profile server up -d

# more supervisors sharing the same queue
docker compose --profile server up -d --scale supervisor=3

# the editor, at http://localhost:5180
bun run editor
Get started

Your data already flows. Draw where it goes.

Run it with Docker → Connect your agent