Skip to content
Fluxify
Visual Backend Canvas meets Autonomous AI & MCP

The Visual Backend for Developers and AI Agents.

Draw REST APIs, webhooks, and background jobs on an interactive canvas, or let Claude Code, Cursor, and Windsurf build them through 65+ native MCP tools. Every save compiles to standalone Bun JavaScript.

Self-host Free GitHub ★ Open Source Explore Features
Instant Kit: docker run -p 8080:8080 ghcr.io/fluxify-rest/fluxify-kit:nightly

production architectures

One visual canvas. Every backend pattern.

From high-concurrency transactional APIs to event streaming and reusable security middleware — see how real backends are designed, compiled, and served.

Transactional Order Checkout & Stock Allocation
POST /api/v1/orders/checkout Compiled Bun Module
Click to expand & zoom
Transactional REST APIs: Atomic database mutations, cache-aside lookups, and sub-millisecond JSON serialization.
Stateless Bun workers execute compiled graph without runtime interpretation Explore all features

Works with

Databases
PostgreSQL MySQL MongoDB
Key-value
Redis Valkey Dragonfly Memcached
Queues
Redis Streams RabbitMQ Kafka NATS JetStream Amazon SQS
Telemetry
OpenTelemetry Loki Audit Logs EE
AI & Extensibility
MCP (Server & OAuth) @fluxify/sdk AI SDK Claude Code Cursor OpenAI Anthropic

EE Enterprise feature · 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

    Commit

    Edits update your dev worker instantly. Snapshot working copies into immutable versions with commit notes.

  3. 03

    Promote

    Automated gates run your test suites and check dependencies before swapping into production workers with zero downtime.

Official load benchmarks (500 concurrent users): Fluxify serves 6,500 – 7,300 req/s with 0 errors — delivering 1.4× the throughput and 3.8× tighter p95 tail latency than hand-written Node.js 24 (116 ms vs 448 ms). See official benchmark report

what you build

The plumbing every backend has.

Endpoints over a database, webhooks, glue between services, background jobs. The work you've written a hundred times — drawn once, served as compiled code.

All use cases

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.

Kit fluxify-kit One container, one port. Prototypes and testing only. Production on Docker admin · orchestrator · worker Traefik in front; the orchestrator starts and replaces workers. Kubernetes Helm The same three images, workers as cluster workloads. With a coding agent llms.txt Hand Claude Code, Cursor or Codex the docs index and a prompt.

Workers per edition: Community 1 · Non-commercial 2 · Enterprise no cap. Editions

faq

Questions backend devs ask first.

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

Yes. Use JS Runner blocks, js: fields, or author your own Plugins using @fluxify/sdk and the CLI to create custom blocks, triggers, and integrations in TypeScript. You can also extract any canvas flow into a reusable custom block. Scripting and npm imports

Can external coding agents (Claude Code, Cursor, Windsurf) edit Fluxify?

Yes. Fluxify ships with a full Model Context Protocol (MCP) server. Generate a Personal Access Token or connect via OAuth 2.0 to give agents 65+ tools covering the canvas, routes, workflows, test suites, sandboxes, and versions. MCP server and tools

How does versioning and deployment work?

Edits land immediately on the development worker's working copy. You commit named versions (v1, v2) with notes, and promote to production only after 5 automated gates — including all attached test suites — pass successfully. Versioning & releases

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?

AI powers the in-editor assistant and the MCP server that builds routes. Routes call upstream AI models via HTTP Request or JS Runner blocks with your provider's npm SDK. How the AI agent 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.

Run the Kit Star · 4

latest release v0.0.3-alpha-pre-plugin · 2026-10-19