DBT Transforms. Fivetran Ingests. Liquibase Secure Governs.

The Modern Data Stack Moves Fast. Maybe Too Fast.

The modern data stack has changed how teams ingest, transform, and activate data. Tools like Fivetran make moving data effortless. DBT streamlines transformation. Cloud-native warehouses like Snowflake, Databricks, BigQuery, and Redshift scale without friction. And Airflow helps orchestrate it all.

But there’s one piece of the stack that hasn’t kept up: schema governance.

Schema changes still happen:

• Manually, often via emailed scripts or IDE changes
  
• Without consistent approvals or enforcement
  
• Bypassing CI/CD pipelines entirely
  
• Without clear rollback, versioning, or audit trails
  

That’s a problem. When schema changes are uncontrolled, the rest of your stack becomes fragile.

That’s why more data and platform teams are saying: DBT transforms. Fivetran ingests. Liquibase Secure governs.

What the Modern Data Stack Looks Like

Here’s how most data platforms are built today:

‍

These tools move and reshape data. None of them govern the structure behind that data.

The Governance Gap

Every team that builds data pipelines knows this scenario:

• Someone drops a column
  
• A pipeline stops
  
• A dashboard breaks
  
• A machine learning model starts skewing
  
• No one knows who made the change or why
  

Without schema governance, you’re vulnerable to:

• Drift between Dev, Test, and Prod environments
  
• Shadow changes made outside approved workflows
  
• Compliance violations tied to SOX, PCI, HIPAA, or GDPR
  
• Data lineage gaps that break AI explainability
  
• Rollback failures when teams scramble to undo bad changes
  
  

And as the stack gets more complex, the risks multiply.

Why DBT Isn’t Enough

DBT is powerful. It focuses on transformation, not governance.

What DBT does well:

• Runs SELECT queries to shape data
  
• Builds models in a modular, reusable way
  
• Creates views or tables in your warehouse
  
• Helps analysts and analytics engineers deliver faster
  

What DBT doesn’t do:

• Safely manage DDL or DML changes like CREATE, ALTER, or DROP (can be scripted but lacks governance)
  
• Block risky schema changes before they go live
  
• Detect schema drift across environments
  
• Support rollback or recovery from failed deployments
  
• Maintain tamper-evident audit logs for compliance or investigation
  
• Govern database components that fall outside its models, such as stored procedures, triggers, functions, and indexes

DBT is a data transformation tool, not a database governance solution. It focuses on shaping data within pipelines, not managing the full database ecosystem around them. Objects like stored logic, roles, and access controls are afterthoughts in DBT’s workflow, they sit outside its core mission. There are workarounds, but they’re fragile and not what DBT was designed for.

One DBT user recently shared this on Hacker News:

“I still feel like I’m missing, in DBT, capabilities for DB DDL/DML deployment (which I’ve done from Liquibase in DBT)…”

They are not alone.

As companies grow and compliance requirements increase, teams realize DBT isn’t built to govern the structure of their data. Liquibase Secure is.

Liquibase Secure: The Governance Layer for the Modern Data Stack

Liquibase Secure brings security, control, and automation to your schema change lifecycle. It integrates with your pipelines and works across more than 60 database platforms.

Here’s what it adds to your stack:

• Policy checks before deployment
  Enforce naming conventions, block risky operations like DROP COLUMN, and require PII tagging or custom validations.
  
• Drift detection
  Catch unauthorized changes before they impact pipelines or break model inputs.
  
• CI/CD integration
  Fit database change into the same pipelines as app code. Use GitHub Actions, Jenkins, GitLab, or Azure DevOps.
  
• Audit logging
  Record every change. Who made it, what changed, and when. Export logs to your SIEM or GRC platform.
  
• Targeted Rollback capabilities
  Roll back specific changes when needed, without affecting unrelated updates.
  
• Multi-database support
  Snowflake, Postgres, MongoDB, BigQuery, Oracle, SQL Server, Databricks, and more.
  

Liquibase Secure doesn’t replace your tools. It wraps around them to make your stack safe, governed, and audit-ready.

What Happens When You Add Liquibase Secure to DBT

Imagine a DBT model depends on a column in a warehouse table. A developer drops that column.

Without Liquibase Secure:

• The change goes live
  
• The DBT model breaks
  
• Dashboards fail silently or return bad data
  
• No one knows why it happened or who made the change
  

With Liquibase Secure:

• The change is blocked in CI
  
• A policy check catches the risky update
  
• Teams get notified
  
• A tamper-evident log records the attempt
  
• If something still goes wrong, rollback is fast and precise
  
  

That’s the difference between hoping nothing breaks and knowing your pipelines are protected.

Why This Matters for AI and Analytics

AI models are only as reliable as the data that feeds them. If your schemas are inconsistent or undocumented:

• Inputs drift without warning
  
• Model performance degrades
  
• Data lineage breaks
  
• Compliance reviews fail
  

Liquibase Secure provides:

• End-to-end schema-level lineage
  
• Consistent structure across environments
  
• Transparent records of what changed and why
  
• Control over every schema change, from dev to prod
  
  

If you’re serious about AI, you need to govern the structure behind your data.

The Modern Stack With Liquibase Secure

Let’s look at the full stack again, this time with governance in place:

‍

This is how modern teams build with confidence.

Conclusion

The modern data stack is fast, scalable, and flexible. But without governance, it’s fragile.

DBT transforms. Fivetran ingests. Liquibase Secure governs.

If you care about compliance, audit readiness, developer velocity, or AI trust, Liquibase Secure is the missing layer your stack needs.

Ready to Govern Your Modern Data Stack?

Request a demo

‍