Documentation

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 · Deploy again

Enabling doesn’t change the site that’s already live. On your next deploy we connect every <form> in your HTML that has no destination of its own (no action, #, a .php, or a Netlify form). Search boxes, logins and forms you pointed at another service are left alone. The panel tells you which forms it connected.

Writing the form yourself

<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: a bot that fills it is kept marked as spam and doesn’t email you.

React, Vite, Bolt, Lovable (JavaScript apps)

In a JavaScript app the form is drawn by code, so a deploy can’t connect it. Send it with fetch — JSON or form data both work — or paste the prompt the panel gives you into your AI tool:

const res = await fetch('https://api.fluentops.org/forms/<token>', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ ...form, 'form-name': 'contact' }),
})
if (res.ok) { /* show your thank-you message */ }

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.

Run modes

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.

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",
#  "warnings":[{"kind":"missing_env","items":["VITE_SUPABASE_URL"],
#    "fix":"fluentops secrets add VITE_SUPABASE_URL=<value> && fluentops deploy"}]}

A deploy that doesn't go live exits non-zero with "status":"error" and a stable code: needs_selection (with the options found — re-run with --front/--back), build_failed (with error and the last log lines in log_tail) or unsupported_stack. Everything an agent needs to fix it and try again, without a second command.

Ignoring files

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

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.