PostgreSQLOpen-Source · MIT · Jedes Postgres

Das Backend, das keine Berechtigungsprüfungvergessen kann.Lass den Agenten das Backend schreiben.Die Datenbank hält es ehrlich.Schreib die Collection.Rebase schreibt den Rest.Deine App bekommt die API.Dein Team bekommt das Panel.

Eine TypeScript-Datei pro Collection liefert dir das Schema, die REST-API, das typisierte SDK und das Panel. Die Zugriffsregeln in derselben Datei werden zu Postgres Row-Level Security kompiliert, sodass jede Route, jeder Job, jedes Skript und jeder Agent gegen dieselbe Wand läuft.

Eine TypeScript-Datei pro Collection ist alles, was ein Agent liefern muss. Schema, REST-API, typisiertes SDK und Panel werden daraus generiert, und die Zugriffsregeln darin werden zu Postgres Row-Level Security kompiliert. Was das Modell vergisst, vergisst die Datenbank nicht.

Schema, REST-API, typisiertes SDK, Panel und Zugriffsregeln kommen aus einer einzigen TypeScript-Datei und ändern sich mit ihr. Die Regeln werden zu Postgres Row-Level Security kompiliert, sodass das Backend, das du generiert hast, auch das ist, das durchgesetzt wird.

Eine TypeScript-Datei pro Collection erzeugt beides: die REST-API und das typisierte SDK, die dein Code aufruft, und das CMS, in dem dein Team arbeitet, mit denselben Policies. Nichts wird zweimal gebaut, und es gibt keine Hintertür an den Regeln vorbei.

Demo testen
zsh · ~/work

$ pnpm dlx @rebasepro/cli init

✔ Rebase im aktuellen Verzeichnis initialisiert.

✔ Schema in Datenbank übertragen. Tabellen erstellt.

✔ Zugriffsregeln zu Postgres-Policies kompiliert.

✔ API, Realtime und Panel laufen.

API- und Panel-URLs werden beim Start ausgegeben · rebase dev wählt freie Ports pro Projekt

$

Von den Machern von FireCMS, dem Open-Source-CMS in über 10.000 Firebase-Projekten.

DearDoc LogoMedicalMotion LogoProton HealthWithUSocial Income

01·Code as Truth

Eine Collection.
Alles generiert.

Eine einzige TypeScript-Datei pro Collection ist der gesamte Input. Das Datenbankschema, die REST API, das typisierte SDK, die Formulare und jede Admin-Ansicht entstehen daraus — und ändern sich mit ihr.

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 },
  },
};

→ erzeugt DB-Schema · REST-API · typisiertes SDK · Entity-Formulare · Admin-Views

02·Security first

In TypeScript geschrieben. Von Postgres erzwungen.

Row-Level Security, direkt in derselben TypeScript-Datei wie die Collection definiert, kompiliert in echte Postgres-Policies. Granular pro Collection, pro Feld, pro Rolle — und von der Datenbank selbst durchgesetzt, nicht von Middleware, an deren Aufruf man erst denken muss.

Wie die Sicherheit funktioniertBlogLesen: Die Sicherheit deines Backends sollte nicht davon abhängen, dass jemand daran denkt
Wo die Regel heute lebtcollections/orders.ts · eine Regel, in Postgres, auf jedem Weg
routes/orders.tsif (order.ownerId !== req.user.id) return 403;✓ checks
jobs/nightly-report.tsdb.select().from(orders) // every row✗ no check
scripts/backfill.tsdb.update(orders).set(…) // run once, kept forever✗ no check
agents/tools.tsconnect(URL, SERVICE_ROLE_KEY)✗ bypasses RLS
the hosted dashboardselect * from orders -- as the owner✗ no policy
securityRules: [
  { operation: "select", using: "owner_id = rebase.uid()" },
  { operation: "update", using: "owner_id = rebase.uid()" },
]
-- compiled into Postgres; enforced on every statement, for every caller
CREATE POLICY orders_select ON orders FOR SELECT USING (owner_id = rebase.uid());
-- a table with no policy is not served at all
routes/orders.tsrebase_user→ policy applies
jobs/nightly-report.tsrebase_user→ policy applies
scripts/backfill.tsrebase_user→ policy applies
agents/tools.tsscoped key→ policy applies
the panelrebase_user→ policy applies

Glaub uns das nicht einfach.

rls-check liest den Katalog deiner eigenen Datenbank und meldet, was tatsächlich offen liegt — Tabellen, die mit abgeschalteter Row-Level Security ausgeliefert werden, Policies, die für jeden wahr sind, Views, die an der RLS ihrer Basistabellen vorbeilesen. Fünfzehn Checks. Jedes Postgres: Supabase, Neon, RDS, dein eigener Server. Es liest nur, braucht keinen Account, und es ist ihm egal, ob du Rebase benutzt.

Alle 15 Prüfungen ansehen
npx @rebasepro/rls-check

SELECTs auf die Systemkataloge und sonst nichts. Keine Telemetrie, kein Upload, und deine Daten liest es nie.

03·Was du bekommst

Alles, was deine App aufruft — und das Panel, in dem dein Team arbeitet.

Ein typisiertes SDK für deine Collections, REST für jede Tabelle und Realtime über WebSocket, ab Minute eins auf deiner Datenbank.

app.ts — typisiert aus deinen Collectionslive · try it
1
2
3
import { createRebaseClient } from '@rebasepro/client';
 
const data = await client.data.
TypeScriptUTF-8Ln 3, Col 1
REST, über jede Tabellelive · 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
your app — 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

Dazu Auth und Rollen, S3-kompatibler Storage, geplante Jobs, Serverless Functions und Backups, alles unter denselben Policies.

Backend erkunden

Das Panel, erzeugt aus derselben Definition.

Es liest deine Daten über dieselbe API und dieselben Policies wie deine App. Deine App spricht mit dem Backend, dein Team arbeitet im Panel, und beide sehen dieselben Regeln.

Womit deine App spricht

Rebase Backend

Der Server, den deine App aufruft: REST, ein typisiertes SDK, Realtime, Auth und Storage über deinem eigenen Postgres.

@rebasepro/server

Wo dein Team arbeitet

Rebase CMS

Tabellen-Editing, Medien, Relationen, Rollen und Workflows — mit deinen eigenen React-Komponenten überall dort, wo das Standardfeld nicht reicht.

@rebasepro/cms

Die Entwicklerhälfte des Panels

Rebase Studio

SQL-Editor, Schema-Visualisierung, RLS-Policy-Editor, Logs und API-Explorer. Studio ist die Entwicklerhälfte desselben Panels, das dein Team ohnehin schon nutzt.

@rebasepro/app

Rebase CMS ansehen

04·Gebaut für das Zeitalter der Agenten

Das Backend, das ein Agent nicht ruinieren kann.

Ein KI-Agent kann in einer Stunde ein Backend hochziehen. Ob dieses Backend sicher ist, kann er dir nicht sagen. Agenten sind hervorragend darin, plausible Backends zu produzieren — und notorisch schlecht darin, sichere zu bauen. Rebase macht das sichere Ergebnis zum einzig möglichen, per Konstruktion.

KI- und Agent-Funktionen ansehen
agent · what it can reach

A surface an agent can hold

A whole backend is a handful of typed collection files. No controllers, no serializers, no migrations to hand-write — the whole contract fits in one context window, and the compiler checks whatever the model writes back.

config/collections/orders.ts
export const orders: PostgresCollectionConfig = {
table: "orders",
properties: { total, status, customer },
securityRules: [{ operation: "select", … }],
};
→ REST · typed SDK · RLS policies · admin views
1 file per collectionfits in one context windowcompiler-checked

05·Gebaut für echte Produkte

Sieben Produkte. Eine Definition.

Ein zertifiziertes Medizinprodukt, ein Retail-Loyalty-Programm, ein zweiseitiger Marktplatz, offene Daten, ein Outbound-Sales-Agent, ein Design-Tool und ein CRM — sehr unterschiedliche Produkte, dieselbe Collection-Datei darunter.

medicalmotion.com
MedicalMotion running at medicalmotion.com

Digitale Schmerztherapie

MedicalMotion

Ein zertifiziertes digitales Medizinprodukt für KI-personalisierte Schmerztherapie. Rebase betreibt das komplette Backend — Patientendaten, Therapiepläne, die Übungsbibliothek und die klinischen Dashboards darüber.

medicalmotion.com
unfeignedgear.com
Unfeigned running at unfeignedgear.com

Retail-Loyalty

Unfeigned

Das Loyalty-Programm einer Modemarke. Bestellungen aus Odoo POS und Shopify landen in Postgres, eine Tier-Engine berechnet Punkte und Rabatte neu, und die Apple- und Google-Wallet-Pässe, die an der Kasse gescannt werden, entstehen aus demselben Schema.

unfeignedgear.com
sustentalent.com
SustenTalent running at sustentalent.com

Marketplace & Jobportal

SustenTalent

Ein zweiseitiger Marktplatz, der Nachhaltigkeits-Profis mit grünen Unternehmen verbindet. Rebase treibt beide Seiten an: rollenbasierte Auth, typisierte Matching-APIs und das Moderations-Backoffice.

sustentalent.com
dadaki.com
Dadaki running at dadaki.com

Vektor-Design-Tool · Vom Rebase-Team gebaut

Dadaki

Unser eigenes Produkt: ein schneller Vektor-Editor im Browser mit Cloud-Sync. Dadaki läuft auf einem völlig normalen Rebase-Backend — dieselbe Auth, derselbe Storage, dieselben generierten APIs wie in jedem Projekt.

dadaki.com
presupuestos.rebase.website
A dónde va el dinero de España running at presupuestos.rebase.website

Offene Daten · Vom Rebase-Team gebaut

A dónde va el dinero de España

Eine öffentliche Aufschlüsselung der spanischen Staatsausgaben, von 725 Mrd. € bis zur einzelnen Haushaltszeile. Im Lesepfad liegt keine Datenbank: Ein Cron kompiliert die offiziellen Zahlen monatlich neu, Storage liefert sie als JSON aus, und die Seite macht keinen einzigen API-Aufruf.

presupuestos.rebase.website
prospector.rebase.website
Prospector running at prospector.rebase.website

KI-Vertriebsagent · Vom Rebase-Team gebaut

Prospector

Ein Agent, der deine Website liest, Zielgruppen plant und echte Unternehmen samt den Menschen dahinter findet — jedes gegen die eigene Website verifiziert. Crons, Functions und das Review-Board sind Rebase von der Stange. Er entwirft; das Schema kennt keinen Zustand, in dem er versendet.

prospector.rebase.website
internal · edith
Stale deal follow-upenabled
cron_trigger
every weekday · 08:00
conditional_switch
last_activity > 14 days
delay
2 hours
create_taskadd_tagcreate_activity
last run 08:00 · 12 items · 0 errors

Internes Tool · CRM und Workflow-Automatisierung

Edith

Ein CRM, das das Team ohne Deploy umbauen kann: Pipelines, Tags, Aufgaben und ein Automatisierungs-Canvas, dessen Trigger, Verzweigungen und Aktionen allesamt Zeilen in Postgres sind. Dreiundzwanzig Collections erzeugten das komplette Back Office; keine einzige Admin-Oberfläche wurde geschrieben.

Internes Tool — keine öffentliche Website

01/07

Verbinde es mit deiner Datenbank.

MIT-lizenziert, von A bis Z. Deine Daten bleiben in deinem Postgres: keine Abhängigkeit von einem Anbieter, kein Per-Seat-Pricing, und der Ausstieg ist ein Redeploy.

Für EntwicklerIm Vergleich

Lokal ausführen

Ein Befehl gegen dein bestehendes Postgres. Kein Account, kein Container-Pull, keine Registrierung.

pnpm dlx @rebasepro/cli init
Quickstart

Selbst hosten

Docker, Fly, Railway, Hetzner oder Bare-Metal. Deine Daten bleiben in deiner Infrastruktur und erreichen uns nie.

docker compose up -d
Deployment-Guides

Rebase CloudPrivate Beta

Managed Hosting auf unserer Infrastruktur. Sie betreibt heute echte Tenants und öffnet in Wellen.

Zugang anfragen
Demo testenDocs lesen