DbSchema vs SQLly: a schema designer vs a SQL client

I build SQLly, so I'm biased. How DbSchema's diagrams, HTML5 docs, schema sync and Git compare with SQLly, what each costs, and when to pick DbSchema.

By

I build SQLly, so I'm biased. Keep that in mind for everything below.

DbSchema is a different kind of tool from most of the clients I compare SQLly against. It's a schema designer first and a SQL client second. So the real question here is which job you're doing.

Here's what I actually checked. I read its website, the editions and purchase pages, the docs for schema sync, Git, documentation, connections, the SQL editor and the AI assistant, and the 10.x release notes. I pulled the 10.6.0 download sizes from its server, and I downloaded the macOS archive and looked inside it: what architectures the binaries are built for, which Java runtime it bundles, and which libraries ship with it. I did not run it, and I didn't benchmark anything. Where I couldn't confirm something, I say so.

How they're built

DbSchema is a JavaFX app from Wise Coders, a German company with its development team in Romania. It ships its own Java runtime inside the installer. The 10.6.0 macOS build carries Java 25, and the app and that runtime are universal binaries, so it runs natively on Intel and Apple Silicon Macs. There are ARM builds for Windows and Linux too. Database access goes through JDBC drivers, which it downloads on demand.

Everything in DbSchema hangs off a model file, a .dbs. You reverse engineer a database into it, or design one from nothing, then diagram it, document it, put it in Git and sync it back to real databases.

SQLly is one Rust codebase that draws its own UI on the GPU. No browser engine, no JVM. It's closed source and it costs money for most people. It also only runs on Apple Silicon on the Mac, so if you're on an Intel Mac, DbSchema wins before we start.

The size gap is real. DbSchema 10.6.0 is a 228.1 MB macOS dmg, a 165.8 MB Windows installer and a 204.2 MB Linux tarball, before drivers. SQLly's macOS dmg is 65.6 MB, the Windows zip 60.9 MB and the Linux tarball 76.2 MB.

Databases

DbSchema lists 101 databases. Anything with a JDBC driver can connect, and that's the honest advantage of building on Java: the long tail comes almost for free.

EngineSQLlyDbSchema
PostgreSQL, MySQL, MariaDB, SQL Server, SQLiteYesYes
Oracle, DuckDB, ClickHouseYesYes
RedisYes, with typed key editing, Cluster, Sentinel, pub/sub and a memory analyzerListed, through its own JDBC driver; I couldn't tell how deep it goes
libSQL / TursoYesNot listed
MongoDBNoYes
Snowflake, Db2PlannedYes
BigQuery, Redshift, Cassandra, Teradata and the restNoYes

SQLly does 30 engines. DbSchema does more than three times that. If your shop runs on Snowflake or Db2, this section probably decides it.

Diagrams and design

This is DbSchema's home turf, and I'm not going to pretend otherwise. You get one diagram per subsystem, table groups, auto-layout, virtual foreign keys for databases that never declared real ones, and comments on hover. You can design a schema without a database, validate it, and generate the DDL for whichever engine you pick. The Architect edition adds logical and conceptual models, so one model can target several engines with your own naming and type rules.

SQLly has a Relationship Graph that reads the live catalog and exports to SVG, Mermaid or DBML. It's useful for finding your way around a database. It is not a modeler. There's no offline model, no logical design, nothing you'd use to plan a schema before it exists.

Documentation

DbSchema publishes interactive HTML5 docs, with the diagrams and comment tooltips, plus PDF and Markdown. That's a real thing to hand a new hire or a client.

SQLly writes a Markdown data dictionary in one step: tables, columns, keys, views, procedures, split per schema for big databases. It's fine for a wiki or a repo. It's not in the same league as DbSchema's HTML docs, and I'd rather say that than have you find out.

Schema sync and Git

Both tools compare schemas and write the SQL to bring one side in line. They come at it from different ends.

DbSchema compares the model against a live database, or the model against another model file. For each difference you click which side wins, then run the script or save it. I couldn't confirm from its docs that it compares two live databases directly or across engines. Its built-in Git client is the other half: commit, push, pull, branches, a side-by-side merge for conflicts, and a Model History that shows which tables changed in each commit.

SQLly compares any two connections, even on different engines, grades each change by risk, and writes both the sync script and a rollback script. Data compare and cross-engine data transfer sit next to it. On Git it's weaker: local DDL files can overlay the live schema, but Git history and blame for that DDL are still planned.

So if your schema lives in Git and gets reviewed there, DbSchema's flow is the more complete one today.

Writing SQL every day

This is where SQLly spends most of its effort.

  • Autocomplete. DbSchema suggests table and column names. SQLly does that, plus real column values in a WHERE, JOIN ON clauses from actual foreign keys, and a GROUP BY warning as you type.
  • Guardrails. DbSchema has a read-only connection option, a Production highlight, and holds single statements in an open transaction until you commit. That's decent. SQLly adds a hard stop on UPDATE or DELETE without a WHERE, read-only connections that refuse file-reading and shell tricks, auto-rollback and tenant checks, inherited down a client, project and environment tree.
  • Big results. SQLly streams to disk past 50,000 rows or 64 MiB and stays flat at 50 million rows. I couldn't find how DbSchema holds a big grid.
  • Query plans. SQLly's plan viewer is still in progress. I found no plan viewer in DbSchema's docs; its AI explains SQL, which isn't the same thing.
  • Passwords. SQLly keeps them in the OS keychain. DbSchema's docs say a remembered password goes "in a file on your computer", and I couldn't confirm whether that file is encrypted.

Both have a visual query builder, a test data generator, import and export, and session and lock dashboards. In DbSchema all of those need Pro.

Automation and AI

DbSchema has more here than I expected. Groovy scripts get full access to the model and the connection, and DbSchemaCLI can regenerate docs, sync schemas or reload test data on a schedule. SQLly's version is thinner: export, backup and restore dialogs give you the matching sqlly-cli command to paste into cron.

On AI, DbSchema's assistant does text-to-SQL, explains queries, writes column comments and suggests indexes. It sends table structure, not your data. You bring your own key on a paid edition, use Ollama, or buy credits at $9 a month. SQLly works with local models, your own endpoint or opt-in cloud providers, and ships a read-only MCP server so an agent can read schemas and run a single SELECT that always rolls back. DbSchema's docs don't mention an MCP server.

Cost

DbSchema Community is free for any use, at any company size. It covers connecting, reverse engineering, diagrams, creating tables and the SQL editor. The catch is that it can't save a design to a file, which is most of the point of the tool.

Pro for business use is $294 one time with a year of updates, then $75 a year if you want newer versions. Or $29.40 a month. Personal is $196, Educational $98, Architect $470.40, and a floating team license is $1,168. Those are list prices in USD before tax; when I looked there was also a 15% Black Friday code on the page.

SQLly is free for hobbyists with two saved servers. Past that it's $100 one time for SQLly 1.x or $200 for Lifetime. The free tier isn't available inside companies with more than 100 people, which is stricter than DbSchema Community.

Which one to pick

Pick DbSchema if:

  • Designing or documenting the schema is the actual job.
  • You want interactive HTML or PDF docs to hand to other people.
  • Your team reviews schema changes in Git and syncs them to each environment.
  • You need MongoDB, Snowflake, BigQuery, Db2 or something else from the long tail.
  • You're on an Intel Mac, or you want free diagrams at a big company.

Pick SQLly if:

  • You spend your day writing and fixing SQL against databases that already exist.
  • You want guardrails that stop a bad DELETE rather than a confirm box.
  • You need to compare two live databases, even across engines, with rollback scripts.
  • Redis or libSQL is part of your stack.
  • You'd rather pay $100 once than $294 plus $75 a year.

Honestly, a lot of teams could use both: DbSchema for the model and the docs, SQLly for the daily querying. They don't step on each other much.

The full feature table is on the SQLly vs DbSchema page. If you want to try SQLly against your own database, it's on the download page, and if I got something about DbSchema wrong, tell me and I'll fix it.