How to Use Backenly: The Beginner's Guide (First Project, the Self-Healing Loop, and the MCP Arc)
CodexFuse Team · 2026-11-03T02:47:21.636Z · 19 min read min read
Backenly is the autonomous backend for AI coding agents: typed MCP tools build your Postgres backend while a self-healing loop fixes safe problems every minute. First project, MCP setup, Free vs Pro, branches.
How to Use Backenly: The Beginner's Guide (First Project, the Self-Healing Loop, and the MCP Arc)
Learning how to use Backenly starts with one idea: your coding agent gets a real backend it can build on directly, and that backend watches itself every minute for problems. Backenly is the autonomous backend for AI coding agents — your agent creates tables, sets up auth, writes policies, and wires realtime over typed MCP tools, while an autonomy loop checks the live backend continuously, fixes what it can verify and undo, and holds anything risky for your approval. If you build agent-driven apps with tools like Dify, our Dify beginner guide covers the agent-app side — Backenly is what sits underneath: the database, API, auth, and realtime your agent's app actually runs on.
Backenly launched on Product Hunt on October 29, 2026, so this is a genuine first-wave beginner's guide — there is no established tutorial canon yet, and everything below is checked against Backenly's own docs and pricing pages fetched this week. This backenly tutorial walks the whole first-use system in order: what the product actually is, your first project, connecting your agent over MCP, what the self-healing loop fixes (and what it holds back), branches for risky experiments, and the Free vs Pro vs self-host decision. And since every table gets a REST API automatically, you can poke the endpoints your agent builds with a REST API tester as you follow along.
What Is Backenly, Exactly?
Backenly is a backend-as-a-service built for AI coding agents instead of humans clicking around a dashboard. You connect your agent (Claude Code, Cursor, Codex, or any MCP host) to a Backenly project, and the agent manages the backend through typed MCP tools: it creates tables, sets auth policies, ships API endpoints, and configures realtime. Sitting beside that is Backenly's autonomy loop, which inspects the live backend every minute on every plan — Free included — looking for schema drift, missing indexes, slow queries, row-level-security gaps, broken triggers, and stuck deployments.
The mental model in one sentence: your agent builds the backend through tools it can call, the loop repairs what is safe and undoable, a human approves what is risky, and every change is versioned with a restore point. That division of labor — agent builds, loop maintains, you approve — is the whole product, and every section below is one piece of it.
One naming clarification, because the search results for this lane are noisy: Backenly is its own product and company. It is not Back4app (a classic backend-as-a-service built on open-source Parse Server, running since 2015, which has recently added an AI agent and MCP layer to its marketing), not Backendless (a low-code MBaaS with a visual database builder and a $25-per-month start tier — UI-driven, not agent-native), and not mcpbackend.com (a separate MCP-native backend that is SQLite-backed rather than Postgres — same genre, different product, different company).
If you are weighing backenly vs back4app for an agent-driven project, the difference is the interface and the maintenance model: Backenly's primary interface is typed MCP tools and it ships a self-healing autonomy loop; Back4app is a mature Parse-based BaaS that humans have operated through a dashboard for a decade, with MCP added recently. This guide covers Backenly only.
How Do I Set Up My First Backenly Project?
To set up your first Backenly project, create an account, start a project, generate a scoped key for your agent, run the one connect command, and start a fresh agent conversation. The flow is deliberately agent-first — you barely touch the dashboard yourself.
- Create your account and project. Sign up on backenly.com; the Free plan needs no credit card. Create a project, which gives you one isolated PostgreSQL schema — Backenly describes the isolation as a Postgres grant, not a WHERE clause, meaning your data is separated at the database permission level.
- Generate a scoped key bound to that project. In the Connect view, create a key and choose its scope: read-only keys serve 16 MCP tools and withhold every write tool, while read-write keys serve all 23. Scope the key to exactly one project, and keep this key out of your app's runtime — the app gets its own project key through a separate create_api_key call, because an agent must never be able to change its own key.
- Run the one connect command for your agent. Before opening your agent, run the command for your host. For Claude Code:
claude mcp add backenly -- npx -y @backenly/mcp-server --project <PROJECT_ID> --key <SCOPED_KEY>. Prefer no local install? Use the remote form:claude mcp add --transport http backenly https://backenly.com/api/mcp --header "x-api-key: <SCOPED_KEY>". The local form runs the npm package on your machine; the remote form connects over HTTP with nothing to install. - Start a new agent conversation. MCP hosts read their MCP configuration at conversation start, so an existing chat will not see the new server. Open a fresh conversation after adding the key.
- Ask the agent to confirm the connection. Have your agent call
read_backend_state. If it can describe your project's tables, the wiring works; if it cannot, the key or the conversation timing is the culprit.
Fallback path worth knowing: if your host cannot run MCP servers, the CLI works without one. npx -y @backenly/cli@latest link --project <PROJECT_ID> --key <SCOPED_KEY> links the project, and then backenly call read_backend_state, backenly call get_table_schema tableName=posts, and backenly call apply_migration sql="..." give you the same operations from a terminal.
How Does My Coding Agent Talk to Backenly?
Your agent talks to Backenly through typed MCP tools, and the typing is the point — the tools are narrow, named, and bound to one project, so the agent can act without a sprawling set of database superpowers. The published agent skill at backenly.com/skill.md is the canonical reference for this; Claude Code users get the fullest documented path, and our Claude Code beginner guide covers the agent side of the pairing if you are new to it.
The backenly mcp backend flow has a deliberate handshake. You scope the key, you pick the transport (local npm package or remote HTTP), and your agent starts from read_backend_state before touching anything. From there the agent can inspect schemas, propose migrations, and manage data — but the key's scope is a hard boundary: a read-only key withholds all write tools, and no agent can escalate its own key. Meanwhile your application connects separately through the Direct tab: a REST base URL, TypeScript types, an OpenAPI spec, allowed origins, and read-only or read-write Postgres connection strings for the app itself.
Two guardrails matter from day one. First, the MCP key must never be used in the app runtime — the server refuses it outright as an MCP_KEY_IN_APP error, which is Backenly's way of forcing you to give the app its own weaker project key. Second, because hosts read MCP config at conversation start, every key change means a new conversation, or you will spend twenty minutes debugging a connection that was never going to appear.
What Does the Self-Healing Loop Actually Fix?
The self-healing loop checks your backend every minute on every plan, Free included, and it fixes only the problems that are additive and undoable — everything else waits for you. Inactive projects (no traffic or changes for 30 days) are not checked until activity returns, and the loop is honest about its blind spots: a check that cannot run is reported as not checked, never as passing.
Here is the practical split, straight from the docs:
| The loop finds | What happens |
|---|---|
| A missing index on an unindexed foreign key | Auto-repaired — additive and verifiable |
| A dead realtime trigger | Auto-repaired — safe and undoable |
| A broken API definition | Auto-repaired — safe and undoable |
| Schema drift or a stuck deployment | Flagged with the evidence; safe repairs apply |
| A row-level-security gap (e.g., a new user-data table with no RLS) | Flagged and held — the docs show it as "flags it and shows you why," not auto-fixed |
| Auth changes, credentials, anything destructive or irreversible | Always held for a person — no mode overrides this |
The vendor's launch post phrases the repair list more aggressively ("repairs missing indexes, RLS gaps and dead realtime triggers"), but the autonomy docs are the stricter source: RLS gaps get flagged for approval. Plan for the docs' behavior and treat the launch post's phrasing as marketing.
You control the loop's posture with two modes. In Review-only mode, every visible change waits for your one-click approval while silent additive repairs still apply. In Autopilot mode, the loop applies safe fixes on its own and holds the rest. Either way, no mode can apply auth, destructive, or irreversible changes by itself — and no setting changes that. Every fix comes with what Backenly calls autonomy receipts: what was found, what changed, and how it was checked, so a repair is never a black box.
The versioning underneath is what makes the auto-repairs safe to allow. Every schema change keeps a restore point, and the History page can restore a single change or roll back to a point without dropping data written since — secrets and revoked keys are never restored, which is the right exception. If the loop escalates something it cannot explain, it may run an AI investigation that gathers read-only evidence and presents a hypothesis, but any proposed repair still waits for your approval — and Backenly pays for those investigations, not you. In fact the whole loop is unmetered: self-healing is never metered on any plan, and the typed MCP tools themselves never spend AI credits. Only Backenly's own model usage (backend_chat, function generation, AI investigations) spends credits.
What Do I Get Inside a Backenly Project?
A Backenly project is one isolated PostgreSQL schema with a full backend attached to it — tables, auth, realtime, and storage, all reachable by both your agent and your app. The isolation is a Postgres grant rather than a WHERE clause, which is the detail that makes "one project" a real security boundary instead of a naming convention.
| Piece | What it is |
|---|---|
| Database | PostgreSQL with tables, relations, indexes, constraints, and pgvector; direct connection strings and pg_dump exports available |
| REST API | Every table served via PostgREST from the catalog — filters, ordering, pagination, embedded resources, and an OpenAPI spec |
| Auth | Sign-up, OAuth, magic links, and verification emails — each project signs with its own secret |
| Realtime | Inserts, updates, and deletes as they land, plus presence and broadcast — delivered over SSE, with no socket server to run |
| Storage | Buckets, uploads, metadata, and expiring signed URLs — local disk or any S3-compatible provider |
New tables start with sensible defaults: an id (uuid), createdAt and updatedAt in camelCase, and deleted_at in snake_case, per the agent skill. And the "table doing two jobs" problem has its own arc: when autonomy decides a schema needs restructuring, it proposes a step-by-step reversible plan, rehearses it on a copy, and only runs it after you approve the exact plan — with dropping the old column always left to you. That restructuring path needs the maintenance scheduler, which is on for Cloud and off by default for self-hosted.
How Do Branches Keep My Agent's Experiments Safe?
Branches let your agent experiment on a copy of the backend, and merging anything back waits for a human — which is exactly how version control should work. If you already think in branches from Git, our Git beginner guide is the mental model: Backenly applies the same clone-experiment-review-merge shape to a live backend.
The arc works through the branch MCP tool: list, create, connect, diff, and merge. Your agent clones the backend into a branch, runs apply_migration with a branchId, and tests against a preview endpoint using a branch-bound key — the risky schema work never touches production data. When the experiment works, the agent reviews the diff with you, and merge completes only after a person approves it. The vendor's homepage sums it up as "clone the backend, let your agent experiment, review the diff, merge what works."
Destructive requests have their own queue: anything your agent asks to do that cannot be undone parks under "Waiting on you" in the dashboard, with the impact laid out — live row counts and recoverability — before you decide. The agent's key can request and poll these, but never approve them. The dashboard around all this is an oversight surface: the agent journal, the autonomy receipts, key/team/branch management, and the restore points, in one place.
Should I Use the Free Plan, Pro, or Self-Host?
Start on the Free plan — it includes the full autonomy loop and never asks for a credit card, which makes it the honest way to evaluate the product. Backenly Cloud's pitch is "no credit card, move to Pro when your product needs more capacity," and the free tier is genuinely usable rather than a demo.
| Free ($0) | Pro ($25/mo or $240/yr) | |
|---|---|---|
| Projects / seats | 1 project, 2 team seats | Unlimited projects, 5 team seats with project-level access |
| Postgres | 512 MB | 8 GB included, then $0.125/GB-month |
| API requests | Unlimited | Unlimited |
| Realtime | 25 concurrent connections | 1,000 concurrent connections |
| Function runs | 10,000/month | 2M/month, then $2.00/1M |
| AI credits | 200/month | 3,000/month |
| Self-healing loop | Included, every minute, never metered | Included, every minute, never metered |
| Backups / logs | Daily backups kept 7 days; 7-day log retention | 30-day log retention; email support; custom domains; SSO (OIDC) |
A few pricing details that matter: MAU are 50,000 on Free and 100,000 on Pro ($0.003 per MAU after); storage is 1 GB with 5 GB egress on Free versus 100 GB storage and 250 GB egress on Pro ($0.0213/GB-month and $0.09/GB after, respectively). Quotas are hard-capped by default — nothing silently bills you — and overage requires spend limits ($50, $100, or $250) that you pay in advance and that stay off unless you enable them. There is also an Enterprise tier with custom annual pricing and a dedicated 12-hour SLA.
The backenly self-host option is a different deal: the entire platform is open source under Apache-2.0, including the autonomy engine, while the SDK, CLI, MCP server, and agent skill are MIT — so you can run the same codebase on your own infrastructure for free. Say this once, because it is the part people get wrong: you bring the servers, and you bring an AI provider key (Claude or OpenAI) only for the features that use a model, like the natural-language build tools. The self-healing fixes themselves are rule-based — detection finds the drift, each finding maps to a typed repair that compiles to SQL, and no model sits in the repair path. It is the same codebase either way, and pg_dump moves your data between Cloud and self-hosted.
One launch detail: the Product Hunt post advertises code PRODUCTHUNT50 for 50% off monthly Pro for three months. It does not appear anywhere on backenly.com or the pricing page, and whether it still redeems could not be checked without a checkout — if you are considering Pro, try the code at signup and treat it as a launch perk that may expire.
What Are the Beginner Mistakes to Avoid?
Backenly is new enough that the mistake catalog is small — which is exactly why it is worth reading before your first project. Every one of these follows from something the docs state explicitly.
| Mistake | Why it hurts | Do this instead |
|---|---|---|
| Reusing an old agent conversation after connecting | Hosts read MCP config at conversation start — the server never appears | Always start a fresh conversation after adding the key |
| Using the MCP key inside your app | The server refuses it outright (MCP_KEY_IN_APP) | Give the app its own project key via create_api_key |
| Giving the agent a read-write key for a first look | All 23 tools are live, including migrations | Start read-only (16 tools); widen scope deliberately |
| Treating the launch post as the docs on RLS | The post says "repairs RLS gaps"; the docs say RLS gaps are flagged for approval | Plan for approval-gated RLS fixes |
| Running experiments on the live project | Schema changes are versioned but still disruptive | Branch first, merge after reviewing the diff |
| Assuming a silent loop means a healthy backend | A check that cannot run is reported as not checked, never as passing | Read the autonomy receipts, not just the absence of alerts |
| Leaving the self-hosted maintenance scheduler off | Schema restructuring plans need it to run | Turn it on if you self-host and want the full autonomy arc |
Sources
Every fact in this guide was verified against pages fetched during the week of publication: Backenly's homepage (backenly.com) for the autonomy loop, licensing, and self-hosting terms; backenly.com/pricing for the Free and Pro tiers, overage rates, and the "self-healing never metered" note; backenly.com/docs/connect for the scoped-key flow and the MCP connect commands; backenly.com/docs/autonomy for the per-minute checks, the auto-fix vs flagged split, and the Review-only/Autopilot modes; backenly.com/skill.md for the typed MCP tools, the CLI fallback commands, the connect handshake, and the branch tool; the Product Hunt launch page (producthunt.com/products/backenly-2, published October 29, 2026) for the launch offer and launch-week claims; and the aihot0818 tool directory listing as a second confirmation of the launch timing.
Frequently Asked Questions
Is Backenly free?
Yes — the Cloud Free plan costs $0 with no credit card and includes 1 project, 2 team seats, 512 MB of Postgres, unlimited API requests, the per-minute self-healing loop, and 200 AI credits a month. Pro is $25 a month (or $240 a year) for unlimited projects and higher limits, and self-hosting the Apache-2.0 platform on your own servers is free apart from your own infrastructure and an AI provider key for the model-powered features.
How does Backenly connect to Claude Code?
Through MCP: create a scoped key bound to one project, then run claude mcp add backenly -- npx -y @backenly/mcp-server --project <PROJECT_ID> --key <SCOPED_KEY> before opening your agent, start a new conversation, and ask the agent for read_backend_state to confirm. A remote form (--transport http against backenly.com/api/mcp) connects with nothing to install.
What does Backenly's self-healing loop fix automatically?
It auto-repairs additive, undoable problems: missing indexes on unindexed foreign keys, dead realtime triggers, and broken API definitions. Row-level-security gaps are flagged for your approval, and auth changes, credentials, and anything destructive or irreversible are always held for a person — no mode overrides that.
Is Backenly open source?
Yes. The entire platform, including the autonomy engine, is open source under Apache-2.0, and the SDK, CLI, MCP server, and agent skill are MIT licensed. You can self-host the same codebase that runs Backenly Cloud, and pg_dump moves data between the two.
How is Backenly different from Back4app or Backendless?
Back4app is a classic backend-as-a-service built on open-source Parse Server (running since 2015) that has recently added an AI agent and MCP layer, and Backendless is a low-code MBaaS with a visual database builder — both predate the agent-native wave. Backenly is built agent-first: typed MCP tools are the primary interface, and the autonomy loop maintains the backend continuously. They solve adjacent problems with different interfaces and histories.
