SchemaSmith vs Liquibase

Free, state-based schema management for SQL Server, PostgreSQL, and MySQL — 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 open source with limited features; Liquibase Secure is paid (Starter, Growth, Business, Enterprise tiers, all contact-sales pricing) with caps on applications and database types per tier.

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, view, procedure) XML / YAML / JSON / formatted SQL changelogs
Drift Detection Built-in — compares live database to declared state on every run Available; observability features sit in paid Liquibase Secure tiers
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 JSON* Hand-written rollback scripts; many change types do not auto-rollback
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 (platform-specific schema definitions) 20+ databases via JDBC drivers
Licensing Free under SSCL v2.0 (source-available); unlimited seats & schemas Community (Apache 2.0, free) or Liquibase Secure (paid, 4 tiers, contact sales)

*SchemaQuench rolls back schema by re-applying the prior release’s declared state — including stored procedures, views, and functions, which restore from JSON definitions. 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 tiers 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 — the JSON definition is the source of truth
  • 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 the JSON definition automatically — the same source of truth that deploys it forward also deploys it backward. 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 paying for premium observability tiers
  • You manage SQL Server, PostgreSQL, and MySQL and want one tool covering all three
  • Your team regularly hits merge conflicts on changeset ordering or changelog files
  • You expect to scale apps, database types, or replicas where Liquibase Secure tier costs compound
  • 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 per-app or per-DB-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, MariaDB, 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) Apache 2.0 (Community) / proprietary commercial (Secure)
Cost $0/year — free for any purpose, any organization, any scale Community: free. Secure: contact sales for pricing.
Tiers / Caps One edition; no application, database-type, or seat caps Liquibase Secure has four tiers (Starter, Growth, Business, Enterprise) with caps on applications and database types per tier
Cost as You Scale Stays at $0/year regardless of applications, database types, replicas, or regions Tier upgrades trigger when applications or database types exceed the current tier’s caps

Liquibase publishes its current tier matrix at liquibase.com/pricing. We deliberately do not quote competitor prices on this page because vendor pricing changes and contact-sales tiers are 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 application cap, no database-type cap, no tier to escalate to. The same free CLI deploys to dev, staging, and production at any team size, on any number of databases, forever.

Migrating from Liquibase

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

  1. Extract current state with SchemaTongs. Point it at a representative database and let it capture every table, view, procedure, and function as JSON template files.
  2. Review the generated metadata. The JSON files become the new source of truth — commit them to source control alongside the rest of your repo.
  3. Deploy with SchemaQuench. Future schema changes are edits to the JSON; 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 May 2026. Competitor information may change.