Skip to content
Fluxify

self-hosted visual backend builder · Apache-2.0 core · alpha

Draw the backend.
Run it as compiled JavaScript.

Build REST APIs, webhooks and background jobs on a canvas, over your PostgreSQL, MySQL, MongoDB and Redis. Every save compiles to plain JavaScript that Bun workers run.

GET /users/:id
  1. request

  2. success · cache hit

  3. failure · cache miss

  4. error handler · any block throws

execution lognext: cache miss

Run the request: the first call misses Redis and reads Postgres; run it again within 60s to hit the cache.

No response yet.

Real block types, configs and compiler output (compiler.ts). The execution, data and timings are simulated in your browser.

Works with

Databases
PostgreSQL MySQL MongoDB
Key-value
Redis Valkey Dragonfly Memcached
Queues
Redis Streams RabbitMQ Kafka EE NATS JetStream EE Amazon SQS EE
Telemetry
OpenTelemetry Loki
AI assistant
OpenAI Anthropic Gemini Mistral OpenAI-compatible

EE Enterprise connector · all integrations

how it works

Compiled once on save. Requests run plain code.

Most visual flow tools read the flowchart on every call. Fluxify reads it once, when you save, and ships the result to workers.

  1. 01

    Draw

    Pick from 39 blocks and wire them socket to socket. Validation, branches and error paths are part of the drawing.

  2. 02

    Save

    The route compiles to one JavaScript module. If it doesn't compile, the old version keeps serving and the error shows in the editor.

  3. 03

    Serve

    Stateless Bun workers load the module from NATS KV and swap it in place. No restart, no dropped requests.

Same route, same machine: 1.6× the throughput and 43% less CPU per request than our previous interpreter. Full numbers and caveats

capabilities

More than boxes and arrows.

All 39 blocks

operations

What happens when things break.

  1. Admin down, API up.

    Workers hold compiled routes in memory. If the control plane stops you can't edit, but your endpoints keep answering. docs

  2. Broken saves never ship.

    A flow that fails to compile — a missing setting, a cycle — never replaces the version that's serving. docs

  3. Workers can't reach Fluxify's database.

    They receive compiled code over NATS and nothing else. Your flows still reach your own databases through integrations. docs

honest trade-offs

Fluxify vs writing it by hand.

what you get

  • ✓ Request validation, routing and error paths without boilerplate
  • ✓ Deploy by saving — a broken save never goes live
  • ✓ A trace span for every block, without instrumenting anything
  • ✓ Compiled JavaScript on the request path, not an interpreter
  • ✓ Tests, schedules and queue consumers in the same tool

what you give up

  • × It's alpha — expect breaking changes before 1.0
  • × Code runs on Bun, not Node.js
  • × No blocks that call an AI model from a route yet
  • × Community runs one worker; more needs Non-commercial or Enterprise
  • × It's another service to run — there's no hosted version

self-hosted only

One command to try it. Your servers to run it.

Try the Kit, then move to separate admin, orchestrator and worker images for production.

Kit — admin, worker, dashboard, AI gateway and proxy, with bundled Postgres, Redis and NATS
docker run -d --name fluxify \
  -p 8080:8080 \
  -v fluxify_data:/data \
  -e SEED_USER_EMAIL=admin@example.com \
  -e SEED_USER_PASSWORD=ChangeThisPassword123! \
  ghcr.io/fluxify-rest/fluxify-kit:nightly

Open http://localhost:8080/_/admin/ui and sign in with the seed user. Published routes are served from http://localhost:8080/. Keep the volume, or your data goes with the container. :nightly is the latest alpha build.

faq

Questions backend devs ask first.

Can I write code when a block isn't enough?

Yes. The JS Runner block and any js: field run JavaScript on Bun, and scripts can import npm packages you add under Project Settings. You can also package a flow as your own custom block. Scripting and npm imports

Is it production-ready?

Fluxify is alpha: expect breaking changes before 1.0. Use the Kit to try it; production runs as separate admin, orchestrator and worker images on Docker or Kubernetes. Production setup

What's the licence?

Everything outside the ee folders is Apache-2.0 and free for any use, commercial included. Enterprise features are source-available: free for personal, education and non-profit use with LICENSE_KEY=NON_COMMERCIAL; commercial use needs a key, and keys aren't issued before 1.0. Editions and licensing

What does it need to run?

PostgreSQL for the admin, Redis or Valkey, and NATS JetStream. The Kit bundles all three in one container; in production only the admin connects to Postgres. Production requirements

Is there a hosted version?

No. Fluxify is self-hosted only — your servers, your data. Self-hosting options

Does AI run inside my routes?

Not yet. AI powers the assistant that builds routes on the canvas, with your own OpenAI, Anthropic, Gemini, Mistral or OpenAI-compatible model. There are no blocks that call a model from a route. How the AI assistant works

Can a coding agent set it up for me?

Yes. Point Claude Code, Cursor or Codex at docs.fluxify.rest/llms.txt with one of the deployment prompts; every docs page is also served as Markdown. Coding agent setup

Is there an API for the admin?

Yes — everything the editor does goes through the admin REST API, with OpenAPI docs served at /_/admin/api/openapi/ui. Admin API in the Kit docs

Apache-2.0 core. Self-hosted. Free.

Community is free for any use, commercial included, with no limits on routes, requests, projects or seats. Personal, education and non-profit projects can switch on every Enterprise feature for free.

latest release v0.0.2-alpha · 2026-09-23