Database diagrams that live in your repo.

Design your schema in the browser. ERDone commits every change as JSON to a GitHub repo you own — versioned, diff-able, yours forever.

Try it free See pricing

No signup required to try the local-only editor.

Generate SQL for the database you're shipping to.

ERDone supports the eight databases most engineering teams actually use — from classic relational to modern cloud warehouses. Or skip the choice up front with Pick later mode and decide when you're ready.

SQL Server
PostgreSQL
Oracle
MySQL
MariaDB
SQLite
Snowflake
Redshift

Built for the database, not just the diagram.

Pair with Claude on your schema design

A second set of eyes on the design — not the syntax.

Click Pair with Claude and Claude reviews how your schema is modeled: a table that should be split, a missing index on a column you join on constantly, a relationship pointing the wrong way round, naming that won't age well. Each finding is a card you can jump straight to, act on, or dismiss — dismiss it and it stays gone. It's a review, not a rewrite: you decide what changes. The deterministic checks still own syntax and dialect correctness; Pair with Claude reviews the modeling underneath. On Pro and Team.

Designed for your database, not against it

The dialect is part of the diagram, not an afterthought.

Pick your target — SQL Server, Postgres, Oracle, Snowflake, and more — and the editor adapts to it. CLUSTERED indexes show up for SQL Server. IDENTITY matches your dialect's syntax. No lowest-common-denominator schema, no translation step — the DDL runs as written.

From diagram to migration script

Diff against what's deployed. Save a migration. Ship.

Each diagram carries a baseline of what's currently deployed. Edit, then Generate Migration emits dialect-aware ALTER / DROP / CREATE that diffs your design against that baseline — Postgres' ALTER COLUMN, MySQL's MODIFY, T-SQL's named DF_ defaults, all native. Views ride along — add or drop one and the migration carries its CREATE / DROP VIEW. Save to repo writes a timestamped file your CI can pick up — Flyway, dbmate, sqlx, golang-migrate, and Atlas all work. Stable column IDs make rename detection exact, so you don't get a DROP + CREATE when you meant a RENAME.

Catch it before its deploys

Diagram Health validates your schema while you draw it.

Missing PKs, FK type mismatches, identity on non-integer columns, reserved-word collisions, FKs without a covering index — caught inline as you draw, with one-click Fix on the four most common (FK index, FK type mismatch, same-name-no-FK, {Table}Id-not-linked). It also catches foreign-dialect syntax — SQL Server brackets or a MySQL backtick that slipped into a Postgres diagram — before it turns into a broken migration. Warnings flag the mistakes that compile cleanly and break in production. No more shipping a schema and finding out at deploy time.

Indexes and relationships, modeled like your database thinks

Crow's-foot semantics in the diagram, native DDL on output.

Crow's-foot cardinality (Many / At-least-one / Optional / Exactly one). Composite indexes with INCLUDE, WHERE, UNIQUE, CLUSTERED. Parent-required auto-syncs the FK column's NOT NULL — no hand-tracked invariants. Foreign keys emit as ALTER … ADD CONSTRAINT after the CREATEs, so cyclic dependencies don't bite.

Round-trippable across 8 dialects

Import any SQL. Edit visually. Generate clean DDL. Repeat.

Paste any SQL — SQL Server, Postgres, Oracle, anywhere — and ERDone parses it into a diagram. Choose Merge to add to your existing design, or Replace All to seed a fresh baseline from a pg_dump. Auto-detects the source dialect; translates types in place: JSONB → NVARCHAR(MAX), SERIAL → INT, BYTEA → VARBINARY(MAX). Round-trip a legacy schema, refactor it visually, ship clean DDL.

Build SQL views visually — the SELECT writes itself

Pick columns from your tables; the query writes itself — and round-trips to SQL and back.

Add a view to your diagram, pick the columns you want from your tables, and ERDone writes the SELECT for you. It reads your foreign keys to work out the joins — even across tables that aren't directly related, by walking the shortest path between them — and quotes WHERE values correctly for each column's type, so you're not hand-writing JOIN … ON or remembering which literals need quotes. It goes both ways: your views land in the SQL ERDone generates and in your migration scripts as CREATE [MATERIALIZED] VIEW — materialized where your dialect supports it — and pasting an existing CREATE VIEW turns it back into a view you can edit. Anything it can't model — a SELECT *, a vendor-specific bit of syntax — it keeps verbatim as a read-only view instead of choking on the import. Round-trip, nothing lost. Layers keep it readable: group tables and views into named, color-coded layers you can toggle on and off — including a one-click toggle to hide every view at once when you want to see just the schema.

Your repo is the database

Diagrams as files. Saves as commits. Reviews as PRs.

Connect a GitHub repo and every save commits one folder per design as JSON — versioned, diff-able, reviewable in a PR. Teammate commits push into your editor within seconds, no polling. Cancel and the files stay where they are; nothing on our side holds them hostage. The tool can disappear; the schema can't.

Simple pricing. No seat-counting games.

Start free. Upgrade when you want your diagrams in a real repo.

Free

Trying it out, single throwaway diagrams.

Open the editor

Pro

Team

$12 /mo

Teams collaborating on a shared schema.

Start 14-day free trial

Compare every feature

Get your schema out of a SaaS silo.

Open the editor, sketch a few tables, and see what it feels like to own your diagrams.

Try it free