See exactly what changed in your schema before you migrate.

Paste the before and after schemas — every added, dropped and renamed table and column, every type change, each flagged breaking, caution or safe. Checked entirely on your device.

  • Your schema data never leaves the device
  • DDL or simple list · up to 5 files
  • Risk flag on every change
  • Markdown migration report

Paste your before and after schemas

SQL DDL (CREATE TABLE, CREATE INDEX, ALTER TABLE … ADD COLUMN) or a simple list — one line per table, for example “users: id INT PRIMARY KEY, email TEXT NOT NULL”. pg_dump --schema-only and mysqldump --no-data output paste straight in.

Try a sample:
Choose a side first, then drop .sql files below.

Drag & drop .sql files here

or browse your files · up to 5 files, 5 MB each

Compared in your browser — both schemas are parsed and diffed with a plain-English reason for every risk flag. Nothing is uploaded.

    No text or files yet. Everything stays on this device. Reports download instantly.

    Privacy you can verify, not just trust

    Your schema describes your product — which tables you keep, which columns hold what, how your data is shaped. Sending it to a hosted diff service means handing that map to a stranger’s server. This one can’t: your text and files are parsed and compared entirely in your browser. Your schema data never leaves the device — the only third-party requests are the site’s own analytics, which count page views — and it uploads nothing, ever. There is no file fetched after load for the comparison itself. Don’t take our word for it:

    New cross-origin requests during use: 0
    1. Press F12 to open developer tools, then the Network tab.
    2. Compare two schemas above. Watch: apart from the site’s analytics, nothing new is requested — no uploads, and no schema data ever leaves your device.
    3. Extra credit: disconnect your internet after this page loads — comparing still works.

    How to review a database schema change without uploading it

    A schema change is the most dangerous line in a pull request: one dropped column deletes a table’s worth of data, one narrowed type rejects rows that used to fit, one NOT NULL added to a column with NULLs fails the whole migration halfway through. The diff in your Git client shows you the text that changed — it does not tell you which of those changes will hurt.

    This tool reads the change where it already is: on your own device. When you paste the before and after schemas, your browser:

    1. Parses both schemas — CREATE TABLE statements from PostgreSQL, MySQL, SQLite or SQL Server, plus CREATE INDEX and ALTER TABLE … ADD COLUMN, or a simple table and column list if you would rather not paste SQL.
    2. Diffs them structurally — tables and columns added, dropped and renamed, type changes (widening versus narrowing), nullability, defaults, UNIQUE constraints, primary keys, foreign keys and indexes.
    3. Flags the risk of every change — breaking, caution or safe, each with a plain-English reason — and draws a before and after diagram for every changed table, so a reviewer sees the change as a picture, not a wall of SQL.

    What makes this visualizer different

    The established schema-diff tools are either command-line programs you install — pg-schema-diff, Liquibase, Flyway, DBeaver’s schema compare — or hosted services that take your schema onto their server. The free browser tools that do exist show a list of differences: one lists added and removed columns, another generates ALTER statements, a third draws an ER diagram of a single schema. None of them, as far as we could find, combine all three things a reviewer actually needs on one page: a visual before and after diagram of the change itself, a risk flag on every single change with a plain-English reason, and a rename guess that says so honestly instead of reporting a drop plus an add. This page is that combination — free, fully client-side, no install, no account, no upload, with a live network-request counter so you can verify the privacy claim yourself.

    When is visualising the right choice — and when is it the wrong one?

    Visualising is right before a migration ships, when a pull request changes a schema and a reviewer needs to see what will break, and when you inherit a database and want to know what changed between two versions. It is the wrong choice as a substitute for testing the migration: a report that says “safe” does not mean the migration will run — test it on a copy of the database first. It is also the wrong choice for data problems: this tool compares structure only, so it cannot tell you whether a type change will fit your actual rows.

    Honest limitations

    Heuristic parsing, not a full parser

    The parser covers common DDL from the big four dialects. Unusual syntax — dialect-specific extensions, stored procedures, triggers, views — is reported as a parser note rather than guessed. If a table is missing from the report, check the notes first.

    Renames are guesses

    A removed column and an added column with the same type and a similar name are reported as a possible rename. The tool cannot know whether you renamed the column or dropped one and added another — and the two have very different consequences for your data.

    It never writes migration SQL

    The report lists what changed and why it matters. Writing the migration is your job, or a migration tool’s — and it must be tested on a copy before it touches production. Never run generated SQL against a live database without review.

    It never sees your data

    Only the structure is compared. A type change the tool calls “widening” can still fail if your rows do not fit the new type, and a NOT NULL addition the tool calls breaking can pass if no row has NULL. The data decides; the report only flags the risk.

    No live database, ever

    The tool reads pasted text and dropped files only. It cannot compare a live database with a file, catch drift from a hotfix applied by hand, or see what is actually running. Export the schema first, then paste it.

    Risk flags are judgement

    Breaking, caution and safe are this tool’s judgement, documented openly on the page. A team with different risk tolerance may reasonably score the same change differently — the flag is a starting point for a review, not a verdict.

    Frequently asked questions

    Do my schemas upload anywhere?

    No. Your text and files are parsed and compared entirely in your browser — your schema data never leaves the device, and the only third-party requests are the site’s own analytics, which count page views. You can verify it yourself with the network-request counter in the privacy section below the visualizer.

    What changes does it flag?

    Tables added, dropped and renamed; columns added, dropped and renamed; type changes, nullability changes, default changes and UNIQUE changes; primary-key changes; foreign keys added and removed; and indexes added and removed. Every change carries a risk flag — breaking, caution or safe — with a plain-English reason, and every changed table gets a before and after diagram.

    What do breaking, caution and safe mean?

    Breaking means the change deletes data or will fail the migration — dropping a table or column, narrowing a type, or adding NOT NULL to a column that has NULLs. Caution means the change needs a closer look before you migrate — widening a type, relaxing a constraint, or a rename that is only a guess. Safe means the change is additive — a new table, a nullable column, a new index — and existing queries keep working.

    How does it spot a renamed column?

    When a column disappears from a table and a new column appears in the same table with the same type and a similar name, the tool reports it as a possible rename — and labels it as a guess, never as a fact. Confirm it before migrating: if it is actually a drop plus an add, the old column’s data is lost. Unrelated columns with different types are never guessed as renames.

    Which SQL dialects does it understand?

    Common DDL from PostgreSQL, MySQL, SQLite and SQL Server: CREATE TABLE with column definitions, table-level primary keys, foreign keys and unique constraints, CREATE INDEX, and ALTER TABLE … ADD COLUMN. You can also paste a simple list instead of SQL — one line per table, for example “users: id INT PRIMARY KEY, email TEXT NOT NULL”. Unusual syntax is reported as a parser note rather than guessed.

    Can I paste a pg_dump or mysqldump export?

    Yes. Export the schema only — pg_dump --schema-only or mysqldump --no-data — and paste the output straight in. The parser reads the CREATE TABLE and CREATE INDEX statements and ignores the rest, so a full dump with INSERT rows works too, though pasting data rows is pointless: this tool compares structure, not data.

    Does it write the migration SQL for me?

    No. This tool reports what changed and how risky each change looks, and exports that as a Markdown migration report you can attach to a pull request. You — or a migration tool such as Flyway, Liquibase or Prisma Migrate — write the actual migration. Never run generated SQL against a live database without review.

    Can it compare a live database with a file?

    No. It reads only the text and files you paste or drop — it never connects to a database and never sees your data. To compare a live database, export its schema first (pg_dump --schema-only, mysqldump --no-data, or sqlite3 .schema) and paste the export here.

    What does this tool NOT do?

    It does not connect to a database, does not generate migration SQL, and does not check your data — only the structure. Its parser is heuristic, not a full SQL parser, so unusual dialect syntax may not parse. Rename detection is a guess. And a clean report means the two schemas match, not that either schema is well designed.