SchemaCanvas
Sign inStart free

Database design, end to end

Your database schema, in code and on canvas.

Write the schema as text or drag tables around on the canvas — every edit flows both ways, instantly. Then point SchemaCanvas at your real PostgreSQL, MySQL or SQL Server database to see exactly where it has drifted, and generate the migration that closes the gap.

Start free Try it now — no account

Private diagrams, version history and visual organisation are free. No credit card.

orders schemaAll changes savedtable users #4f5df0 { id int key auto email varchar! unique created_at timestamp}table orders { id int key auto user_id int! -> users.id status order_status total decimal(10,2)}enum order_status { pending shipped}-- cardinality is derivedusersidPKemailvarcharcreated_attimestampordersuser_idFKstatusenumtotaldecimal+ columnproductsidskuin sync
3SQL dialects out
6ways to import in
12design checks, free
24starter templates
100%self-hostable

The difference

Most tools make you pick a side. We don't.

Code-first tools give you precision and version control, but you cannot drag a box. Diagram-first tools are approachable, but the output is not something you can review in a pull request.

SchemaCanvas treats the text and the drawing as one artefact. Rename a table on the canvas and the code updates. Paste in a schema and the boxes appear. There is no import step, no export step, no drift between the two.

  • Every feature works from both the code pane and the canvas
  • Comments, spacing and unrecognised blocks survive untouched
  • Undo spans both surfaces in one history
  • Positions live outside the schema text, so your file stays portable
CodeCanvasonly the edited blockis rewritten

Connected to the real thing

A diagram that knows what your database actually looks like.

A diagram is worthless the moment it stops matching production. So SchemaCanvas reads your live database — PostgreSQL, MySQL or SQL Server — and shows you the difference in colour, on the canvas.

Then it writes the migration. Dialect-correct, with the destructive statements commented out by default and anything it cannot resolve mechanically flagged for a human. It is a reviewed starting point, never a blind-apply script.

  • Read-only introspection — the connection string is used once and never stored
  • Drift shown as green, amber and red directly on the diagram
  • Migrations from a past version, or from your live database
  • Twelve design checks running as you type — no gate, no upsell
Live databaseYour diagram+ 2 tables~ 1 modified− 1 droppedALTER TABLEordersADD COLUMNtotal-- DROP commented

Everything in one place

The whole schema workflow, not a slice of it

Design, document, review and ship — without stitching three products and three subscriptions together.

Two-way editing

Code and canvas, always in step. Rename, connect, restructure — from whichever side suits the moment.

Live database sync

Introspect PostgreSQL, MySQL or SQL Server. Spot drift on the canvas. Generate the migration that closes it.

Visual diff

Compare any version against today. Added, modified and removed tables drawn in colour, with a plain-English change list.

Schema linter

Twelve deterministic checks — missing keys, type mismatches, unindexed foreign keys, duplicate tables, impossible sizes — running live as you type.

Version history

Automatic snapshots as you work, one pinned every time you save, labelled ones when it matters, and a safe restore that snapshots first.

Share & embed

A read-only link for anyone, revocable in a click, plus an iframe snippet for Notion, Confluence or your own docs.

CLI & REST API

Pull and push schemas from CI, mint scoped API tokens, and fire webhooks when a diagram changes.

Built for review

Even the people who can't edit get a say.

Give a stakeholder view access and they can still restructure the diagram freely — nothing saves. When they are happy, they submit it as a change proposal, and an editor reviews it as a visual diff before merging.

Presence chips show who else is in the room, edits sync live, and comment threads anchor to the table they are actually about.

  • Workspaces with owner, editor and viewer roles — invite teammates by email
  • Threaded comments pinned to tables, with @mentions
  • Real-time presence and live sync
  • Merging snapshots first, so accepting is always reversible
ARJLMKJamie@adilshould status be an enumrather than a varchar here?2

One product, one price

Free where it counts

Most schema tools split diagrams, documentation and history into separate products — or make your work public unless you pay. We think the basics should just be there.

SchemaCanvas

  • ✓ Private diagrams from the start
  • ✓ Version history and visual diff
  • ✓ Schema documentation included
  • ✓ Colours, groups, notes and views
  • ✓ Schema linter included, no upsell
  • ✓ Import from SQL, Prisma, EF Core, dbdiagram.io, QuickDBD or a live database
  • ✓ Self-host with Docker whenever you want

Typical code-first tools

  • — Free tier often forces diagrams public
  • — History behind a paid plan
  • — Docs sold as a separate product
  • — Code-first only, no canvas editing
  • — No connection to your real database
  • — Limited import formats
  • — Hosted only

Already have diagrams?

Bring them with you.

Copy the code out of dbdiagram.io or QuickDBD and paste it in. The format is recognised for you, converted, and drawn — tables, keys, relationships and notes — so moving across takes a minute rather than an afternoon of retyping.

  • No need to know what your format is called — paste, and it is recognised
  • Relationships always arrive pointing the right way, whichever way they were written
  • Anything with no equivalent here is listed after the import, never quietly dropped
  • A script or schema exported from here imports back as the same design — SQL, Prisma or EF Core
  • Works in the playground, with no account
Import from dbdiagram.ioImport from QuickDBD
What you pasteuser_id int [ref: > users.id]user_id int FK >- users.idorWhat you getuser_id int! -> users.idone way to write itand on the canvas

Secure by construction

Sessions live in cookies no script can read, every state-changing request is CSRF-checked, and outbound features cannot be aimed at internal networks.

Your credentials stay yours

Database connection strings are used for a single read-only request. Never persisted, never logged, never reused.

Run it yourself

A Docker Compose stack ships with the product. Keep the whole thing inside your own network if that is what compliance needs.

Start with a blank canvas — or your existing database.

Paste your DDL, connect a live instance, or open the playground and draw something. It takes about a minute either way.

Create your free accountOpen the playground