PostgreSQLOpen-source · Deploy anywhere · Postgres-native

The Postgres you already have.The backend you always wanted.

Point it at the database you already run. Nothing to provision, nothing copied, nothing migrated — your schema is the only input.

zsh · ~/work

$ pnpm dlx @rebasepro/cli init

✔ Initialized Rebase in current directory.

✔ Schema pushed to database. Tables created.

✔ Admin panel, API, and WebSocket server running.

API on :3001 · panel on :5173

$

DearDoc LogoMedicalMotion LogoProton HealthWithUSocial Income

01·Code as Truth

One collection.
Everything generated.

One TypeScript file per collection is the entire input. The database schema, the REST API, the typed SDK, the forms and every admin view come out of it — and change with it.

Code as Truth
App Code — products.ts
import type { PostgresCollectionConfig }
  from "@rebasepro/types";

export const products: PostgresCollectionConfig = {
  name: "Products",
  slug: "products",
  table: "products",
  properties: {
    name: {
      name: "Name",
      type: "string",
      validation: { required: true },
    },
    category: {
      name: "Category",
      type: "string",
      enum: {
        electronics: "Electronics",
        fashion: "Fashion",
        home: "Home & Garden",
      },
    },
    price:     { name: "Price", type: "number" },
    in_stock:  { name: "In Stock", type: "boolean" },
    image_url: { name: "Image", type: "string", url: true },
  },
};

→ generates Admin views · forms · DB schema · REST API · Typed SDK

02·What your app talks to

The whole backend, already running.

A typed SDK for your collections, REST over every table, and realtime on a WebSocket — plus auth, storage and backups, running against your database from minute one.

app.ts — typed from your collectionslive · try it
1
2
3
import { createRebaseClient } from '@rebasepro/client';
 
const data = await client.data.
TypeScriptUTF-8Ln 3, Col 1
REST, over every tablelive · send a request
Endpoints
GET/api/data/users
POST/api/data/users
GET/api/data/posts
PUT/api/data/posts/:id
DEL/api/data/posts/:id
Ready
Response
Send a request...
Realtime — LISTEN/NOTIFYlive
localhost:5173 — web
name
status
upd
Alice
pending
2m ago
Bob
active
5m ago
Carol
inactive
1h ago
Dave
active
12m ago
ws
live
admin panel
name
status
upd
Alice
pending
2m ago
Bob
active
5m ago
Carol
inactive
1h ago
Dave
active
12m ago
Both clients subscribed to users…ws://localhost:3000/realtime

Plus auth and roles, S3-compatible storage, scheduled jobs, serverless functions and backups — all against the database you already own, under the same policies.

Explore the backend

03·Security-first

Written in TypeScript. Enforced by Postgres.

Row-level security written in the same TypeScript file as the collection, compiled into real Postgres policies. Granular per collection, per field, per role — and enforced by the database itself, not by middleware someone has to remember to call.

studio · row-level security
Tables
public
auth
public.usersRLS ENABLED
users_read_ownSELECT
Live
USING:rebase.uid() = id
Roles:public
users_update_ownUPDATE
Live
USING:rebase.uid() = id
CHECK:rebase.uid() = id
Roles:public
admin_manage_usersALL
Live
USING:auth.role() = 'admin'
Roles:admin

Don't take that on faith.

rls-check reads your database's own catalogue and reports what is actually exposed — tables served with row-level security switched off, policies that evaluate to true for everyone, views that read straight past the RLS on their base tables. Fourteen checks. Any Postgres: Supabase, Neon, RDS, your own server. It is read-only, it needs no account, and it does not care whether you use Rebase.

See all 14 checks
npx @rebasepro/rls-check $DATABASE_URL

SELECTs against the system catalogues and nothing else. No telemetry, no upload, and it never reads your data.

04·One definition, either half

Take only the half you actually need.

The panel reads your data through the same API and the same policies your app does. Ship headless today and add it the day a human needs to touch the data — or never. Whichever half you leave out, the API answers exactly the same.

What your app talks to

Backend

REST, auth, storage, realtime and backups over your database. No UI, no React anywhere in the dependency tree.

@rebasepro/server

Where your team works

Admin panel

Spreadsheet editing, media, relations, roles and workflows — with your own React components dropped in wherever the default field isn't enough.

@rebasepro/cms

Developer tools, inside the panel

Studio

SQL editor, schema visualizer, RLS policy editor, logs and API explorer — registered as extra views inside the panel.

@rebasepro/app

05·Your workflow

Every view. Zero code.

The same Postgres rows as a data grid, cards, a list or a Kanban board. Switch layouts on the fly, filter live, edit inline — without building a single admin screen.

admin.yourdomain.com
Explore the admin panel

06·Who touches it

Three people touch this. None of them the same way.

The developer who owns the database

Writes one collection file and gets a schema, REST, an SDK and policies. Mostly stays in the editor — and when a question is faster to answer in SQL, opens Studio rather than a second tool.

The backend Studio

The operator who lives in the panel

Fixes a wrong address, refunds an order, moves a card. Did not choose Rebase and will not read its docs — the panel answers to them.

The admin panel

The agent holding a scoped key

Reads and writes through the same API under the same policies as the humans. A first-class caller, not an integration.

AI & agents

07·Built for the agent era

The backend an agent can't screw up.

An AI agent can scaffold a backend in an hour. It can't tell you whether that backend is safe. Agents are extremely good at producing plausible backends — and famously bad at producing secure ones. Rebase makes the safe outcome the only outcome, by construction.

Explore all AI & Agent features
agent · what it can reach

Vector similarity search

Native pgvector with cosine, L2 and inner-product distance. Query embeddings straight over REST — no separate vector database to run.

GET /api/data/docs
GET /api/data/docs
?vector_search=embedding
&vector=[0.12, 0.98, …]
&vector_distance=cosine
200 OK · 14ms
[{ "id": "d_91", "score": 0.94 }, …]
pgvectorcosine · L2 · inner productno extra service

08·Built for real products

Teams ship faster with Rebase

From marketplaces to retail loyalty, public data and internal tools — seven very different products, the same definition underneath.

Roadmap

What's next for Rebase

The changelog is the record. Here is what is being built next.

Now

Available
Postgres introspection & auto-CMS
Isomorphic TypeScript SDK
Instant REST APIs
Row-Level Security (RLS)
Realtime engine — subscriptions, broadcast channels, presence
Table, List, Kanban & Gallery views
Auth and roles system
Backend crons and functions
Native S3 compatible storage
Offline & local-first sync — local database, queued writes, live queries

Next

In Progress
AI SQL generation in editor
Hosted Rebase Cloud infrastructure
Multiplayer cursors in Studio
One-click vector embeddings

Later

Planning
Conversational analytics & charts bot
Text-to-Schema AI generation
Edge functions / Serverless logic
Advanced migration pipelines
MongoDB support

Point it at your database.

Run it locally

One command against the Postgres you already have. No account, no container to pull, nothing to sign up for.

pnpm dlx @rebasepro/cli init
Quickstart

Self-host it

Docker, Fly, Railway, Hetzner or bare metal. Your data stays in your infrastructure and never reaches us.

docker compose up -d
Deployment guides

Rebase CloudNot launched yet

Managed hosting. We run our own products on it first — early access goes out from the waitlist, oldest first.

no command yet
Join the waitlist