From 7d22c5df45d641c255b07f2ed6b726066cc4505a Mon Sep 17 00:00:00 2001 From: adela Date: Mon, 30 Mar 2026 17:39:28 +0200 Subject: [PATCH 1/4] update bb vs liquibase --- content/blog/bytebase-vs-liquibase.md | 248 ++++++++++++-------------- 1 file changed, 118 insertions(+), 130 deletions(-) diff --git a/content/blog/bytebase-vs-liquibase.md b/content/blog/bytebase-vs-liquibase.md index 5a873dbcb..287245740 100644 --- a/content/blog/bytebase-vs-liquibase.md +++ b/content/blog/bytebase-vs-liquibase.md @@ -1,210 +1,198 @@ --- 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 and Liquibase both handle database schema migration, but they serve different workflows. Liquibase is a CLI-first migration engine; Bytebase is a GUI-based collaboration platform with built-in access control, SQL review, and audit logging.' 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. +The right tool 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 team where DBAs review every production migration. Here's where the two tools diverge, and where they overlap. -## 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) +Both Bytebase and Liquibase track and apply schema changes to databases, but they come at the problem from different angles. -## What are the differences between Bytebase and Liquibase? +**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 fits into any CI/CD pipeline as a command-line step. The commercial edition — now called **Liquibase Secure** (rebranded from "Liquibase Pro" in September 2025) — adds policy checks, flow files for workflow automation, and structured JSON logging. -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. +**Bytebase** (v3.16, March 2026) is a web-based collaboration platform. Developers create change issues through a GUI, DBAs review and approve them, and the system handles rollout across environments. It wraps schema migration inside a broader workflow that includes SQL review, access control, data masking, and audit logging. -| | 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) | - | ✅ | +The analogy: **Liquibase is Git for databases; Bytebase is GitHub/GitLab for databases.** Git handles version control locally. GitHub/GitLab adds collaboration, review, permissions, and CI/CD on top. -### Product position +## What They Have in Common -- **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) +- 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 uses the MIT-like BSL license for its enterprise features. -- **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) +## Feature Comparison -### Developer interface +| | 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 | -- **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). +### Developer Interface -### Supported databases +**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. -- **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 ... +**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. + +### 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 the databases it supports — features like online schema change, data masking, and AI-powered SQL review work at the database-engine level, not as generic wrappers. ### 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. The Secure edition adds Flow files: reusable YAML-based pipelines that chain multiple Liquibase commands with conditional logic. -- **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. - 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 +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. -- **Liquibase**: Integrate with VCS CI workflow. - ![liquibase-gitlab-gitops](/content/blog/bytebase-vs-liquibase/liquibase-gitlab-gitops.webp) +### Batch Change -- **Bytebase**: Point-and-Click GitOps workflow setup. - ![bytebase-gitlab-gitops](/content/blog/bytebase-vs-liquibase/bytebase-gitlab-gitops.webp) +**Liquibase** doesn't have built-in multi-environment orchestration. You script it yourself — run the CLI against each target database in your pipeline, or use Flow files (Secure) to chain the steps. - 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** 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. - Check the video: [Setting up GitLab VCS integration for Bytebase (GitOps)](https://www.youtube.com/watch?v=51_bL7Vnqww&t=221s) +![Bytebase canary release across tenant databases](/content/blog/bytebase-vs-liquibase/bytebase-canary.webp) - Because Bytebase has the similar project concept as seen in GitLab/GitHub, the GitOps integration is nature to the developers. +### SQL Review and Policy Checks -### SQL auto check +**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). These are primarily structural checks on changelogs rather than SQL-level analysis. -SQL auto check helps developers write less buggy SQL and save DBAs manual review efforts. +![Liquibase policy check configuration](/content/blog/bytebase-vs-liquibase/liquibase-quality-check.webp) -- **Liquibase**: SQL Quality check -- **Bytebase**: [SQL Review](https://docs.bytebase.com/sql-review/overview/) +**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). -#### Supported Plan +![Bytebase SQL review rules configuration](/content/blog/bytebase-vs-liquibase/bytebase-sql-review-rules.webp) -- **Liquibase**: Only in Pro Plan and above -- **Bytebase**: Available in Free Plan +SQL review triggers automatically in three places: -#### Number of rules +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. -- **Liquibase**: 10 general rules -- **Bytebase**: 49 rules for MySQL, 38 rules for PostgreSQL, 18 rules for Oracle ... +Bytebase also includes AI-powered SQL features: natural language to SQL, AI-based query explanation, and automated problem detection — powered by configurable LLMs (GPT-4o, Gemini, Claude). -#### How to configure +### Approval Flow -- **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) +**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. -#### How to trigger +**Bytebase** provides [risk-based custom approval flows](https://www.bytebase.com/docs/administration/custom-approval/). You define rules like "DDL changes to production require DBA approval" or "any change touching more than 3 databases needs manager sign-off." The system auto-classifies risk and routes approvals accordingly. -- **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) +![Bytebase custom approval flow configuration](/content/blog/bytebase-vs-liquibase/bytebase-custom-approval-flow.webp) -- **Bytebase**: Three places to trigger SQL review by default, users may manually integrate it to other scenarios by API as well: +### Rollback - 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) +**Liquibase Community** supports basic rollback — write rollback scripts manually in your changelog and run `liquibase rollback`. **Liquibase Secure** adds granular rollback with automated scripts, rollback reports (added in v4.27.0), and custom rollback logic. - 2. When users query data from SQL Editor. - ![bytebase-sql-editor-review](/content/blog/bytebase-vs-liquibase/bytebase-sql-editor-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. - 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) +### CI/CD Integration -### Approval flow +**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. -- **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** 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. -### Change history +![Bytebase GitOps SQL review in GitLab merge request](/content/blog/bytebase-vs-liquibase/bytebase-gitops-merge.webp) -- **Liquibase**: Simple Database Change Logs. - ![liquibase-logs](/content/blog/bytebase-vs-liquibase/liquibase-logs.webp) +### Change History -- **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) +**Liquibase** tracks changes in the `DATABASECHANGELOG` table — a record of which changesets were applied and when. The Secure edition adds structured JSON logging that integrates with Datadog, Splunk, and other observability platforms. -### Sync schema +**Bytebase** provides a visual change history with schema diffs and links back to the originating issue, reviewer, and approval chain. -- **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) +![Bytebase change history with diff view](/content/blog/bytebase-vs-liquibase/bytebase-change-diff.webp) -### Rollback +### Data Access Control and Audit + +This is where the tools diverge most. **Liquibase** (both editions) has no access control, data masking, or audit logging features — it's a migration tool, not a governance platform. -- **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/). +**Bytebase** includes: -### Schema drift detection +- **[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** (v3.16) — time-limited, approval-gated query access. -- **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) +![Bytebase SQL Editor with controlled data access](/content/blog/bytebase-vs-liquibase/bytebase-sql-editor.webp) -### Slow query detection and advisor +### Pricing -- **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) +**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. -### Data access control, security and compliance +**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/). -- **Liquibase**: Not supported. +## When to Choose Liquibase -- **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/). +- 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-sql-editor](/content/blog/bytebase-vs-liquibase/bytebase-sql-editor.webp) +## When to Choose Bytebase - 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) +- 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. - Everything that happened within Bytebase will be recorded for audit purposes. - ![bytebase-audit](/content/blog/bytebase-vs-liquibase/bytebase-audit.webp) +## FAQ - Bytebase also supports [SSO](https://docs.bytebase.com/administration/sso/overview/), [IM webhook](https://docs.bytebase.com/change-database/webhook/) and etc. +### Can I use Liquibase and Bytebase together? -## Summary +They solve different layers of the problem. Liquibase handles the migration file format and execution engine; Bytebase handles the collaboration, review, and governance workflow. In practice, most teams choose one — but if you already have Liquibase changelogs, you can keep using them while adopting Bytebase for the review and deployment workflow. -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. +### Is Liquibase still open source? -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. +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 core is open source under a similar business source license. + +### Which tool has better CI/CD integration? + +Liquibase has the edge for pure CLI pipelines — it's a single command that drops into any CI/CD system. Bytebase has the edge for GitOps workflows — it natively integrates with GitHub/GitLab and turns committed SQL files into reviewable issues with automated checks. + +### What happened to Liquibase Hub? + +Liquibase Hub (the web dashboard) was sunset in April 2023. It was not replaced with a new GUI. Instead, Liquibase Secure provides observability through structured JSON logs that feed into third-party dashboards like Datadog or Splunk, plus a VS Code extension for IDE-based interaction. + +--- 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/) From 4218f71b8d2fffb5cb007bffdae81b8422307ddb Mon Sep 17 00:00:00 2001 From: adela Date: Mon, 30 Mar 2026 17:42:23 +0200 Subject: [PATCH 2/4] update --- content/blog/bytebase-vs-liquibase.md | 28 +++++++++++++-------------- 1 file changed, 13 insertions(+), 15 deletions(-) diff --git a/content/blog/bytebase-vs-liquibase.md b/content/blog/bytebase-vs-liquibase.md index 287245740..00425a922 100644 --- a/content/blog/bytebase-vs-liquibase.md +++ b/content/blog/bytebase-vs-liquibase.md @@ -10,17 +10,15 @@ keypage: true > If Liquibase is Git, then Bytebase is GitHub/GitLab. -The right tool 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 team where DBAs review every production migration. Here's where the two tools diverge, and where they overlap. +The right tool 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. ## How They Approach Schema Migration -Both Bytebase and Liquibase track and apply schema changes to databases, but they come at the problem from different angles. +**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. -**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 fits into any CI/CD pipeline as a command-line step. The commercial edition — now called **Liquibase Secure** (rebranded from "Liquibase Pro" in September 2025) — adds policy checks, flow files for workflow automation, and structured JSON logging. +**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. -**Bytebase** (v3.16, March 2026) is a web-based collaboration platform. Developers create change issues through a GUI, DBAs review and approve them, and the system handles rollout across environments. It wraps schema migration inside a broader workflow that includes SQL review, access control, data masking, and audit logging. - -The analogy: **Liquibase is Git for databases; Bytebase is GitHub/GitLab for databases.** Git handles version control locally. GitHub/GitLab adds collaboration, review, permissions, and CI/CD on top. +Put another way: **Liquibase is Git for databases; Bytebase is GitHub/GitLab for databases.** ## What They Have in Common @@ -60,7 +58,7 @@ The analogy: **Liquibase is Git for databases; Bytebase is GitHub/GitLab for dat **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 the databases it supports — features like online schema change, data masking, and AI-powered SQL review work at the database-engine level, not as generic wrappers. +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 @@ -104,13 +102,13 @@ SQL review triggers automatically in three places: 2. When querying in the SQL Editor. 3. In GitOps — before SQL is merged into the main branch. -Bytebase also includes AI-powered SQL features: natural language to SQL, AI-based query explanation, and automated problem detection — powered by configurable LLMs (GPT-4o, Gemini, Claude). +Bytebase also has AI features in the SQL Editor — text-to-SQL, query explanation, and problem detection. You bring your own LLM key. ### Approval Flow **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. -**Bytebase** provides [risk-based custom approval flows](https://www.bytebase.com/docs/administration/custom-approval/). You define rules like "DDL changes to production require DBA approval" or "any change touching more than 3 databases needs manager sign-off." The system auto-classifies risk and routes approvals accordingly. +**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. ![Bytebase custom approval flow configuration](/content/blog/bytebase-vs-liquibase/bytebase-custom-approval-flow.webp) @@ -138,16 +136,16 @@ Bytebase also includes AI-powered SQL features: natural language to SQL, AI-base ### Data Access Control and Audit -This is where the tools diverge most. **Liquibase** (both editions) has no access control, data masking, or audit logging features — it's a migration tool, not a governance platform. +**Liquibase** doesn't touch this area — neither edition has access control, data masking, or audit logging. It's a migration engine, full stop. -**Bytebase** includes: +**Bytebase** bundles all of this: - **[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** (v3.16) — time-limited, approval-gated query access. +- **Just-In-Time (JIT) data access** (new in v3.16) — developers request temporary query access, a reviewer approves it, and access expires automatically. ![Bytebase SQL Editor with controlled data access](/content/blog/bytebase-vs-liquibase/bytebase-sql-editor.webp) @@ -175,7 +173,7 @@ This is where the tools diverge most. **Liquibase** (both editions) has no acces ### Can I use Liquibase and Bytebase together? -They solve different layers of the problem. Liquibase handles the migration file format and execution engine; Bytebase handles the collaboration, review, and governance workflow. In practice, most teams choose one — but if you already have Liquibase changelogs, you can keep using them while adopting Bytebase for the review and deployment workflow. +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. ### Is Liquibase still open source? @@ -183,11 +181,11 @@ Liquibase Community switched from Apache 2.0 to the Functional Source License (F ### Which tool has better CI/CD integration? -Liquibase has the edge for pure CLI pipelines — it's a single command that drops into any CI/CD system. Bytebase has the edge for GitOps workflows — it natively integrates with GitHub/GitLab and turns committed SQL files into reviewable issues with automated checks. +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. It was not replaced with a new GUI. Instead, Liquibase Secure provides observability through structured JSON logs that feed into third-party dashboards like Datadog or Splunk, plus a VS Code extension for IDE-based interaction. +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. --- From 91cb54d891d126e84b407db1fd864e1415b3a65b Mon Sep 17 00:00:00 2001 From: adela Date: Mon, 30 Mar 2026 18:05:38 +0200 Subject: [PATCH 3/4] update --- content/blog/bytebase-vs-liquibase.md | 22 ++++++++++------------ 1 file changed, 10 insertions(+), 12 deletions(-) diff --git a/content/blog/bytebase-vs-liquibase.md b/content/blog/bytebase-vs-liquibase.md index 00425a922..3af57a242 100644 --- a/content/blog/bytebase-vs-liquibase.md +++ b/content/blog/bytebase-vs-liquibase.md @@ -4,13 +4,13 @@ author: Cayden updated_at: 2026/03/30 12:00:00 feature_image: /content/blog/bytebase-vs-liquibase/bytebase-vs-liquibase-banner.webp tags: Comparison -description: 'Bytebase and Liquibase both handle database schema migration, but they serve different workflows. Liquibase is a CLI-first migration engine; Bytebase is a GUI-based collaboration platform with built-in access control, SQL review, and audit logging.' +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. -The right tool 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. +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. ## How They Approach Schema Migration @@ -29,7 +29,7 @@ Put another way: **Liquibase is Git for databases; Bytebase is GitHub/GitLab for - 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 uses the MIT-like BSL license for its enterprise features. -## Feature Comparison +## Key Differences Between Bytebase and Liquibase | | Liquibase (Community) | Liquibase Secure | Bytebase | | ------------------------------ | --------------------- | ---------------- | -------- | @@ -68,19 +68,17 @@ Liquibase covers more databases. Bytebase goes deeper on each one it supports ### Change Execution -**Liquibase** uses changelogs — files in XML, YAML, SQL, or JSON that define database changes. You run `liquibase update` to apply them. The Secure edition adds Flow files: reusable YAML-based pipelines that chain multiple Liquibase commands with conditional logic. +**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. ![Liquibase changelog definition](/content/blog/bytebase-vs-liquibase/liquibase-changelog.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** 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. ![Bytebase issue-based change workflow](/content/blog/bytebase-vs-liquibase/bytebase-issue.webp) -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. - ### Batch Change -**Liquibase** doesn't have built-in multi-environment orchestration. You script it yourself — run the CLI against each target database in your pipeline, or use Flow files (Secure) to chain the steps. +**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** 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. @@ -88,7 +86,7 @@ Bytebase also supports online schema change for MySQL — large table migrations ### SQL Review and Policy Checks -**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). These are primarily structural checks on changelogs rather than SQL-level analysis. +**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. ![Liquibase policy check configuration](/content/blog/bytebase-vs-liquibase/liquibase-quality-check.webp) @@ -114,7 +112,7 @@ Bytebase also has AI features in the SQL Editor — text-to-SQL, query explanati ### Rollback -**Liquibase Community** supports basic rollback — write rollback scripts manually in your changelog and run `liquibase rollback`. **Liquibase Secure** adds granular rollback with automated scripts, rollback reports (added in v4.27.0), and custom rollback logic. +**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. **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. @@ -128,7 +126,7 @@ Bytebase also has AI features in the SQL Editor — text-to-SQL, query explanati ### Change History -**Liquibase** tracks changes in the `DATABASECHANGELOG` table — a record of which changesets were applied and when. The Secure edition adds structured JSON logging that integrates with Datadog, Splunk, and other observability platforms. +**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** provides a visual change history with schema diffs and links back to the originating issue, reviewer, and approval chain. @@ -136,7 +134,7 @@ Bytebase also has AI features in the SQL Editor — text-to-SQL, query explanati ### Data Access Control and Audit -**Liquibase** doesn't touch this area — neither edition has access control, data masking, or audit logging. It's a migration engine, full stop. +**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: From ee0a01bed2f7e37290efa6cde75c1b6a08c2e5ce Mon Sep 17 00:00:00 2001 From: adela Date: Wed, 1 Apr 2026 15:51:13 +0200 Subject: [PATCH 4/4] update --- content/blog/bytebase-vs-liquibase.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/content/blog/bytebase-vs-liquibase.md b/content/blog/bytebase-vs-liquibase.md index 3af57a242..53dd6a753 100644 --- a/content/blog/bytebase-vs-liquibase.md +++ b/content/blog/bytebase-vs-liquibase.md @@ -27,7 +27,7 @@ Put another way: **Liquibase is Git for databases; Bytebase is GitHub/GitLab for - 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 uses the MIT-like BSL license for its enterprise features. +- 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. ## Key Differences Between Bytebase and Liquibase @@ -175,7 +175,7 @@ They solve different layers. Liquibase handles the migration file format and exe ### Is Liquibase still open source? -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 core is open source under a similar business source license. +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. ### Which tool has better CI/CD integration?