diff --git a/content/blog/bytebase-vs-liquibase.md b/content/blog/bytebase-vs-liquibase.md index 5a873dbc..53dd6a75 100644 --- a/content/blog/bytebase-vs-liquibase.md +++ b/content/blog/bytebase-vs-liquibase.md @@ -1,210 +1,194 @@ --- title: 'Bytebase vs. Liquibase: a side-by-side comparison for database schema migration' author: Cayden -updated_at: 2023/06/08 19:21:21 +updated_at: 2026/03/30 12:00:00 feature_image: /content/blog/bytebase-vs-liquibase/bytebase-vs-liquibase-banner.webp tags: Comparison -description: 'When looking for a database CI/CD and schema migration change tool, Bytebase and Liquibase are two common options. Understanding the differences between these two tools can help potential users choose the one that best meets their needs.' +description: 'Bytebase vs. Liquibase compared across migration workflow, SQL review, access control, pricing, and CI/CD. Updated for Liquibase 5.0 Secure and Bytebase 3.16.' keypage: true --- > If Liquibase is Git, then Bytebase is GitHub/GitLab. -When looking for a database CI/CD and schema migration change tool, Bytebase and Liquibase are two common options. Understanding the differences between these two tools can help potential users choose the one that best meets their needs. +Bytebase and Liquibase both handle database schema migration, but the right choice depends on how your team ships database changes — not just which databases you run. A solo developer writing changelogs in a terminal has different needs than a platform team where DBAs review every production migration. -## What Bytebase and Liquibase have in common +## How They Approach Schema Migration -- Native SQL supported. -- Database CI/CD with version control system #GitOps (see [Database GitOps configuration](#database-gitops-configuration)). -- Auto SQL check (see [Auto SQL check](#sql-auto-check)). -- Schema Synchronization (see [Sync schema](#sync-schema)). -- Tiered pricing, offering both free and paid plan. -- Open source, Liquibase has a long history, while Bytebase is growing faster. - ![star-history](/content/blog/bytebase-vs-liquibase/star-history.webp) +**Liquibase** (v5.0, September 2025) is a CLI-first migration engine. You define changes in XML, YAML, SQL, or JSON changelogs, then run `liquibase update` to apply them. It slots into any CI/CD pipeline as a command-line step. The commercial edition — rebranded from "Liquibase Pro" to **Liquibase Secure** in September 2025 — adds policy checks, flow files for workflow automation, and structured JSON logging. -## What are the differences between Bytebase and Liquibase? +**Bytebase** (v3.16, March 2026) is a web-based platform where developers submit changes, DBAs review and approve them, and the system rolls out across environments. Schema migration is one part of it — SQL review, access control, data masking, and audit logging are built in. -While both Bytebase and Liquibase are tools for database CI/CD, there are some key differences between the two. Liquibase main -product is its CLI and the java library. Bytebase also provides a CLI, while its main product is the GUI-based workspace -for developers and DBAs to collaborate. +Put another way: **Liquibase is Git for databases; Bytebase is GitHub/GitLab for databases.** -| | Liquibase | Bytebase | -| -------------------------------------------------------------------------------------------- | --------------- | ------------------------------------ | -| [Product position](#product-position) | Schema change | Schema Change | -| [Developer interface](#developer-interface) | CLI | GUI, API | -| [Supported databases](#supported-databases) | 50 | 22 | -| [Programming language and installation](#installation) | Java + JVM | Golang and no other dependency | -| [Change execution](#change-execution) | Changelog + CLI | Issue + GUI | -| [Batch Change](#change-execution) | - | ✅ Multi-environment / Multi-tenant | -| [Database GitOps](#database-gitops-configuration) | ✅ | ✅ | -| [SQL auto check](#sql-auto-check) | ✅ Paid version | ✅ Available in Free version | -| [Approval flow](#approval-flow) | - | ✅ | -| [Change history](#change-history) | ✅ | ✅ | -| [Sync schema](#sync-schema) | ✅ | ✅ | -| [Rollback](#rollback) | ✅ Manual | ✅ Auto generated rollback statement | -| [Schema drift detection](#schema-drift-detection) | ✅ Manual | ✅ Auto | -| [Slow query detection and advisor](#slow-query-detection-and-advisor) | - | ✅ | -| [Data access control, security and compliance](#data-access-control-security-and-compliance) | - | ✅ | +## What They Have in Common -### Product position +- Native SQL support for defining schema changes. +- GitOps integration — trigger migrations from pull requests. +- Schema synchronization and diff capabilities. +- Change history tracking. +- Tiered pricing with a free community edition. +- Both are open source — though Liquibase switched from Apache 2.0 to the Functional Source License (FSL) in September 2025 with v5.0. Bytebase is MIT licensed, with enterprise features under a commercial license. -- **Liquibase**: A database schema change and version control tool. It helps you track, manage, and automate changes to your database. - ![liquibase-position](/content/blog/bytebase-vs-liquibase/liquibase-position.webp) +## Key Differences Between Bytebase and Liquibase -- **Bytebase**: In addition to database schema change and version control, Bytebase also provides data query, security, and governance features. It provides a GUI based collaboration workspace that helps DBAs and Developers manage the database development lifecycle. - ![bytebase-position](/content/blog/bytebase-vs-liquibase/bytebase-position.webp) +| | Liquibase (Community) | Liquibase Secure | Bytebase | +| ------------------------------ | --------------------- | ---------------- | -------- | +| [Developer interface](#developer-interface) | CLI | CLI + VS Code extension | Web GUI + API + Terraform | +| [Supported databases](#supported-databases) | 60+ | 60+ | 23 | +| [Installation](#installation) | Java 17 + JVM | Java 17 + JVM | Single Go binary, Docker, or K8s | +| [Change execution](#change-execution) | Changelog + CLI | Changelog + CLI + Flow files | Issue-based GUI or GitOps | +| [Batch change](#batch-change) | Manual scripting | Flow files | Built-in multi-env / multi-tenant | +| [SQL review / policy checks](#sql-review-and-policy-checks) | — | Policy checks (custom rules) | 200+ rules, free tier included | +| [Approval flow](#approval-flow) | — | — | Risk-based custom approval | +| [Rollback](#rollback) | Basic (manual scripts) | Granular + automated | Auto-generated rollback + sync to any version | +| [CI/CD integration](#cicd-integration) | Any CLI-based pipeline | Flow files for orchestration | GitOps + GitHub/GitLab native | +| [Change history](#change-history) | DATABASECHANGELOG table | + Structured JSON logging | GUI with diff view + issue linkage | +| [Data access control & audit](#data-access-control-and-audit) | — | — | RBAC, audit log, data masking, SSO | +| [Pricing](#pricing) | Free | Quote-based (5 tiers) | Free / Pro (cloud) / Enterprise | -### Developer interface +### Developer Interface -- **Liquibase**: A command-line tool. A simple graphical user interface (GUI) called Liquibase Hub is available with the Pro Plan, but it has sunset in May 2023. -- **Bytebase**: A web-based GUI tool. It also provides [application programming interface (API)](https://docs.bytebase.com/api/overview/), [Terraform Provider](https://docs.bytebase.com/integrations/terraform/overview/), and [GitHub App](https://docs.bytebase.com/sql-review/github-app). +**Liquibase** is CLI-only for the Community edition. After Liquibase Hub was sunset in April 2023, there is no web dashboard. The Secure edition added a VS Code extension ("Liquibase Secure Developer") for IDE-based interaction, but the primary workflow remains the terminal. -### Supported databases +**Bytebase** provides a web-based GUI where developers submit changes, DBAs review them, and the platform handles rollout. It also exposes a full [API](https://www.bytebase.com/docs/api/overview/), a [Terraform provider](https://www.bytebase.com/docs/get-started/terraform/) for infrastructure-as-code workflows, and a [GitHub App](https://www.bytebase.com/docs/sql-review/github-app/) for PR-based SQL review. -- **Liquibase**: 50 - IBM DB2, MS SQL Server, Oracle, PostgreSQL, MySQL, Snowflake, MongoDB, ClickHouse ... -- **Bytebase**: 22 - MySQL, PostgreSQL, ClickHouse, Snowflake, MongoDB, Redis, Redshift, Oracle, MS SQL Server ... +### Supported Databases + +**Liquibase** supports 60+ databases through a modular extension system. Core databases include PostgreSQL, MySQL, Oracle, SQL Server, MariaDB, Snowflake, MongoDB, and DB2. Many database extensions are community-contributed. + +**Bytebase** supports 23 database engines with deep integration: 9 RDBMS (MySQL, PostgreSQL, Oracle, SQL Server, MariaDB, TiDB, OceanBase, CockroachDB, Spanner), 6 NoSQL (MongoDB, Redis, Cassandra, DocumentDB, DynamoDB, Cosmos DB), 7 data warehouses (Snowflake, BigQuery, Redshift, Hive, ClickHouse, Databricks, StarRocks), and Elasticsearch. + +Liquibase covers more databases. Bytebase goes deeper on each one it supports — online schema change for MySQL, engine-specific SQL review rules for PostgreSQL, column-level data masking that understands each database's type system. ### Installation -- **Liquibase**: Java-based tool, so you need to install a Java Virtual Machine (JVM) before users can install Liquibase. -- **Bytebase**: Go-based tool, a self-contained binary with no external dependency. Also provides [Docker](https://docs.bytebase.com/get-started/deploy-with-docker/) and [Kubernetes](https://docs.bytebase.com/get-started/deploy-with-kubernetes/) deployment. +**Liquibase** requires Java 17+ (as of v5.0). Install the JVM, then install Liquibase. The Secure edition includes a one-step certified installer with bundled database drivers. -### Change execution +**Bytebase** ships as a single Go binary with no external dependencies. Deploy via [Docker](https://www.bytebase.com/docs/get-started/deploy-with-docker/) or [Kubernetes](https://www.bytebase.com/docs/get-started/deploy-with-kubernetes/) in under 5 minutes. -- **Liquibase**: CLI or GitOps. Users specify the changes by defining a `changelog` and then run a command. +### Change Execution -![liquibase-changelog](/content/blog/bytebase-vs-liquibase/liquibase-changelog.webp) -![liquibase-update](/content/blog/bytebase-vs-liquibase/liquibase-update.webp) +**Liquibase** uses changelogs — files in XML, YAML, SQL, or JSON that define database changes. You run `liquibase update` to apply them. Changelogs support preconditions (skip a changeset if the table already exists), contexts (apply only in certain environments), and labels (tag changesets for selective execution). The Secure edition adds Flow files: reusable YAML-based pipelines that chain multiple Liquibase commands with conditional logic — for example, run `validate` first, then `update`, and only run `rollback` if `update` fails. -- **Bytebase**: Web-based GUI or GitOps. Users create issues with SQL which could be approved. An issue may include SQL running against one database, or batch change against multiple databases span across different [development environments](https://docs.bytebase.com/change-database/batch-change/#change-databases-from-multiple-environments) and [different tenants](https://docs.bytebase.com/change-database/batch-change/#change-databases-from-multiple-tenants). - ![bytebase-issue](/content/blog/bytebase-vs-liquibase/bytebase-issue.webp) +![Liquibase changelog definition](/content/blog/bytebase-vs-liquibase/liquibase-changelog.webp) - Users can create tenant project to facilitate batch change. In tenant mode, users can do advanced canary release. - ![bytebase-canary](/content/blog/bytebase-vs-liquibase/bytebase-canary.webp) +**Bytebase** uses an issue-based workflow. A developer creates an issue containing SQL statements, which goes through review and approval before execution. Issues can target a single database or batch across environments. Bytebase also supports online schema change for MySQL — large table migrations that would normally lock the table for hours complete in seconds with zero downtime. - Users can also do online schema change for large tables to reduce downtime from hours to seconds. - ![bytebase-online-schema-change](/content/blog/bytebase-vs-liquibase/bytebase-online-schema-change.webp) +![Bytebase issue-based change workflow](/content/blog/bytebase-vs-liquibase/bytebase-issue.webp) -### Database GitOps configuration +### Batch Change -- **Liquibase**: Integrate with VCS CI workflow. - ![liquibase-gitlab-gitops](/content/blog/bytebase-vs-liquibase/liquibase-gitlab-gitops.webp) +**Liquibase** doesn't have built-in multi-environment orchestration. You run `liquibase update` against each target database separately in your CI/CD pipeline. The Secure edition's Flow files help — you can define a YAML pipeline that runs the same changelog against dev, staging, and prod in sequence, with gates between stages. But it's still you writing the orchestration, not the tool managing it. -- **Bytebase**: Point-and-Click GitOps workflow setup. - ![bytebase-gitlab-gitops](/content/blog/bytebase-vs-liquibase/bytebase-gitlab-gitops.webp) +**Bytebase** handles this natively. A single issue can roll out changes across [multiple environments](https://www.bytebase.com/docs/change-database/batch-change/#change-databases-from-multiple-environments) (dev → staging → prod) or [multiple tenants](https://www.bytebase.com/docs/change-database/batch-change/#change-databases-from-multiple-tenants) with canary release support. - You may even enable SQL Review in GitLab automatically by clicking a checkbox while configuring GitOps workflow. (which is not in the video) - ![bytebase-gitops-sql-review](/content/blog/bytebase-vs-liquibase/bytebase-gitops-sql-review.webp) +![Bytebase canary release across tenant databases](/content/blog/bytebase-vs-liquibase/bytebase-canary.webp) - Check the video: [Setting up GitLab VCS integration for Bytebase (GitOps)](https://www.youtube.com/watch?v=51_bL7Vnqww&t=221s) +### SQL Review and Policy Checks - Because Bytebase has the similar project concept as seen in GitLab/GitHub, the GitOps integration is nature to the developers. +**Liquibase Community** has no built-in SQL quality checks. **Liquibase Secure** offers Policy Checks (renamed from "Quality Checks" in September 2024) with custom rules and conditional logic chains (AND/OR/NOT). You can write checks like "block any changeset that drops a table in production" or "require a rollback section for every changeset." These operate on changelog structure and SQL patterns — useful for governance, though less granular than engine-specific SQL analysis. -### SQL auto check +![Liquibase policy check configuration](/content/blog/bytebase-vs-liquibase/liquibase-quality-check.webp) -SQL auto check helps developers write less buggy SQL and save DBAs manual review efforts. +**Bytebase** includes [SQL Review](https://www.bytebase.com/docs/sql-review/overview/) with 200+ rules across MySQL, PostgreSQL, Oracle, SQL Server, and more — available in the free tier. Rules are database-engine-specific (not generic), and you can configure error levels per environment (warn in dev, block in prod). -- **Liquibase**: SQL Quality check -- **Bytebase**: [SQL Review](https://docs.bytebase.com/sql-review/overview/) +![Bytebase SQL review rules configuration](/content/blog/bytebase-vs-liquibase/bytebase-sql-review-rules.webp) -#### Supported Plan +SQL review triggers automatically in three places: -- **Liquibase**: Only in Pro Plan and above -- **Bytebase**: Available in Free Plan +1. When a change issue is created. +2. When querying in the SQL Editor. +3. In GitOps — before SQL is merged into the main branch. -#### Number of rules +Bytebase also has AI features in the SQL Editor — text-to-SQL, query explanation, and problem detection. You bring your own LLM key. -- **Liquibase**: 10 general rules -- **Bytebase**: 49 rules for MySQL, 38 rules for PostgreSQL, 18 rules for Oracle ... +### Approval Flow -#### How to configure +**Liquibase** has no built-in approval workflow in either edition. Approval happens outside the tool — in your CI/CD pipeline, Jira tickets, or Slack messages. -- **Liquibase**: Predefined, users may set levels while calling. - ![liquibase-quality-check](/content/blog/bytebase-vs-liquibase/liquibase-quality-check.webp) -- **Bytebase**: Rules are predefined, users can activate and choose error level for specific rules. The picked rule set will make a reusable policy which can be applied to environment, e.g. `Test`, `Staging`, `Prod`. - ![bytebase-sql-review-rules](/content/blog/bytebase-vs-liquibase/bytebase-sql-review-rules.webp) +**Bytebase** has [risk-based custom approval flows](https://www.bytebase.com/docs/administration/custom-approval/). You define rules like "DDL on prod needs DBA approval" or "changes touching 3+ databases need manager sign-off," and the system routes each issue to the right reviewers based on what it touches. -#### How to trigger +![Bytebase custom approval flow configuration](/content/blog/bytebase-vs-liquibase/bytebase-custom-approval-flow.webp) -- **Liquibase**: Run `check` command or manually integrate this command in automation. Users may go to admin console to view logs. - ![liquibase-validate-result](/content/blog/bytebase-vs-liquibase/liquibase-validate-result.webp) +### Rollback -- **Bytebase**: Three places to trigger SQL review by default, users may manually integrate it to other scenarios by API as well: +**Liquibase Community** supports basic rollback — you write rollback SQL manually in your changelog and run `liquibase rollback` to a specific tag or date. **Liquibase Secure** improves this with auto-generated rollback scripts for common operations, rollback reports (added in v4.27.0) that show what was rolled back, skipped, or failed, and custom rollback logic for complex cases. - 1. When a database change is created as an issue. - ![bytebase-issue-auto-sql-review](/content/blog/bytebase-vs-liquibase/bytebase-issue-auto-sql-review.webp) +**Bytebase** auto-generates rollback statements for DML changes and supports reverting to any previous schema version via [schema sync](https://www.bytebase.com/docs/change-database/rollback-data-changes/). No manual rollback scripts needed. - 2. When users query data from SQL Editor. - ![bytebase-sql-editor-review](/content/blog/bytebase-vs-liquibase/bytebase-sql-editor-review.webp) +### CI/CD Integration - 3. When users enable GitOps workflow, before a new SQL is merged into the main branch. - ![bytebase-gitops-merge](/content/blog/bytebase-vs-liquibase/bytebase-gitops-merge.webp) +**Liquibase** fits into any CI/CD pipeline as a CLI step — GitHub Actions, GitLab CI, Jenkins, CircleCI. The Secure edition's Flow files add reusable pipeline definitions with conditional branching based on exit codes. -### Approval flow +**Bytebase** offers point-and-click [GitOps setup](https://www.bytebase.com/docs/vcs-integration/overview/) with GitHub and GitLab. SQL files committed to a repo automatically create change issues in Bytebase, with SQL review running as a merge check. -- **Liquibase**: Not supported. -- **Bytebase**: Basic rollout and [risk-based custom approval flow](https://docs.bytebase.com/administration/custom-approval/). - ![bytebase-rollout-policy](/content/blog/bytebase-vs-liquibase/bytebase-rollout-policy.webp) - ![bytebase-custom-approval-flow](/content/blog/bytebase-vs-liquibase/bytebase-custom-approval-flow.webp) - ![bytebase-risk-center](/content/blog/bytebase-vs-liquibase/bytebase-risk-center.webp) +![Bytebase GitOps SQL review in GitLab merge request](/content/blog/bytebase-vs-liquibase/bytebase-gitops-merge.webp) -### Change history +### Change History -- **Liquibase**: Simple Database Change Logs. - ![liquibase-logs](/content/blog/bytebase-vs-liquibase/liquibase-logs.webp) +**Liquibase** tracks changes in the `DATABASECHANGELOG` table — a record of which changesets were applied, when, and by whom. You query it directly with SQL. The Secure edition adds structured JSON logging (replacing the old text-based logs) that you can pipe into Datadog, Splunk, or any log aggregator. This is how Liquibase replaced the Hub dashboard — instead of a built-in UI, you build observability from the log stream. -- **Bytebase**: Change History tracking diffs and the originated issue. - ![bytebase-change-history](/content/blog/bytebase-vs-liquibase/bytebase-change-history.webp) - ![bytebase-change-diff](/content/blog/bytebase-vs-liquibase/bytebase-change-diff.webp) +**Bytebase** provides a visual change history with schema diffs and links back to the originating issue, reviewer, and approval chain. -### Sync schema +![Bytebase change history with diff view](/content/blog/bytebase-vs-liquibase/bytebase-change-diff.webp) -- **Liquibase**: Support `diff-changelog` to compare databases and to create a deployable changelog to sync. -- **Bytebase**: Choose a specific schema version, auto calculate the diff with selected databases. - ![bytebase-sync-schema-step1](/content/blog/bytebase-vs-liquibase/bytebase-sync-schema-step1.webp) - ![bytebase-sync-schema-step2](/content/blog/bytebase-vs-liquibase/bytebase-sync-schema-step2.webp) +### Data Access Control and Audit -### Rollback +**Liquibase** doesn't cover this area. Neither edition has access control, data masking, or audit logging — the Secure edition's structured logs tell you what changed and when, but not who queried what data. If you need database access governance, you'd pair Liquibase with a separate tool. + +**Bytebase** bundles all of this: -- **Liquibase**: Support `rollback-one-changeset` or `rollback`. -- **Bytebase**: By using sync schema, users may revert to a specific version. Also support [auto rollback](https://docs.bytebase.com/change-database/rollback-data-changes/). +- **[RBAC](https://www.bytebase.com/docs/concepts/roles-and-permissions/)** — workspace and project-level roles (Admin, DBA, Developer, Releaser) plus custom roles with granular permissions. +- **[SQL Editor](https://www.bytebase.com/docs/sql-editor/overview/)** — centralized query interface where data access is controlled and logged. +- **[Data masking](https://www.bytebase.com/docs/security/data-masking/overview/)** — column-level dynamic masking with multi-level policies, built into the SQL Editor. +- **[Audit log](https://www.bytebase.com/docs/security/audit-log/)** — every operation is recorded, with integrations to Splunk, Datadog, Elastic, and cloud logging services. +- **SSO** (Google, GitHub, OIDC, LDAP) and **2FA** for enterprise authentication. +- **Just-In-Time (JIT) data access** (new in v3.16) — developers request temporary query access, a reviewer approves it, and access expires automatically. -### Schema drift detection +![Bytebase SQL Editor with controlled data access](/content/blog/bytebase-vs-liquibase/bytebase-sql-editor.webp) -- **Liquibase**: Not supported. -- **Bytebase**: Will auto detect schema diff if someone manipulates the schemas out of Bytebase. - ![bytebase-schema-drift](/content/blog/bytebase-vs-liquibase/bytebase-schema-drift.webp) +### Pricing -### Slow query detection and advisor +**Liquibase** restructured its pricing in September 2025 into five tiers: Community (free), Starter, Growth, Business, and Enterprise. All paid tiers are branded "Liquibase Secure." Paid plans are gated by number of applications, database types, and company revenue (Starter and Growth require under $1B revenue). No public pricing — quotes only. -- **Liquibase**: Not supported. -- **Bytebase**: Will auto detect slow queries and send weekly summary report. Provide an AI-based index advisor to provide query optimization advice. - ![bytebase-slow-query](/content/blog/bytebase-vs-liquibase/bytebase-slow-query.webp) +**Bytebase** has three tiers: Community (free, self-hosted), Pro (cloud-hosted, monthly subscription), and Enterprise (self-hosted or cloud, 14-day free trial). [Full pricing details](https://www.bytebase.com/pricing/). -### Data access control, security and compliance +## When to Choose Liquibase -- **Liquibase**: Not supported. +- Your team is CLI-first and wants to embed migrations directly into existing CI/CD pipelines. +- You need to support a wide range of databases (60+), including niche or legacy systems. +- Your developers already work in Java/JVM ecosystems. +- You need a migration engine, not a governance platform — access control and approval happen in other tools. -- **Bytebase**: With centralized [SQL Editor](https://docs.bytebase.com/sql-editor/overview/), data access is [controlled](https://docs.bytebase.com/security/database-permission/overview/), [reviewed](https://docs.bytebase.com/security/database-permission/query/), [audit-logged](https://docs.bytebase.com/security/audit-log/). Also provide [data masking](https://docs.bytebase.com/sql-editor/mask-data/), [watermark](https://docs.bytebase.com/security/watermark/). +## When to Choose Bytebase - ![bytebase-sql-editor](/content/blog/bytebase-vs-liquibase/bytebase-sql-editor.webp) +- Your team includes DBAs or platform engineers who review database changes before they reach production. +- You need a collaborative workflow — approval flows, role-based access, audit logging — not just a migration CLI. +- You want SQL review, data masking, and access control in one platform instead of stitching together separate tools. +- You're running multi-environment or multi-tenant deployments where batch change orchestration matters. - Bytebase supports [RBAC](https://docs.bytebase.com/concepts/roles-and-permissions/), e.g. developers need to require permission to access or export databases via SQL Editor. - ![bytebase-request-query-export](/content/blog/bytebase-vs-liquibase/bytebase-request-query-export.webp) +## FAQ - Everything that happened within Bytebase will be recorded for audit purposes. - ![bytebase-audit](/content/blog/bytebase-vs-liquibase/bytebase-audit.webp) +### Can I use Liquibase and Bytebase together? - Bytebase also supports [SSO](https://docs.bytebase.com/administration/sso/overview/), [IM webhook](https://docs.bytebase.com/change-database/webhook/) and etc. +They solve different layers. Liquibase handles the migration file format and execution; Bytebase handles collaboration, review, and governance. Most teams pick one, but if you already have a library of Liquibase changelogs, you don't have to throw them away — Bytebase can manage the review and deployment side while Liquibase stays as the execution engine. -## Summary +### Is Liquibase still open source? -To summarize, Bytebase and Liquibase are both viable options for database CI/CD. Liquibase deliver its feature via its CLI, while Bytebase -offers a GUI-based collaboration space. +Liquibase Community switched from Apache 2.0 to the Functional Source License (FSL) in September 2025. FSL is not an OSI-approved open source license — it restricts commercial use in competing products. Each version reverts to Apache 2.0 after two years. Bytebase is MIT licensed, with enterprise features under a commercial license. -As an analogy, **Liquibase is Git for database, and Bytebase is GitHub/GitLab for database**. Git is good for local and personal use. On the other hand, for team development which needs collaboration, review, access control and etc, GitHub/GitLab is more suitable. +### Which tool has better CI/CD integration? + +Depends on what "CI/CD integration" means to you. If it means "I want a command I can add to my Jenkins/GitHub Actions pipeline," Liquibase wins — it's just a CLI call. If it means "I want SQL files in a repo to automatically become reviewed, approved change issues," Bytebase's GitOps integration does that out of the box. + +### What happened to Liquibase Hub? + +Liquibase Hub (the web dashboard) was sunset in April 2023 and never replaced. There's no Liquibase GUI anymore. The Secure edition compensates with structured JSON logs you can pipe into Datadog or Splunk, and a VS Code extension for IDE-based interaction — but if you want a web UI for database changes, Liquibase doesn't have one. + +--- Related comparisons: - [Bytebase vs. Flyway](/blog/bytebase-vs-flyway/) - [Flyway vs. Liquibase](/blog/flyway-vs-liquibase/) +- [Top Database Schema Change Tools](/blog/top-database-schema-change-tool-evolution/)