Our proposed database review workflow: static SQL rules enforce policy, Jev assesses contextual risk, an LLM explains the findings, and a human approves.

Testing Jev on Database Change and Access Workflows

Oracle SQL review tools compared: PLSQL_WARNINGS, SQLcl CODESCAN, dbLinter, SonarQube, SQLFluff, Toad, Flyway, utPLSQL, and where Bytebase's approval gate fits.

Top Oracle SQL Review Tools in 2026

A SQL Server schema migration tool moves a database from one schema version to the next. This guide reviews 8 tools, migration-based and state-based.

Top 8 SQL Server Schema Migration Tools in 2026

Streaming production to a warehouse and masking in dbt masks for analysts, not operators. Where cleartext survives, and what production masking needs.

Data Masking Architecture: Why the Warehouse Pattern Leaves Production Exposed

SQL Server SQL review tools compared: the built-in SR rules in SQL projects, SqlServer.Rules' 140+ T-SQL checks, SQLFluff, tSQLt, Redgate, and where Bytebase's approval gate fits.

Top SQL Server SQL Review Tools in 2026

A SQL Server schema compare tool diffs two databases and generates the T-SQL to reconcile them. This 2026 guide reviews 8 tools and what each one costs.

Top 8 SQL Server Schema Compare Tools to Diff and Sync Databases in 2026

MySQL SQL review tools compared: SQLFluff for style, Skeema for schema-design linting, SOAR for query anti-patterns, and where Bytebase fits as the approval layer.

Top MySQL SQL Review and Lint Tools in 2026

How PostgreSQL evolved from blocking DDL toward concurrent operations, metadata-only changes, and deferred constraint validation.

The Evolution of PostgreSQL Schema Migrations: Less Locking, Less Rewriting, Less Downtime

Four missing primitives: delegation, attenuation, immutable application context, and labels on data. GRANT and RLS are a good policy engine, but nothing trustworthy feeds it when the caller is an AI agent. Oracle and SQL Server solved pieces of this; Postgres has none of it.

What Postgres is Missing for AI Agents

Postgres SQL review tools compared: SQLFluff for style, Squawk for migration safety, plpgsql_check and pgTAP, and where Bytebase's rule engine overlaps them with an approval gate attached.

Top Dynamic Data Masking Tools in 2026

Zero trust for databases extends identity and network controls to SQL statements, query results, data changes, and schema changes.

Zero Trust for Databases: From Access Control to SQL Control

Snowflake and the data warehouses can tag any database object with structured metadata and drive masking from it. Almost no production database can. In the LLM era, that inline, self-contained context is exactly what agents need.

Object Tagging: The AI Feature Almost Every Production Database Skipped

Database governance lives upstream, on the production database. Here is how to actually govern the source: reviewed changes, scoped access, codified policy, and audit where the data is born.

How to Govern Data at the Source: A Guide to Upstream Database Governance

Data governance and database governance are four letters apart and constantly conflated. They are different disciplines, owned by different teams, solved by different tools. Here is the dividing line.

Data Governance vs. Database Governance: The Difference Is the Base

PopSQL shuts down on September 1, 2026. Compare the top PopSQL alternatives for team SQL editing, dashboards, and governed database access before you migrate.

Top PopSQL Alternatives 2026: Where to Migrate Before the Shutdown

Money software is judged not on whether the feature works, but on what the database can prove eighteen months later. Fintech database governance through three principles: no invented data, no lost data, no trust.

Database Governance for Fintech: Guarding the Ledger

PostgreSQL has no ADD COLUMN ... AFTER. The reason one little number in a system catalog turned a "simple" feature into a decade-long engineering saga, and what you can do about it today.

Why It's So Hard to Add a Column in the Middle of a PostgreSQL Table

The static data masking tools that produce safe non-production data, Delphix, Tonic.ai, and greenmask compared, plus how to roll your own when no tool fits.

Static Data Masking Tools (and How to Roll Your Own)

Notes on the MySQL 9.7 LTS release: Hypergraph Optimizer in Community, JSON Duality View DML, Group Replication observability, and Dynamic Data Masking for Enterprise.

Notes on the MySQL 9.7 LTS release

PostgreSQL 19 features I'm excited about: planner advisor framework, DDL extraction, online REPACK, pg_stat_recovery, parallel autovacuum, sequence sync, and 64-bit MultiXact.

PostgreSQL 19 features I'm excited about

What SOC 2 compliance audits actually want from your database audit log: not 'logging enabled' but evidence your auditor will accept. Lessons from going through our own audit.

SOC 2 Audit Log Requirements: Lessons From Our Own Audit

A practical look at what SOX Section 404 expects from database changes: the four ITGC domains, the six questions auditors actually ask, and how to make compliance evidence a byproduct of your workflow.

Database Change Management for SOX Compliance

A look at 10 data management tools developers and data engineers actually use in 2026: GUI clients, schema migration, pipelines, and analytics, with pricing for each.

Top 10 Data Management Tools in 2026

The best SQL editors built exclusively for PostgreSQL: what each one is good at, who it fits, and when a Postgres-only tool beats a multi-database client.

Enterprise Text-to-SQL: Context, Evaluation, and Governance

A practical look at the database deployment tools DevOps teams actually use in 2026 — Flyway, Liquibase, Atlas, pgschema, Octopus Deploy, Harness, DBmaestro and Bytebase — sorted by how each one defines, applies, and coordinates schema changes.

Database Deployment Tools for DevOps Teams in 2026

Postgres 19 widens MultiXactOffset to 64 bits, eliminating the hidden 4 billion member limit that caused catastrophic outages for high-concurrency workloads.

Postgres 19 Feature Preview: 64-bit MultiXactOffset

How to run MySQL schema migrations without blocking queries or causing downtime, covering the MySQL-specific behaviors that bite in production and the tools that work around them.

MySQL Schema Migration Best Practice

Postgres 19 introduces automatic sequence synchronization for logical replication, eliminating manual tracking and making major version upgrades and failover significantly easier.

Postgres 19 Feature Preview: Sequence Synchronization for Logical Replication

A guide to open source sensitive data discovery tools, from NLP libraries like spaCy and Microsoft Presidio to multi-source scanners like Hawk-Eye and full metadata platforms like OpenMetadata.

Top Open Source Sensitive Data Discovery Tools in 2026

Six open-source PostgreSQL backup tools compared for 2026, with the language, license, interface, and best-fit use case for each, plus a note on which ones are still maintained.

What's New in PostgreSQL 18: A Developer's Perspective

A look at the open-source ways to add authentication and authorization to a Postgres app in 2025, from all-in-one platforms to libraries, identity servers, and the minimalist JWT-to-RLS pattern, with a "best for" note on each.

Features I Wish Postgres Had but MySQL Already Has

Areas where PostgreSQL shines and MySQL falls short.

Features I Wish MySQL Had but Postgres Already Has

Compare the top free, open-source database schema diagram tools in 2026 (DrawDB, ChartDB, Azimutt, and Liam ERD) by database support, workflow, and project momentum.

Top 4 Free, Open Source Database Schema Diagram Tools in 2026

An overview of the most popular text-to-SQL AI tools in 2026, including DataGrip, TablePlus, Vanna.ai, SQLAI.ai, DBHub MCP server, and Bytebase SQL Editor. Compare features and capabilities to find the best SQL AI assistant for your workflow.

Top 6 Text-to-SQL Query Tools in 2026

Evaluate several TypeScript ORMs, and help you to choose the right one for 2026

Top TypeScript ORM 2026

PostgreSQL 18 features and what they change for running production databases.

What's New in PostgreSQL 18: A DBA's Perspective

Explore alternatives to Amazon RDS in 2026: Aurora, Cloud SQL, AlloyDB, Azure, DigitalOcean, Aiven, TigerData, and the serverless Postgres providers, with cost comparisons.

RDS Alternatives in 2026

Infrastructure as Code security tools help organizations identify vulnerabilities and misconfigurations in their infrastructure definitions. This post explores the top open-source IaC security tools available in 2025.

Top Open Source Infrastructure as Code (IaC) Security Tools in 2025

Compare the price of the mainstream managed PostgreSQL hosting providers

PostgreSQL Hosting Options in 2026: Pricing Comparison

Database governance controls how production databases are changed and accessed; data governance catalogs what lands downstream. The terms are conflated in every search, so this post covers the top open-source tools on both sides of the line.

Top Open Source Database Governance Tools in 2026

Workflow orchestration tools help coordinate tasks, handle errors, and monitor execution processes. In this post, we are taking a look at open source workflow orchestration options

Top Open Source Workflow Orchestration Tools in 2025

Compare the price of the mainstream managed MySQL hosting providers

MySQL Hosting Options in 2026: Pricing Comparison

A comprehensive guide to the best open-source Kubernetes cluster management tools in 2025, including Argo CD, Karmada, Sveltos, and Plural.

Top 4 Open Source Kubernetes Cluster Management Tools in 2025

Review the state of the Golang ORM and query builder in 2026

Choose the Right Golang ORM or Query Builder in 2026

Overview of MySQL 9 features with spicy comments

What's New in MySQL 9 - a DBA's Perspective

SQL clients makes it safer and easier to manage databases. In this post, we are taking a look at open source SQL clients options for you to try in 2024.

Top Open-Source SQL Parsers in 2025

A comprehensive reference guide to standard port numbers used by popular database systems in 2025

Common Database Port Numbers in 2025

Explore the leading Terraform UI tools of 2026 that enhance IaC workflows with visualization, collaboration, and governance features to streamline infrastructure management.

Top 4 Terraform UI Tools 2026

A comprehensive guide to the best free and open-source PostgreSQL EXPLAIN tools for query performance analysis, including built-in extensions, online visualizers, and integrated GUI solutions.

Top Free, Open Source Postgres Explain Tool to Analyze Database 2025

Top open-source Kubernetes dashboard solutions include K9s, Lens, and KubeDashboard.

Top Free, Open Source Kubernetes Dashboard in 2026

In this post, we will review the top 5 open source Terraform tools for 2025.

Top 5 Open Source Terraform Tools for 2025

A Postgres schema compare tool diffs and synchronizes schemas between PostgreSQL databases. This 2026 guide reviews the top 6 tools — pg-schema-diff, Atlas, Liquibase, pgAdmin, Navicat, and Bytebase — and how to choose.

Top 6 Open Source Infrastructure as Code (IaC) Tools 2025

How to Become a Platform Engineer in 6 months?

SQL editor with built-in AI streamlines database management, making SQL development faster, more accurate, and accessible to users of all skill levels.

Top 3 Free SQL Editors with Built-in AI

An extensive list of PostgreSQL SQL Review and Style Guide.

PostgreSQL SQL Review and Style Guide

Compare the best SQL Server monitoring tools for 2026 — free and paid. Includes SSMS built-in SQL monitors, open-source MSSQL monitoring tools (DBA Dash, SQLWATCH, Opserver), and commercial SQL performance monitoring solutions (Redgate, Datadog).

Top SQL Server Monitoring Tools: Best SQL Performance Monitors in 2026

The open source, self-hostable, web-based SQL editors compared honestly, with per-tool verdicts and a fresh repository-activity check.

Top 5 Open Source, Online SQL Editors You can Self-host

The top database DevOps tools in 2026 by category: CI/CD, SQL lint, backup, data masking, observability, access management, secrets, and all-in-one.

Top Database DevOps Tools in 2026

Introduce the advanced tools for platform engineering. Covering CD, security, workflow orchestration, database development workflow, and internal development portal.

How to Pick Platform Engineering Tools in 2025 - Advanced Guide

Introduce the essential tools for platform engineering. Covering code hosting, CI/CD, observability, resource provisioning, and secret management.

How to Pick Platform Engineering Tools in 2025 - Essential Guide

Bastion gates connections. ITSM gates approval. PAM gates credentials. Three layers, three tools, one gap at execution — and what an integrated platform replaces.

Securing Database Change: From Bastion to Integrated Platforms

How OpenAI and DeepSeek designs SSN database schema.

OpenAI vs. DeepSeek: SSN Database Schema Design

DevSecOps tools empower teams to seamlessly integrate security into every phase of the software development lifecycle, fostering the adoption of DevSecOps practices.

Top DevSecOps Tools for 2025

What happened in the database tooling landscape in 2024.

Database Tools in 2024: A Year in Review

Some of the craziest database security vulnerabilities uncovered in DBAs' career

Database security vulnerabilities are the craziest

Due to Docker's recent requirement for a paid subscription for professional use, people began searching for alternatives. Right alternatives for you will depend on your specific needs and requirements.

Top 4 Free Docker Desktop Alternatives 2026

What are the top Postgres extensions you may need to enhance your Postgres instance in 2026.

Why Managed Database Service is not Enough

Six levels of database automation, named after the autonomous-driving framework. From L0 manual SQL to L5 self-healing — and where most teams plateau.

The 6 Levels of Database Automation

When team wants to enforce a process for database change management. A quick approach is to reuse their existing ITSM system such as Jira. Let's review how a typical Jira workflow looks like and its inherent limitations.

Hope Is Not a Strategy: Why Jira Falls Short for Database Change

A list of features I wish PostgreSQL had. It is mainly around improving development workflow and inspired by Git. While acquiring Git-like behavior is challenging in database because of the stateful nature.

Features I wish PostgreSQL had as a developer

In this post, we are reviewing several open-source GitOps tools.

Top Open Source GitOps Tools in 2025

When schema migration outage happens, who should be more responsible in order to prevent future incidents?

Schema Migration Outage: Author or Reviewer's Fault?

The "Modern Snowflake Stack" refers to the set of technologies and tools built around Snowflake for data ingestion, transformation, security, and analytics. First mapped in early 2024, refreshed for 2026 after a wave of mergers and acquisitions reshuffled nearly every layer.

Modern Snowflake Stack in 2026

What are the top open source MySQL schema migration tools in 2026 - Skeema, Liquibase, Flyway, and Bytebase compared.

Top Open Source MySQL Migration Tools in 2026

This article explores leading database security tools designed to shield your data from varied risks.

Top Database Security Tools

A comparison of the top 5 MySQL GUI clients in 2026: MySQL Workbench, DBeaver, TablePlus, Beekeeper Studio, and Navicat.

Top 5 MySQL GUI Clients in 2026

The top open source Postgres migration tools in 2026: Flyway, Liquibase, Atlas, Sqitch, DBLift, pgroll, graphile-migrate, pgschema, and Bytebase compared.

How many DBAs should a company hire

DORA recently released its annual State of DevOps 2023 report. Bytebase is a Database CI/CD tool for DBAs and DevOps teams, and we are diving deep into the State of DevOps Report.

Notes on the DORA 2023 State of DevOps Report

DataGrip is a database IDE developed by JetBrains and closely integrated with the JetBrains ecosystem. If you prefer a dedicated database GUI, here are the top DataGrip alternatives in 2026.

Top DataGrip Alternatives 2026

If you work exclusively with MySQL, MySQL Workbench is an excellent choice for a database GUI, but if you work with multiple databases, you need to look elsewhere. This article highlights five database GUI alternatives for MySQL Workbench.

Top MySQL Workbench Alternatives 2026

pgAdmin is the default Postgres GUI, but it is not the only one. Here are the top pgAdmin alternatives in 2026.

Top pgAdmin Alternatives 2026

Navicat is a long-established database GUI, but it falls short in multi-user scenarios where team collaboration and centralized control are needed. Here are the top Navicat alternatives in 2026.

Top Navicat Alternatives 2026

DBeaver is one of the most popular database management tools. If it doesn't fulfill your requirements or you want to try something new, here are the top DBeaver alternatives in 2026.

Top DBeaver Alternatives 2026

A Postgres GUI client gives you a visual interface to query, design, and administer PostgreSQL — instead of doing everything from psql. Here are the 7 most useful in 2026, with the trade-offs that decide which one fits your workflow.

Understanding Google Cloud SQL Pricing

A MySQL schema compare tool diffs and synchronizes schemas between MySQL databases. This 2026 guide reviews 7 tools, what each one licenses, where each one stops, and how to choose.

Top 7 MySQL Schema Compare Tools to Diff and Sync Databases in 2026

Compare the top database schema migration tools of 2026: Flyway, Liquibase, Atlas, Alembic, Skeema, goose, dbmate, Prisma, and Bytebase, plus a decision table.

Top Database Schema Migration Tools to Avoid Change Outage 2026

What happened in database industry in 2022.

Database Review 2022 and 2023 Prediction

The best free, open-source SQL clients and database management software in 2026. Compare DBeaver, Beekeeper Studio, DbGate, HeidiSQL, and Bytebase — free database programs for Mac, Windows, and Linux — on license, engine coverage, and team access.

Top 5 Free, Open Source SQL Clients and Database Management Tools (2026)

To manually spin up several different kinds (and versions) of database instances for testing can be gruesome. Here are some free tools to help you start a local database instance on Mac.

Top 3 Free Tools to Start a Local Database Instance on Mac

Real talk on whether strict SQL review and schema conventions actually help — with answers from working developers and DBAs.

Is SQL Review Necessary? Real Talk From Developers


<HintBlock type="info">

This post is maintained by Bytebase, an open-source database governance platform. We update the post periodically.

</HintBlock>

PostgreSQL keeps topping the popularity charts (DB-Engines named it DBMS of the Year in 2023, runner-up in 2024). And yet doing a schema migration in Postgres is still a PITA. A small industry of tools has grown up to make it less so, and they don't all solve the same problem. The ones that apply your SQL fall into three camps: the versioned-migration tools that run your scripts in order, the declarative tools that diff a desired schema against the live one, and the zero-downtime specialists that rewrite big tables without taking a lock. Bytebase is the odd one out: it can run the migration too, but what it adds is the governance layer around the change.

Here's the full list, all open source and, with the one exception I flag under Reshape, actively maintained as of September 2026:

- [Flyway](#flyway)
- [Liquibase](#liquibase)
- [Sqitch](#sqitch)
- [graphile-migrate](#graphile-migrate)
- [DBLift](#dblift)
- [Atlas](#atlas)
- [pgschema](#pgschema)
- [pgroll](#pgroll)
- [Reshape](#reshape)
- [Bytebase](#bytebase)

## The versioned camp

### Flyway

[Flyway](https://github.com/flyway/flyway) is the one your CI probably already runs. You write each change as a numbered SQL file (`V1__init.sql`, `V2__add_index.sql`), Flyway applies them in order, and it records what ran in a `flyway_schema_history` table. It's Java, and ships as a CLI, a library, Maven and Gradle plugins, and a Docker image.

Redgate bought Flyway in 2019 and, to their credit, kept the developer-first feel while stacking paid tiers on top (Enterprise adds undo, dry runs, and drift checks). The open source Community edition still covers the core job. It's on the 13.x line now. ~10,100 stars.

The honest limitation: Flyway runs migrations, full stop. Review, approval, and audit are yours to solve elsewhere. More in [Bytebase vs. Flyway](/blog/bytebase-vs-flyway/).

### Liquibase

[Liquibase](https://github.com/liquibase/liquibase) is the enterprise incumbent. Changes live as a `changeset` inside a `changelog`, and because of its Java roots the canonical format is XML (YAML, JSON, and plain SQL came later).

![liquibase-xml](/content/blog/_shared/liquibase-xml.webp)

Liquibase 5.0 shipped in early 2026, folding the old Pro capabilities and a reworked flow engine into the main line. The core stays free; Pro and Secure tiers add policy checks and reporting. ~5,600 stars.

To be honest, the XML is the part I'd push back on. It takes a paragraph of markup to add one column. If your shop already standardized on Liquibase changelogs, it's a fine default and the integrations are unmatched. If you're starting fresh, that verbosity is a tax you're choosing to pay. More in [Bytebase vs. Liquibase](/blog/bytebase-vs-liquibase/).

### Sqitch

[Sqitch](https://github.com/sqitchers/sqitch) is for people who just want SQL and nothing else. No version numbers, no framework. You write three scripts per change (deploy, revert, verify), and Sqitch tracks dependencies between changes instead of a linear counter. Perl, MIT-licensed, no paid tier. ~3,200 stars.

The dependency model is the clever bit. Declare that change B depends on A, and Sqitch refuses to deploy B first. It rides directly on `psql`, so there's almost nothing to learn if you already write SQL by hand. FWIW, this is what I'd reach for when a project wants reversible plain-SQL migrations without a heavyweight.

### graphile-migrate

[graphile-migrate](https://github.com/graphile/migrate) is the framework-native member of the versioned camp: [opinionated](https://github.com/graphile/migrate?tab=readme-ov-file#opinions), roll-forward, and written in TypeScript for the Graphile and PostGraphile crowd. Its signature is a git-like local loop: `graphile-migrate commit` moves the current migration into the `committed/` folder and resets a shadow database, and `uncommit` backs it out while you iterate. ~840 stars.

If you're not already in PostGraphile land, there's little reason to reach for it. If you are, it fits like a native.

### DBLift

[DBLift](https://github.com/dblift/dblift) is the only Python tool on this list, built for one annoyance: a Python team keeping a JVM patched just so Flyway can apply SQL files. DBLift reads the same `V1__init.sql` naming convention, installs with `pip`, and runs as a CLI or as a library inside your app or your pytest suite. `dblift import-flyway` copies an existing `flyway_schema_history`, so switching doesn't reset anyone's history.

Undo scripts and a dry run that prints the exact SQL ship in the Apache-2.0 package. Flyway keeps both in its paid edition. A Pro tier adds SQL linting and drift detection. One default to know before you migrate: DBLift applies out-of-order migrations unless you pass `--strict`, the opposite of Flyway.

Where it stands: the repo went public in June 2026 and has a handful of stars, against Flyway's decade of production mileage. _Alternatives:_ Alembic, if your schema is driven by SQLAlchemy models and you want autogenerated revisions instead of hand-written SQL.

## The declarative camp

### Atlas

[Atlas](https://github.com/ariga/atlas) brings the Terraform model to database schema. You declare the schema you want (in HCL, SQL, or straight from an ORM), Atlas plans the diff against the live database, then applies it. It also does versioned migrations, so you can work declaratively and still generate files for review. Go, from the Ariga team.

The core is Apache-2.0. Atlas Pro, sold through Atlas Cloud, adds linting, drift detection, and a schema registry. ~8,700 stars and moving fast. If you love `terraform plan`, you'll feel at home immediately. One thing to weigh: its diffing overlaps with the dedicated [Postgres schema compare tools](/blog/top-postgres-schema-compare-tools/), so decide up front whether you want one tool doing both jobs.

### pgschema

[pgschema](https://github.com/pgplex/pgschema) (Go) does the same declarative, Terraform-like flow, but Postgres-only:

- **Dump** a Postgres schema in a developer-friendly format
- **Edit** it to the desired state
- **Plan** the change by diffing desired against current
- **Apply** with concurrent-change detection, transaction-adaptive execution, and lock-timeout control

Postgres-only is the feature. Instead of the lowest-common-denominator abstraction a multi-engine tool settles for, it diffs 16 kinds of schema object across Postgres 14 through 18, including the ones generic tools tend to skip: row-level security policies, partitioned tables, constraint triggers, domains, default privileges, and column-level grants. It launched in mid-2025 and is already past 1,000 stars and on the 1.x line.

## The zero-downtime specialists

### pgroll

[pgroll](https://github.com/xataio/pgroll) (Go, from [Xata](https://xata.io/)) tackles the genuinely hard one: schema change with zero downtime. It uses the expand/contract pattern, keeping both the old and new schema valid behind versioned views so the old and new versions of your app run side by side during a rollout.

![pgroll-migration-flow](/content/blog/top-open-source-postgres-migration-tools/pgroll-migration-flow.webp)

Apache-2.0, actively developed, ~6,600 stars. This is the tool you add the day a plain `ALTER TABLE` on a hot 40-million-row table would lock writes long enough to page someone. You don't need it until you very much do.

### Reshape

[Reshape](https://github.com/fabianlindfors/reshape) got there first with the same view-based, zero-downtime idea, written in Rust. A migration runs in three phases: `start` sets up the views and triggers so both schemas work, you roll out the app gradually, and `complete` drops the old schema.

![reshape](/content/blog/top-open-source-postgres-migration-tools/reshape.webp)

The caveat: the author has moved on to [ReshapeDB](https://reshapedb.com/), a database built from the ground up around zero-downtime migrations, and Reshape itself (~1,900 stars) now sees less activity than pgroll. It's worth reading to understand expand/contract. But if you're choosing today, pgroll is the more actively maintained take on the same trick.

## The governance layer

### Bytebase

Full disclosure: [Bytebase](https://github.com/bytebase/bytebase) is ours, so read this with the appropriate grain of salt. Everything above applies SQL. Bytebase governs the change around it. Think GitHub or GitLab for database changes, where developers and DBAs collaborate through a GUI or a GitOps workflow. Go and TypeScript, ~14,500 stars.

![issue-detail](/content/blog/top-open-source-postgres-migration-tools/issue-detail.webp)

It runs configurable SQL review rules to catch anti-patterns, a missing `NOT NULL` or a dangerous DDL statement, before a change reaches production.

![sql-review](/content/blog/top-open-source-postgres-migration-tools/sql-review.webp)

It also keeps change history, approval flows, and an audit log, plus a SQL Editor with data access control and dynamic data masking on the query path.

![sql-editor](/content/blog/top-open-source-postgres-migration-tools/sql-editor.webp)

Bytebase can be the whole pipeline, from the SQL a developer submits to the rollout across environments, or it can work next to the migration tool your CI already runs. If your problem isn't running the SQL but knowing who approved a change and whether what ran matched what was approved, that's the gap it fills. See [how to build a CI/CD pipeline for database schema migration](/blog/how-to-build-cicd-pipeline-for-database-schema-migration/) and [database version control](/blog/database-version-control/).

## Summary

| Tool             | Approach                    | Interface     | Language        | Postgres-only | Zero-downtime     | Licensing model        |
| ---------------- | --------------------------- | ------------- | --------------- | ------------- | ----------------- | ---------------------- |
| Flyway           | Versioned SQL               | CLI + library | Java            | No            | Edition-dependent | OSS core + paid        |
| Liquibase        | Versioned changesets        | CLI + library | Java            | No            | No                | OSS core + paid        |
| Sqitch           | Versioned, dependency-based | CLI           | Perl            | No            | No                | MIT                    |
| graphile-migrate | Roll-forward SQL            | CLI           | TypeScript      | Yes           | No                | MIT                    |
| DBLift           | Versioned SQL               | CLI + library | Python          | No            | No                | Apache-2.0 core + paid |
| Atlas            | Declarative + versioned     | CLI           | Go              | No            | Partial           | Apache-2.0 core + paid |
| pgschema         | Declarative                 | CLI           | Go              | Yes           | Lock-aware apply  | Apache-2.0             |
| pgroll           | Expand/contract             | CLI           | Go              | Yes           | Yes               | Apache-2.0             |
| Reshape          | Expand/contract             | CLI           | Rust            | Yes           | Yes               | MIT                    |
| Bytebase         | Governed platform           | GUI + GitOps  | Go + TypeScript | No            | No                | OSS core + paid        |

## My take

So which one? If I'm starting a new Postgres project today, I'd use Sqitch or Flyway for everyday versioned migrations. If your team thinks in desired state, pgschema is my pick for a Postgres-only shop, and Atlas if you need the same model across several engines.

And once more than a couple of people are touching production, the bottleneck stops being which tool applies the SQL. It becomes who's allowed to run a change, who approved it, and what actually ran. That's the unglamorous part, and none of the tools above do it. They shouldn't. Applying SQL is a different job.

It matters more now that AI agents write migrations too. An agent can produce a plausible `ALTER TABLE` in seconds, and it will never be the one paged when that statement locks a hot table. So it needs what any engineer needs: its own identity instead of a shared credential, a review gate before production, and an audit trail afterwards. That governance layer is what we built [Bytebase](#bytebase) to provide, for people and agents alike.



It's the beginning of the year and companies are planning their HCs for the new year. With the advent of advanced database platforms and tooling, the industry is trending towards decreasing or even eliminating DBAs (Database Administrators). We have been working with companies of all sizes in the past and below share our thoughts.

To clarify, the DBA role we are talking about is the role dedicated to database operational tasks. The person may hold different titles, including Database Administrator (DBA), Database Reliability Engineer (DRE), SRE, Platform Engineer, DevOps Engineer, etc.

## < 30 - No need to have a dedicated DBA

When the company's engineering HC is below 30, there is no need for a DBA. Usually, the backend engineers, DevOps / Platform engineers, or TLs in the team take up part-time responsibilities at this stage.

At this stage, it is recommended to choose a cloud database hosting service, because it comes with out-of-the-box tooling such as monitoring and backup. As for daily changes to the database, you can introduce tools or not. If you don't introduce it, the TL can cope with it through design review, code review, etc.

## 30 to 50 - First DBA and tooling

The database-related tasks have increased and part-time can not sustain. At the same time, because the business is beginning to take off, it is necessary to pave the way for longer-term data quality and governance. Therefore, at this stage, the company needs to consider introducing a dedicated DBA to take charge of database-related matters.

With the introduction of the first DBA, the introduction of relevant database tools should also be considered. As for the exact timing, one is to look at the proportion of the database-related workload, 50% is the watermark. Another is to see whether more than 50% of the high-priority work items of the entire engineering org are database-related. Of course, another indicator is the number of database-triggered outages. If there have been incidents in two consecutive months, then the introduction of a DBA is imminent.

Usually at this stage, the company still has difficulty attracting a good DBA, and that's OK. The first DBA does not need to build a system, just establishes a process. The process is divided into two parts, one is to formalize the database's operational and maintenance tasks, such as monitoring, periodic fleet inspection, and backup. The other part is to standardize the process of database access and change management. Both things need to leverage tools. The former usually leverages the cloud platform with the proper configuration; the latter requires 3rd party tools such as [Bytebase](https://docs.bytebase.com/introduction/what-is-bytebase/) to standardize the process (e.g. Require manual review before changing the database in prod).

![change-query-secure-govern-database-all-in-one](/content/blog/_shared/db-scheme-lg.png)

At this stage, it is also necessary for the engineering lead to be supportive. Because the introduction of DBA and process will limit the developers' freedom. Because DBA and Developers have different incentives, and DBA is new to the team. We need the engineering lead to mediate between the two sides to avoid conflict. In the end, at this stage, the business is still the absolute priority, so if the developers do not buy in, they can find excuses to bypass the policies that DBA establishes.

![_](/content/blog/how-many-dbas-should-a-company-hire/freedom-control.webp)

Meanwhile, the engineering lead should also focus on mentoring the DBA, so that she can grow with the company into the next stage.

## 100 - Second DBA

Typically, when the engineering team size reaches 100, it is necessary to bring in a second DBA to form a backup. If the first DBA grows up, then the second DBA can be a junior. However, if the first DBA does not keep up with the company's growth, then it is necessary to introduce a relatively senior DBA.

At this stage, DBA must examine the current database stacks and standardize on very limited choices (e.g. Pick either MySQL or PG, not both). The key are two things, choosing the right database and the right tool. This is also why we need a seasoned DBA. After this stage, it will be a huge endeavor to switch databases and tooling, so it's more cost-effective to find an experienced DBA now.

## 200 - Team DBA

We see cases of public companies maintaining a two-DBA setup for a long time. However, the number of DBAs is correlated with database risk. **The empirical rule is the DBA:Developer ratio should not be less than 1:200**. The DBA cost can be justified if she can prevent one outage per year, which is quite easy to achieve.

At this stage, it's also quite often that the DBA team needs to extend the standard 3rd-party tools to meet the custom in-house requirements. This can go as far as GitHub, where they build the [entire toolchain to automate the database schema migrations](https://github.blog/2020-02-14-automating-mysql-schema-migrations-with-github-actions-and-more/).

## Wrapup

| Engineering Org Size | DBA Size                               | Core Responsibilities |
| -------------------- | -------------------------------------- | --------------------- |
| Below 30             | 0                                      | Run                   |
| 30 to 50             | 1                                      | Establish process     |
| 50 to 200            | 2 ~ 3                                  | Governance            |
| Above 200            | DBA:Developer ratio no less than 1:200 | Customization         |

## Do we need DBA at all

> A skilled warrior has no illustrious achievements - The Art of War by Sun Tzu

Cloud, Serverless, and Autonomous DBs, all suggest a path to a future without DBAs. However, dealing with database operations is still a specialized skill and also bears high risk. Even for companies not having the luxury to hire a DBA, a database person should always be put in place. This is quite similar to the security team.

The stakes are so high that one can't blindly trust an index optimization suggestion and must take a second eye. It's better to let the database platform and tools be the copilots and still put the dedicated DBA in the driver seat.

Meanwhile, companies can also consider hiring 3rd-party DBA consultants such as [Vettabase](https://vettabase.com/). For small companies, they provide database health checks and monthly DBA time. For larger companies, they can also provide expertise with technologies that DBAs are not familiar with, such as certain load balancers, query optimization, or Ansible/Terraform automation.


The
Bytebase Blog

Explore the standard for database governance

Solutions & Platform

Resources

Change Management

Access & Security

AI & Agents

Comparisons

Company

Legal

The Bytebase Blog

Explore the standard for database governance

The
Bytebase Blog