Documentation

FluentOps deploys full web apps — a static front-end (React, Vite, plain HTML), a real backend (Node, Python, Go, Ruby), or an app that renders its own pages (Next.js, Nuxt, SvelteKit, Astro, Remix, Django, Rails) — to a public URL with automatic HTTPS, free. You never touch infrastructure.

There are three ways to ship, all equivalent:

• CLI — fluentops deploy from your project folder. Best for AI agents.
• Drag & drop — drop a folder or ZIP in the dashboard.
• Git — connect a GitHub repo and deploy.

Every deploy gives you your-project.fluentops.org; connect your own domain anytime.

The fastest path is the CLI:

cd my-app
fluentops deploy

That's it:

✓ Project created
✓ Source uploaded
✓ Build completed
✓ Deployment completed

Live URL:
  https://my-app.fluentops.org

Prefer a UI? Create a project in the dashboard and drag your folder onto it.

A thin, single-binary CLI for macOS and Linux. It detects your framework, creates and links the project, packages your source, uploads, streams build logs, and prints the live URL. Built to be driven by humans or AI agents (Claude Code, Codex, Cursor).

Install

One command — it detects your platform, installs the binary onto your PATH and drops the agent skill:

curl -fsSL https://fluentops.org/install.sh | bash

The fastest way is to let your agent do it: use Copy setup instructions for my agent at the top of this page and paste into Claude Code, Codex or Cursor. Prefer a manual download? Grab the archive for your platform (macOS / Linux, amd64 / arm64) from https://fluentops.org/cli/ and put fluentops on your PATH.

Authenticate

login opens your browser and stores a token securely (macOS Keychain, or an encrypted file).

fluentops login
fluentops whoami

For CI or agents (no browser), set a token directly:

export FLUENTOPS_TOKEN=<token>
# or: fluentops login --token <token>

Deploy

From your project directory:

fluentops deploy

On the first run it creates the project and writes .fluentops/project.json so later deploys reuse it — no prompts. Override the name with --name my-app.

Commands

Agent & JSON mode

--json emits machine-readable output and --yes never prompts — both auto-enable when output isn't a terminal, so agents and CI work with zero flags.

fluentops deploy --json --yes
# {"status":"success","project_slug":"my-app",
#  "url":"https://my-app.fluentops.org", ...}

Ignoring files

node_modules, .git, dist, build, out and .fluentops are always skipped. Add a .fluentopsignore (gitignore syntax) to exclude more.

No install required:

1. Create a project in the dashboard.
2. Drag your project folder (or a .zip) onto the deploy panel.
3. We skip node_modules, .git and build output automatically — leave them in.
4. The build runs in the cloud and logs stream live; your URL appears when it finishes.

To update, drop again — each upload replaces the previous version at the same URL. Max upload 50 MB.

1. In your project, choose Deploy from Git.
2. Connect GitHub once (one click) — needed for private repos; public repos work without it.
3. Paste the repository URL and deploy. We clone, install, build and publish.

Re-deploy anytime to pull the latest commit.

Add secrets under Project → Secrets (or fluentops secrets add KEY=VALUE). They're encrypted at rest and injected both at build time and into your backend at runtime, so code like process.env.OPENAI_API_KEY (or os.environ) just works.

• Prefix a variable with VITE_ to expose it to the browser bundle (safe for public keys/URLs).
• Keep service-role and secret keys unprefixed — they stay server-side, and reach your backend at runtime.
• Connect a service lists the exact variables for Supabase, OpenAI, Stripe, Firebase and more.

Under Project → Domains, add your domain (e.g. www.mycompany.com). FluentOps issues a free certificate and shows the exact DNS records to add, in two steps:

1. Verify ownership — add the CNAME validation record (one-time; auto-renewals reuse it).
2. Point your domain — add the routing record at your DNS provider.

For a root/apex domain: if your DNS supports it (Cloudflare, Route 53…) you add the record at @ directly. If your registrar can't (e.g. Namecheap), connect www and add an Unmasked 301 redirect from the root — the UI detects this and shows the right records. HTTPS is provisioned and renewed automatically once DNS resolves.

FluentOps Forms turns a plain <form> on your static site into working lead capture — no backend, no code. Submissions land in your project’s inbox and email you instantly. It’s free (100 submissions/month per account). See the Forms overview.

1 · Enable it

In your project, open the Grow tab and click Enable forms. You get a unique endpoint URL for that project.

2 · Point your form at it

<form action="https://api.fluentops.org/forms/<token>" method="POST">
  <input name="email" />
  <textarea name="message"></textarea>
  <input type="text" name="_gotcha" style="display:none" tabindex="-1" />
  <button>Send</button>
</form>

Any field names work — they all arrive in your inbox. The hidden _gotcha field is a honeypot that silently drops bots.

Optional fields

• _redirect (or _next) — send the visitor to a thank-you page after submitting; without it they get a small JSON response.
• form-name (or _form) — label submissions when a project has more than one form.

Free includes 100 submissions/month across all your sites, kept 30 days. Pro raises it to 1,000/month with CSV export and unlimited retention. Over the limit, leads are still captured — we never drop one.

FluentOps runs a real backend for your app — an actual process in a container, not a serverless function. It keeps in-memory state, holds WebSocket connections, and connects to your database normally.

Zero config — we detect your stack

You don't write a Dockerfile. Just like the front-end, we read your project's files and build the image for you. Deploy the same way (CLI, drag & drop, or Git); if we find a server, we deploy it alongside your front-end in one step.

Where it lives

Deployed on its own, your backend answers every path at your project's URL — whatever routes you wrote, wherever you mounted them. Nothing else is competing for /, so we don't take it from you:

https://your-project.fluentops.org/users

/api/* keeps working either way, so a URL you already wired up doesn't break. Your project's secrets are injected as environment variables at runtime, so process.env / os.environ just works.

Front + back in one project (monorepos)

Have your front-end and backend in one repo (say web/ and api/)? Deploy it as-is — we scan your folders, find both, and deploy them together: the front-end at /, the API at /api/*. You can also choose to deploy just one. If we find more than one front-end or more than one backend, we ask you which to deploy.

Apps that render their own pages

If your app renders its pages on the server — Next.js SSR, Nuxt, SvelteKit, Astro, Remix, Django, Rails, or an Express/Flask app with templates — deploy it as-is. We detect it, build it, and your app owns every route at /, not just /api/*. No output: "export", no splitting it in two, no changes to your code.

The trade-off is worth knowing: a static front-end is served from the CDN and stays up even while a Free backend naps, whereas a server-rendered app builds each page in your container. If your site is content that doesn't change per visitor, a static build is still faster and cheaper — but that's your call to make, not a limit we impose.

Every backend is one artifact with a run mode you pick on the project page (next to Secrets). Change it anytime — no re-deploy.

• Always on — a service that keeps listening (an API, a web server). On Free it sleeps after a few minutes idle and wakes on the first request (a ~1–3s cold start); on Pro it never sleeps.
• On demand — a job that runs when triggered and stops. We give you a private activation URL (POST) and a Run now button; each run's logs and exit code are kept in history.
• On a schedule — the same job on a cron schedule (UTC). Free runs at most once a day; Pro allows per-minute schedules.

Run minutes for on-demand and scheduled jobs are metered against your plan's monthly quota; when you hit it, jobs pause until next month — you're never billed for overage.

FluentOps hosts your app, not your database — the same model as Vercel. Use a managed provider and connect to it from your backend with a secret:

• Supabase / Neon — Postgres
• PlanetScale — MySQL
• Upstash — Redis
• Any host — set the connection string as a secret (e.g. DATABASE_URL)

The dashboard's Secrets section has copy-paste recipes for the common ones, with the exact variable names each expects.

Front-end (static hosting)

• React (CRA or any bundler with a build script)
• Vite (including React + Vite)
• Next.js static export (output: "export")
• Static HTML / CSS / JS

Apps that render their own pages (server-side)

Deployed as-is: the app owns every route at /, and we build it the way its framework expects. No output: "export", no code changes.

• Next.js (SSR / App Router — dynamic routes, middleware and route handlers included)
• Nuxt, SvelteKit, Astro (server mode), Remix
• Django — manage.py plus your settings module; we run collectstatic for you
• Rails with views, and Express / Flask / FastAPI apps that render templates (EJS, Pug, Jinja, ERB…)

Backend (auto-detected, no Dockerfile needed)

• Node — Express, Fastify, Hono, Koa, NestJS, Elysia (or any server with a start script)
• Python — FastAPI, Flask, or a plain script/worker (job.py, main.py…) run as a job
• Go — any module with a main package
• Ruby — Rails, or Rack apps (Sinatra/Roda) with a config.ru
• Jobs & cron — a script that runs and exits is a job: it defaults to On demand (trigger by URL/CLI) and can be switched to On a schedule. No server, no Dockerfile.

Any other language

FluentOps builds your app from its detected stack — it doesn't run an uploaded container, so a Dockerfile in your project is ignored (we tell you when we skip one). Stacks we don't build yet — Rust, Java, PHP, Deno and others — aren't supported at the moment; tell us what you need and we'll prioritize it.

If we can't tell how to start your backend, the build fails with a clear message (e.g. "add a start script to package.json").

Still stuck? Use Send Feedback in the dashboard — include your WhatsApp and we'll reach out.