Liquibase Alternatives With a Visual Schema Diff

The table changed this morning, and the only account of what that does to the target database is a changelog file you have to read like code. DbSchema is the Liquibase alternative that puts the change on screen: it compares the design model against the live database object by object and generates the migration SQL from the differences you select. The comparison runs before anything is deployed, and you read it as a list of objects rather than as a diff of XML.

Liquibase is built for the other half of the work, replaying authored changes across environments from a pipeline. Three more tools appear on the same shortlist for that half: Redgate Flyway, Atlas and Bytebase.

Comparing Liquibase and its alternatives

The five tools split along one line. Either the change is authored as text and replayed against each environment, or it is made on a schema and the difference against the target is calculated for you. DbSchema is on the calculated side, and so are the diff features of the others, to varying degrees.

The difference shows up in review. A changelog tells a reviewer what the author intended to change; a diff against the target tells them what will actually run there, including the drift somebody introduced by hand last week. That is the gap DbSchema fills, and it is why architects who deploy through Liquibase still keep DbSchema next to it.

The other split is where the picture of the schema lives. Liquibase, Flyway and Atlas keep the change; none of them keeps a diagram you arrange for a design review and open again a month later. DbSchema keeps the tables, the layout, the diagram groups and the comments in one .dbs file, so the same artifact answers "what changed" and "what does this schema look like".

What is the purpose of Liquibase?

Liquibase keeps a text-based changelog that lists every change made to a database in sequence, so it can audit the database and apply whatever has not run yet. A single unit of change is a changeset, and the update command deploys the changesets your changelog names. Changelogs are written in SQL, XML, YAML or JSON, and Liquibase Secure adds a Formatted Mongo format[3]. Liquibase works with 60+ databases, including relational, NoSQL and graph engines[4].

Writing changes this way makes the deployment reproducible: the same file runs in the same order everywhere, and the pipeline needs nothing but the repository. It also means the structure lives in prose you maintain. A column you added on a diagram has to be re-expressed as a changeset before it deploys anywhere, and a reviewer reads the intended change rather than the difference against the environment it is going to.

Liquibase Community is open source and covers migration execution. The commercial product, Liquibase Secure, is sold in Starter, Growth, Business and Enterprise plans, each priced by quote and bounded by how many applications and how many database types it covers; Starter and Growth are offered only to companies under $1B in annual revenue, and every plan requires a separately billed professional services package for onboarding[2].

What is the alternative to Liquibase for visual schema diffs?

DbSchema keeps the schema as a design model in a local .dbs file, which is plain XML you can open in a text editor and commit next to the application code[5]. You connect over JDBC, DbSchema reverse-engineers the tables into diagrams, and from then on the diagram and the file are the same thing.

Editing the diagram changes the model file and nothing else, and DbSchema can be switched to disconnected mode so no statement reaches a database while you design. Two menu commands cross back to the live schema. Schema → Compare Model with Database lists what differs, object by object, and lets you decide per difference whether to update the model or push the change. Schema → Synchronize Model with Database generates the SQL that closes the gap, and the database changes only when you read that SQL and click Execute. Both are Pro features, along with saving the model to a file.

The same comparison runs between two model files: open two .dbs files at once and synchronize between them, which is how you diff a branch against what is deployed[5]. The model file travels through Git like source code. Git — Collaborative Design in the Model menu clones, stages, commits and pushes it, and after a pull, Compare with Current opens the Synchronization Dialog on the incoming version.

Around that core, DbSchema exports interactive HTML5, PDF and Markdown documentation from Diagram → Export HTML5 or PDF Documentation, reads 100+ SQL and NoSQL databases including PostgreSQL, MySQL, Snowflake and MongoDB, and browses several tables at once over foreign keys and virtual ones in the Relational Data Editor. Working offline in a model file and designing PostgreSQL schemas visually are the two habits that change first.

Licenses are per developer, and the amount for each of the three editions is on the purchase page[1], which prices in your own currency and carries separate Business, Personal and Universities & Students tabs. Community is free with no time limit and covers every supported database, connecting and reverse-engineering, interactive diagrams, creating tables and columns, and the SQL editor. Pro is bought once plus taxes, includes the first year of updates and an optional yearly renewal after that to keep receiving them, and adds saving the model to a file, documentation export, the visual query builder, schema synchronization, relational data browse, the data generator and the data importer. Architect, the edition above Pro, adds database-independent logical and conceptual design.

Which is better, Flyway or Liquibase?

Flyway, from Redgate, applies migrations you write as SQL scripts. The scripts are versioned, repeatable or baseline, and versioned ones come in a regular and an undo form. The migrate command scans the configured locations, compares what it finds against what the schema history table records as applied, and runs the gap in order. That table is what tells you which migration ran, when, and by whom[6]. Migrations are usually SQL, with Java and script migrations also supported.

Liquibase abstracts the change into a platform-agnostic changeset and generates the dialect-specific SQL; Flyway keeps the dialect in your hands. Neither draws the schema. Flyway's drift feature is a command rather than a picture: flyway check -drift compares a target environment against a snapshot and writes a report, and deployment can be aborted when drift is found. It is part of Flyway Enterprise[7].

DbSchema fits either pipeline without competing with it. You design on the diagram, run the comparison against staging, and export the generated SQL into the repository your Flyway or Liquibase job reads. Schema synchronization can also run headless through Groovy automation scripts or DbSchemaCLI, so the step fits into CI without a person at the screen. That pattern is the one most schema migration tools end up in.

How Atlas plans a migration from a declared schema

Atlas takes the Terraform approach to a database. You declare the schema you want in HCL, in SQL, as a database URL or from an ORM, and atlas schema apply loads that desired state into a dev database, inspects the target, plans the change and asks you to approve the plan before it runs[8]. Nothing is hand-written as an ALTER.

The plan covers schemas, tables, indexes and constraints such as foreign keys and checks. Views, materialized views, functions, procedures, triggers, sequences, domains, extensions, roles, users and permissions are included for Atlas Pro users[8]. The free Starter tier covers MySQL, MariaDB, PostgreSQL and SQLite; Atlas Pro starts at $9 per developer per month, and running Atlas in CI/CD through Atlas Pipelines costs $59 per month per project with two target databases included, plus $39 per month for each additional target[9].

Atlas shows an ERD and inspects a schema from the CLI. The layout is not something you arrange and keep: DbSchema saves table positions, groups and notes in the model file, so the diagram taken into a design review is the one the next person opens.

What Bytebase adds as a review layer

Bytebase is a server your team installs and then works through in a browser. A change is submitted in the web UI or from a linked Git pull request, checked against pre-deployment SQL review rules, routed for approval, and recorded in a changelog. The pricing page lists over 200 review rules, Git-based schema version control, schema comparison and one-click rollback in every tier[10].

Community is free forever for up to 20 users and 10 database instances. Pro is $20 per user per month with the same 10 instances, and adds Google and GitHub single sign-on plus a seven-day audit log. Approval workflows, dynamic data masking, custom roles and unlimited audit retention are Enterprise features, priced on request[10].

The cost of that model is the server: somebody runs it, upgrades it and keeps it reachable. DbSchema is a desktop application connecting straight to the database over JDBC, so the review artifact is a file in the repository rather than a record in another system.

How to choose a schema migration strategy

Pick DbSchema when the design itself has to be visible and portable: an ER diagram you arrange and keep, a model file in Git, HTML5 documentation for people who never open a database client, and a side-by-side comparison that writes the migration SQL. That is the architect's half of the job, and it covers every engine on one licence.

Liquibase suits a delivery process that has to be identical in every environment and evidenced afterwards, with changelogs as the record. Flyway suits a team that would rather own the SQL itself. Atlas suits people who already think in declared state and want the plan calculated from it. Bytebase suits an organization that wants change requests, review and approval to happen in one web application.

Two of them together is a normal arrangement, and the seam is clean: design and diff in DbSchema, commit the generated script, let the pipeline apply it. Download DbSchema at https://dbschema.com/download.html, connect it to the database your changelogs deploy to, and run the comparison against your current model. Connecting, reverse-engineering, diagrams and the SQL editor are free in Community; schema synchronization, the saved model file and the documentation export are Pro; logical and conceptual design is Architect.

Frequently asked questions

What is the alternative to Liquibase?

DbSchema, for the part Liquibase leaves to you: seeing the change. The model it compares is not tied to one engine: open Model → Model Properties, pick another database under RDBMS, and DbSchema previews how every data type converts before you save the model[5]. How the comparison itself runs is in the section on the visual alternative.

Can DbSchema and Liquibase run in the same pipeline?

DbSchema starts without its user interface for exactly that. DbSchema.exe -x path/to/script.groovy runs a Groovy automation script from the command line, with the database connection and the DbSchema project injected into the script as variables it works from. You commit the SQL the script writes, and the Liquibase job in the pipeline applies it.

Is Liquibase free to use?

Liquibase Community is open source and free. Liquibase Secure is quoted rather than listed, and each plan caps what it covers: Starter is up to 5 applications and 1 database type, Growth up to 10 applications and 3 database types. A DbSchema licence is priced per developer instead, so the number of applications and engines behind it does not change the cost.

Sources

1. dbschema.com
2. liquibase.com
3. docs.liquibase.com
4. docs.liquibase.com
5. dbschema.com
6. documentation.red-gate.com
7. documentation.red-gate.com
8. atlasgo.io
9. atlasgo.io
10. bytebase.com