SchemaSmith vs Liquibase

Free, state-based schema management for SQL Server, PostgreSQL, MySQL, and MariaDB — vs XML/YAML changelog-driven migrations.

Chaos vs Precision: Product Comparisons

Quick Summary

SchemaSmith uses a state-based approach: you declare the end state in JSON and the tool generates the changes. Liquibase uses a changelog-driven approach: you author changesets in XML, YAML, or JSON that apply in order. SchemaSmith is free under a source-available license — unlimited seats, schemas, and servers, at any team size, application count, or database-type count. Liquibase Community is free and, from version 5.0, source-available under the Functional Source License (FSL); Liquibase Secure is paid (Starter, Team, Business, and Enterprise plans, all quoted by sales), and each plan caps database types and database targets.

Technical Comparison

How the tools differ in approach, features, and developer experience.

Aspect SchemaSmith Liquibase
Approach State-based: declare end state, tool generates the changes Changelog-driven: changesets applied in order
Source Format JSON template files (one per table, plus indexed and materialized views) and SQL scripts (one per procedure, function, trigger, or ordinary view) XML / YAML / JSON / formatted SQL changelogs
Drift Detection Built-in — compares live database to declared state on every run Community's diff compares two databases; the drift report requires Liquibase Secure (Team plan and above)
Environment Sync Any environment converges to the declared state in one run Apply every changeset in order from baseline
Rollback Re-deploy prior release state — views, procedures, and functions restore from that release’s package* Automatic for many change types; hand-written for the rest, including every formatted SQL changelog
Merge Conflicts JSON table definitions merge cleanly in source control Changelog ordering / changeset-ID conflicts on parallel branches
CI/CD Model Idempotent — same result whether run once or ten times Order-dependent — tracks applied changesets in DATABASECHANGELOG
Reference Data Declarative DataDelivery blocks; two-pass FK-aware loader loadData, insert, and sqlFile changesets
Failed Deployment Recovery Checkpoint & resume (--ResumeQuench); skips completed work on retry Restart from the failed changeset; partial-state cleanup is manual
Conditional Deployment ShouldApplyExpression — one file applies per database, env, or version Liquibase contexts and labels on changesets
Platform Coverage SQL Server, PostgreSQL, MySQL, MariaDB (platform-specific schema definitions) 60+ databases via JDBC drivers
Licensing Free under SSCL v2.0 (source-available); unlimited seats & schemas Community (free; FSL-1.1-ALv2 from 5.0, Apache 2.0 for earlier releases) or Liquibase Secure (paid, four plans, quoted by sales)

*SchemaQuench rolls back schema by re-applying the prior release’s declared state — including stored procedures, views, and functions, which restore from that release’s package. Data preservation (e.g., retaining values from a dropped column) is handled with user-written migration scripts inside the same package.

Production-resilience features, free

Checkpoint & resume, two-pass FK-aware data delivery, ShouldApplyExpression, secondary servers for SQL Server Availability Groups, and custom script folders all ship in the free CLI — the same production-resilience and observability axes Liquibase Secure plans charge for.

Rollback: A Closer Look

Rollback capabilities differ significantly between state-based and changelog-driven approaches.

SchemaSmith Rollback

  • Stored procedures, functions, views restore to the prior version automatically when you re-deploy the prior release’s package, because the package holds that version.
  • Schema structure reverts automatically — no rollback scripts for tables, columns, or indexes
  • No pre-planning required — deploy any prior release state directly
  • Non-sequential rollback included — skip intermediate versions
  • Data preservation for column drops requires migration scripts inside the package
SchemaSmith Rollback Docs

Liquibase Rollback Limitations

  • Stored logic does not auto-restore — Liquibase’s docs note that rollback “does not restore the previously stored version”
  • Many change types require hand-written rollback blocks
  • Formatted SQL changelogs have no automatic rollback — you author every reverse statement
  • Pre-plan with tags before deployment to enable point-in-time rollback
Liquibase Rollback Docs

The key difference

With SchemaSmith, rolling back a stored procedure restores the prior version from that release’s SQL script automatically: re-deploy the prior release’s package, and its scripts put the earlier version back. With Liquibase, you maintain previous versions inside custom rollback blocks alongside each changeset, or accept that rollback will not restore stored logic to its prior state.

Choose SchemaSmith when...

  • You want built-in drift detection without buying a Liquibase Secure plan
  • You manage SQL Server, PostgreSQL, MySQL, and MariaDB and want one tool covering them all
  • Your team regularly hits merge conflicts on changeset ordering or changelog files
  • You expect to add database types or database targets. Every Liquibase Secure plan caps both
  • You want idempotent CI/CD — the same pipeline produces the same result whether run once or ten times
  • You need to resume a failed deployment without re-running everything that already succeeded
  • You want one license — free, source-available, no database-target or database-type caps — that does not change as the team or footprint grows

Choose Liquibase when...

  • You prefer the XML or YAML changelog format and want every change captured as an explicit, reviewable changeset
  • You are deeply invested in an existing Liquibase changelog history and the cost of extracting current state outweighs the benefit of switching
  • You rely on Liquibase-specific integrations (Spring Boot starters, Maven / Gradle plugins, custom change classes) that you want to keep
  • You target a database SchemaSmith does not yet cover (Oracle, DB2, Snowflake, etc.) and need one tool across all of them
  • You prefer database-agnostic changelog abstractions that try to render the same logical change across many platforms

Pricing & Licensing

How the two tools differ on cost, license terms, and what changes as you scale.

Aspect SchemaSmith Liquibase
License SSCL v2.0 (source-available) FSL-1.1-ALv2 (Community, from 5.0; earlier releases Apache 2.0) / proprietary commercial (Secure)
Cost $0/year — free for any purpose, any organization, any scale Community: free. Secure: contact sales for pricing.
Plans / Caps One edition; no database-target, database-type, or seat caps Liquibase Secure has four plans (Starter, Team, Business, Enterprise), each capped on database types and database targets; every plan requires a Professional Services package
Cost as You Scale Stays at $0/year regardless of applications, database types, replicas, or regions Going past a plan's database-type or target cap means buying added capacity or moving up a plan

Liquibase publishes its current plan matrix at liquibase.com/pricing. We deliberately do not quote competitor prices on this page because vendor pricing changes and contact-sales pricing is not public.

Total cost at scale

SchemaSmith’s cost stays at $0/year regardless of how many applications, database types, replicas, or regions you deploy to. There is no per-user license, no database-target cap, no database-type cap, no higher plan to move up to. The same free CLI deploys to dev, staging, and production at any team size, on any number of databases.

Migrating from Liquibase

Switching from Liquibase to SchemaSmith does not require rewriting your changelog history. Extract current state once, review the captured package, and start managing future changes declaratively.

  1. Extract current state with SchemaTongs. Point it at a representative database and let it capture tables and indexed or materialized views as JSON template files, and stored procedures, functions, ordinary views, and triggers as SQL scripts.
  2. Review the captured package. The package becomes the new source of truth — commit it to source control alongside the rest of your repo.
  3. Deploy with SchemaQuench. Future schema changes are edits to the package: a table change is an edit to its JSON, and a stored procedure change is an edit to its SQL script. SchemaQuench generates and applies the DDL on every run, idempotently.

Your existing Liquibase changelog history stays in place as a record of how the database got here. SchemaSmith takes over from the current state forward.

Pricing and feature data last verified November 2026. Competitor information may change.

Hands-on lab

Switch from XML/YAML changelogs to JSON state files and deploy idempotently, with no changeset ordering to wrangle.

Start the Liquibase lab

Next Steps by Platform

Everything from here is organized by database. Choose yours below and keep going.

Shape. Strengthen. Succeed.

Free schema-as-code for SQL Server, PostgreSQL, MySQL, and MariaDB.

The source is on GitHub for anyone to read.

Get Started on GitHub