Design, version and review your Postgres schema together.

DBA as a service for Postgres teams. Keep every version, compare any two, design the next one live.

Request access Sign in

romulus never connects to your database.

acme/ billing/ add-invoices from v12

ASL Publish v13

schema.sql JSON DBML Mermaid

Compiling Compiled

1CREATE TYPE invoice_status AS ENUM
2  ('draft', 'open', 'paid', 'void');
3
4CREATE TABLE customers (
5  id    uuid PRIMARY KEY,
6  email text NOT NULL,
7  name  text NOT NULL
8);
9CREATE INDEX customers_email_idx
10  ON customers (email);
11
12CREATE TABLE invoices (
13  id          uuid PRIMARY KEY,
14  customer_id uuid NOT NULL REFERENCES customers,Ada
15  status      invoice_status NOT NULL,
16  total_cents bigint CHECK (total_cents >= 0),
17  issued_at   timestamptz
18);
19
20COMMENT ON COLUMN invoices.total_centsLin
21  IS 'Sum of the lines, in cents';
22
23CREATE TABLE invoice_lines (
24  id          uuid PRIMARY KEY,
25  invoice_id  uuid NOT NULL REFERENCES invoices,
26  description text NOT NULL,
27  amount      numeric(12, 2) NOT NULL
28);
29
30CREATE TABLE payments (
31  id         uuid PRIMARY KEY,
32  invoice_id uuid NOT NULL REFERENCES invoices,
33  amount     numeric(12, 2) NOT NULL,
34  paid_at    timestamptz DEFAULT now()
35);

Graph

4 tables, 1 enum

customers

idPKuuid

emailtext

nametext

invoicesA

idPKuuid

customer_idFKuuid

statusinvoice_status

total_centsbigint

issued_attimestamptz

payments

idPKuuid

invoice_idFKuuid

amountnumeric

paid_attimestamptz

invoice_statusenum

draft

open

paid

void

invoice_lines

idPKuuid

invoice_idFKuuid

descriptiontext

amountnumeric

Sam

Every version kept. Any two compared.

Each upload, CI push and published draft becomes a version that can't be edited afterwards. Pick any two to see what changed, as a list, on the graph and in SQL.

Diffs of the schema itselfA column that became NOT NULL shows up. Reformatting the SQL shows nothing.
A history nobody rewritesEach version records who made it and where it came from.

Versions

v14Pushed from CImain, 2 hours agoto

v13add-invoicesAda, yesterday

v12Uploaded SQLSam, Oct 9from

v11Pushed from CImain, Oct 2

v12 v14 5 added1 changed1 removed

Addedenum invoice_status
Addedtable invoices
Addedtable invoice_lines
Addedtable payments
Addedpolicy invoices_by_org on invoices
Changedcolumn customers.email text → citext
Removedindex customers_email_idx

Design the next version together.

A draft is a branch of your schema the whole team can open at once. Type SQL or work on the graph; both edit the same draft, and everyone's cursor shows in both.

Checked by Postgres as you typeEach change compiles in a real Postgres sandbox, and errors point at the line that caused them.
Edit on the graph, get SQLRename, add or drop tables and columns, or draw a foreign key, and romulus writes the statement.
Publish in one stepIf a new version landed first, Update draft merges statement by statement and leaves you only the real conflicts.

Update draft v14 was pushed while you worked1 conflict

4CREATE TABLE customers (
5  id    uuid PRIMARY KEY,
6  email citext NOT NULL UNIQUE,from v14
7  name  text NOT NULL
8);
Yours
9CREATE UNIQUE INDEX customers_email_idx
10  ON customers (email);
v14, pushed from CI
Dropped this index
Keep mineKeep theirs

Publishing waits until every conflict is resolved.

Push the real schema from CI.

remus, the open-source twin of romulus, reads your database's catalog inside your own pipeline and sends the result. romulus never sees a connection string or a row of data.

Push on every runWhen nothing changed, the push answers 200 unchanged and the history stays clean.
Tokens with one jobA push token belongs to one database and can only push.

In CI, after your migrations

remus -u "$DATABASE_URL" -f json \  | curl -fsS --data-binary @- \      -H "Authorization: Bearer $ROMULUS_TOKEN" \      -H "Content-Type: application/json" \      "$ROMULUS_URL/api/databases/$ROMULUS_DATABASE_ID/versions"

201Created v143 changes since v13

200Unchangednothing new to keep

Postgres, down to the last policy.

romulus keeps what the Postgres catalog says, with remus's model. Drafts compile in PostgreSQL 17, so the graph shows what Postgres accepted.

ENUMEnums, with their values in order
DOMAINDomains, with their base type and checks
PARTITION BYPartitioned tables, partitions kept under their parent
CREATE POLICYRow level security policies and their roles
GENERATEDIdentity and generated columns
CHECKCheck, unique and exclusion constraints
WHEREPartial and expression indexes
COMMENT ONComments on tables and columns, shown on the graph
CREATE VIEWViews, with the tables they read
citext[]Arrays and composite types

Roles, functions and extensions your SQL uses without creating are stubbed for the compile, and never reach your model.

Roles that match how teams review.

Each organization has three roles. Reviewers see every version and follow drafts live without editing them; their cursor stays visible, so you know who's looking.

Read-only, enforced by the serverA reviewer's edits are dropped before they reach the draft.
Single sign-on, invite linksAn invitation works once, and only for the verified email it was made for.

What each role can do
Permission	Admin	Developer	Reviewer
Read versions and diffs
Follow drafts live
Edit drafts and publish
Upload, push tokens
Create and delete databases
Invite and manage members

Questions

Something else? Write to us.

What does “DBA as a service” mean here?

romulus does the schema work a DBA would keep for a team: it keeps every version, shows exactly what changed, checks each proposal in real Postgres before anyone publishes it, and gives everyone one place to design and review the next change.

Does romulus connect to our production database?

No. You upload SQL, or remus reads your database inside your own CI and pushes the schema. romulus never holds a connection string and never sees your data.

Does it replace our migrations?

No. Keep your migration tool; romulus versions the schema it produces. Push the result from CI after each run, and use drafts to agree on what the next migration should do.

Which is the source of truth, the SQL or the graph?

The SQL. Edits on the graph are written back as SQL statements, so the text is always what gets compiled and versioned. Table positions and groups are saved next to it.

Which Postgres versions does it understand?

Drafts compile in a PostgreSQL 17 sandbox, and pushes from remus carry whatever your own server's catalog says. Enums, domains, partitions, policies and generated columns all come through as themselves.

How do people sign in?

With single sign-on. An admin invites teammates with a one-time link, which only works for the verified email address it was made for.

What does it cost?

Nothing during early access, since there is no billing yet. Request access and we'll set up your organization.

Bring the schema you have.

Upload your SQL or push it from CI. That becomes version 1, and your team can open the first draft on it right away.

Request access Sign in