Postgres, a schema of your own
Tables, relations, indexes, constraints and pgvector, in a PostgreSQL schema per project. Isolation is a Postgres grant, not a WHERE clause.
- Standard PostgreSQL
- pgvector
- Direct connection strings
- pg_dump exports
(opens in a new tab)The autonomous backend built for coding agents
Your coding agent builds the backend over MCP. Backenly maintains it on its own, fixing what it can verify and undo, and holding anything risky for you.
Claude Code builds the UrbanCart store backend through Backenly MCP tools while the Backenly Database page fills with the products, orders, order_items and users tables and the first orders arrive.
Your agent builds tables, auth, policies and realtime over MCP.
Works with any MCP host
- Claude Code
- Cursor
- Codex
- Antigravity
- Cline
- GitHub Copilot
- Zed
Everything a production backend needs. Wired to one Postgres schema per project from the first table.
Auth
Sign-up, OAuth, magic links and verification emails for your users. Each project signs with its own secret.
REST APIs
PostgREST serves every table from the catalog: filters, ordering, pagination, embedded resources, OpenAPI.
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, on local disk or any S3-compatible provider.
Functions and triggers
Run code on insert, update, delete or signup, or on a cron schedule. Webhooks and rate limits included.
Also built in
Every featureRow-level security by description
Say who can read and write what. Backenly writes and enforces the Postgres policies.
Branches for risky work
Clone the backend, let your agent experiment, review the diff, merge what works.
Teams and organizations
Invite teammates with roles. Every actor writes to the same change ledger.
Your backend repairs itself. Backenly checks it every minute, fixes what is safe on its own and holds risky changes for your approval.
An illustration of an example store backend: five tables on a platform. Backenly checks it every minute with a sheet of light that crosses every table. The orders table turns amber: a query on it is slow. Backenly adds the missing index on its own, checks again, and a green check confirms the fix. Then your coding agent sends a request to drop the carts table. It stops at a violet gate in front of carts and waits for your approval, with the table and its 1,284 rows untouched.
Your agent asks to drop the carts table. It waits for you, all 1,284 rows untouched.
An illustration, with an example store's tables.Your schema restructures itself. When a table starts doing two jobs, Backenly separates them once you approve, and your apps keep working.
An illustration of an example store backend. The orders table is drawn as a stack of column layers: graphite for its own columns and violet for three refund columns, a second job inside it. Changing those columns locks orders. Backenly rehearses moving them on a copy and rolls the copy back, then waits for your approval. Once you approve, a new order_refunds table is built beside orders, the refund columns are copied across and kept in step both ways, and new code can read order_refunds while your app keeps using orders. Nothing is removed from orders.
Old and new code both keep working. Nothing is removed, and undo stays available.
An illustration, with an example store's tables.Run close to your users. Five regions across three continents.
Backenly Cloud regions
Backenly Cloud runs in Mumbai, Frankfurt, US East, US West and Singapore. Self-hosted, Backenly runs wherever your servers do.
Questions before you trust us with production
Anything else, ask the people who built it.
One command installs the Backenly MCP server for Claude Code, Cursor, Codex, Cline, or any MCP host. The key is scoped and revocable from your project dashboard. There is also a CLI (npx @backenly/cli) for schema, generated types, CI diffs, logs, and read-only SQL, and a canonical agent skill at backenly.com/skill.md.
Dropping or emptying a table, dropping a column, deleting files and revoking keys do not run. Each parks as an approval request under “Waiting on you” in your dashboard, with the impact laid out (how many live rows, whether the data is recoverable), and waits for a person on the project to decide. The agent’s key can request and poll, never approve. Ordinary row inserts, updates and deletes run as normal.
Real infrastructure: an isolated PostgreSQL schema per project, live REST endpoints, auth with per-project secrets, file storage, and realtime streams. Schema changes are read back from the live database before they count as done, and the autonomy loop keeps monitoring and repairing the backend after you ship.
Yes. The entire platform is open source under Apache-2.0, including the autonomy engine, and the SDK, CLI, MCP server, and agent skill are MIT. Self-host everything on your own infrastructure, with your own Postgres. Or use Backenly Cloud, where we run the infrastructure and handle backups and upgrades. It is the same codebase either way, so you can move between the two.
Like Supabase, Backenly is open source, built on real PostgreSQL, and self-hostable. The difference is who operates it. Supabase and Firebase hand you excellent parts and leave the assembly, configuration, and upkeep to you. You are the operator. Backenly does not just generate resources; it manages backend change safely. Changes are planned, destructive ones wait for your approval, schema changes are read back from the live database, and a resident autonomy loop keeps fixing the running backend, with receipts, when no one is at the keyboard.
No. The contract is standard REST plus a typed SDK, and the database is standard PostgreSQL. Every plan, including Free, gets direct read-only and read-write connection strings (psql, TablePlus, any BI tool) and pg_dump exports that restore on any Postgres: RDS, Neon, your own server. And because the platform itself is open source, the exit path includes running Backenly on your own servers. Everything leaves with you, anytime.
Self-hosting is free under Apache-2.0: you bring the servers, and an AI provider key (Claude or OpenAI) only for the features that use a model, such as the natural-language build tools. The self-healing fixes themselves are rule-based. On Backenly Cloud, the Free plan is genuinely free, with no credit card, and includes a real, permanent backend plus the self-healing loop every minute. Pro is $25/month and raises capacity, not the self-healing, which is never capped on any plan; Enterprise is custom. Driving the backend from your own coding agent through the typed MCP tools is never metered as AI, and autonomy is included on every Cloud tier.
Oversight. The dashboard is where you inspect every table, user, file, and function; approve or reject destructive requests under “Waiting on you”; read the agent journal and autonomy receipts; manage keys, teams, and branches; and restore earlier versions from restore points. Your agent operates; you stay in command.
Give your agent a backend it can’t break
Connect Claude Code or Cursor in one command, ship real infrastructure today, and let autonomy keep it healthy tonight.