
CEO & Co-founder of Visivo
Stay Aligned with Modern Data Stack for Reliable Data Systems
Learn how aligning your BI tools with the modern data stack creates reliable, unified data systems and trustworthy analytics.

The modern data stack changed how organizations collect, process, and analyze data. It is a cloud-native set of specialized tools, each responsible for one layer, and together they scale further and break less than the monolithic platforms they replaced. Grand View Research attributes much of the growth in the global data analytics market to modern data stack adoption.
Many organizations still struggle to fit their business intelligence tools into this architecture. The result is friction that undermines data reliability and every analysis built on top of it.
What the modern data stack is
The modern data stack is a shift from monolithic, on-premise data platforms to composable, cloud-native architectures. Instead of one vendor supplying every capability, each layer goes to the tool that does that one job best.
The core components:
Cloud data warehouses: Snowflake, BigQuery, and Databricks separate compute from storage, so teams can analyze very large datasets without managing infrastructure.
Data integration tools: Fivetran, Airbyte, and dlt automate ingestion from hundreds of sources and handle schema changes, API updates, and connection management for you.
Transformation layer: dbt™ (data build tool) is the standard for transformation. Analysts build reliable data models with SQL and version control. Our dbt™ BI integration guide covers how BI fits in.
Orchestration platforms: Apache Airflow and Dagster coordinate data workflows, respect dependencies, and handle failures.
Data quality and observability: Monte Carlo and Great Expectations monitor data quality and alert teams to anomalies before they reach downstream analytics.
What matters about this architecture is its modularity. Each tool does one thing well and connects to its neighbors through standard interfaces, so you can swap a component when your needs change without rebuilding the whole system.
# Example: Visivo integrating with modern data stack tools
# project.visivo.yml
name: modern_stack_integration
sources:
# Snowflake data warehouse
- name: warehouse
type: snowflake
account: ${env.SNOWFLAKE_ACCOUNT}
username: ${env.SNOWFLAKE_USER}
password: ${env.SNOWFLAKE_PASSWORD}
database: ANALYTICS
db_schema: DBT_PROD
# DuckDB for local development
- name: local_duckdb
type: duckdb
database: local_analytics.db
models:
- name: snowflake_sales
source: ${ref(warehouse)}
sql: SELECT * FROM fct_sales
- name: local_dev
source: ${ref(local_duckdb)}
sql: SELECT * FROM staging_data
Why BI tools must align with the stack
Traditional BI tools were built for a different era, when data lived in operational databases and ETL meant overnight batch jobs. Dropped into a modern stack, they cause three problems:
Data freshness gaps: A BI tool that does not integrate with modern orchestration cannot use real-time or near-real-time pipelines. Users see stale numbers while fresher data sits unused in the warehouse. Our reliable BI insights for stakeholders guide covers this problem.
Transformation duplication: Without alignment to dbt™ and similar tools, BI platforms force analysts to recreate business logic in proprietary languages. Two copies of the same logic drift apart and double the maintenance work, as we discuss in YAML vs GUI BI configuration.
Governance breakdown: Modern data stacks implement governance through data catalogs and lineage tracking. A BI tool that stays outside those systems is a blind spot.
Misalignment is technical debt that compounds. Teams spend hours reconciling BI calculations against the source-of-truth data models. Business users lose trust when two tools show two numbers for the same metric, and data quality issues like these, often caused by inconsistencies between systems, carry a real financial cost.
Strategies to stay aligned
Alignment takes deliberate choices:
Use compatible tools: Choose a BI platform built for the modern data stack. A tool like Visivo treats dashboards as code, so it speaks the same Git, YAML, and SQL as the rest of the stack and fits an engineering-oriented data team. Our developer-first BI workflows guide goes into detail.
# Example: Visivo workflow aligned with modern data stack
# 1. Pull and build the latest dbt™ models
git pull origin main
cd dbt_project && dbt run --target prod
# 2. Update Visivo dashboards to use new models
cd ../visivo_dashboards
visivo run # Run the models and insights against the new data
visivo test # Assert on the insight results
visivo deploy -s production
Adopt a modular architecture: Treat the BI layer as one more modular component, not a monolithic platform. Data modeling belongs to dbt™, visualization to your BI tool, and orchestration to Airflow. Each has one responsibility and talks to the others through well-defined interfaces.
# project.visivo.yml
name: analytics_dashboards
# Read the DuckDB file your dbt™ project builds
sources:
- name: dbt_duckdb
type: duckdb
database: target/dev.duckdb
models:
- name: dbt_metrics
source: ${ref(dbt_duckdb)}
sql: |
SELECT * FROM analytics.fact_sales
WHERE date >= CURRENT_DATE - INTERVAL 30 DAY
insights:
- name: sales_trend
props:
type: scatter
mode: lines
x: ?{ ${ref(dbt_metrics).date} }
y: ?{ ${ref(dbt_metrics).revenue} }
charts:
- name: sales_performance
insights:
- ${ref(sales_trend)}
dashboards:
- name: Analytics Dashboard
rows:
- height: medium
items:
- chart: ${ref(sales_performance)}
Ensure data governance: Apply the same governance to every component of the stack:
- Unified metrics layer: Define each business metric once in a central place (in Visivo, the semantic layer of metrics, dimensions, and relations) and reference it everywhere it is used
- Lineage tracking: Make sure your BI tool can report its lineage back to data catalogs, so you can see how dashboards connect to the underlying data
- Access control: Align BI permissions with warehouse security policies through service accounts and role-based access
# Example: Centralized metrics definition on a dbt™ model
# project.visivo.yml
models:
- name: fct_orders
source: ${ref(warehouse)}
sql: SELECT * FROM fct_orders
metrics:
- name: revenue
expression: SUM(order_total)
dimensions:
- name: order_month
expression: DATE_TRUNC('month', order_date)
insights:
- name: monthly_revenue
props:
type: bar
x: ?{ ${ref(fct_orders).order_month} }
y: ?{ ${ref(fct_orders).revenue} }
Embrace DataOps practices: Apply DevOps principles to the whole data stack, BI included:
- Version control every configuration
- Automate testing and deployment
- Monitor and alert
- Use infrastructure-as-code for reproducibility
What alignment gets you
When BI tools align with the modern data stack, the system becomes reliable in ways it could not be before:
Single source of truth: Business logic lives in one place, typically dbt™ models. BI tools consume those validated, tested models instead of recreating the logic, which ends the "which number is right?" debate.
# Example: Visivo consuming dbt™ models directly
# project.visivo.yml
dbt:
enabled: true
dbt_project_yml_location: dbt_project
profiles_yml_location: dbt_project
With the dbt: block enabled, Visivo reads your dbt™ project's manifest and profiles, turns each dbt™ target into a source and each dbt™ model into a Visivo model, and you reference them in Insights by name.
End-to-end observability: With an aligned BI tool, a team can trace an issue from the data source to the dashboard. In Visivo, tests assert on the results of your Insights when you run visivo test, and alerts send any failure to Slack or email:
# project.visivo.yml
tests:
- name: revenue_positive
assertions:
- ">{ min( ${ ref(sales_trend).props.y } ) >= 0 }"
alerts:
- name: data_quality_alert
if: ">{ anyTestFailed() }"
destinations:
- name: data_alerts_slack
type: slack
webhook_url: ${env.SLACK_WEBHOOK}
Faster delivery: New data sources plug in, transformations deploy automatically, and dashboards update without manual work. What once took weeks takes hours.
Trust through transparency: Business users can see data freshness, understand the transformations applied, and trust that governance policies are enforced the same way everywhere.
Lower cost: Aligned BI tools do not maintain their own data extracts and calculations. They use the warehouse and transformation layer you already pay for, so nothing is processed or stored twice.
The path to alignment is not always straightforward. The destination, a reliable and unified data system, is worth it. Aligning your BI tools with the modern data stack aims at faster dashboard development, fewer data discrepancies, and more user trust in analytics.
The modern data stack is a way of thinking about data, not just a set of tools. A BI tool that follows the same principles multiplies what a data team can do. One that resists becomes the bottleneck that caps the organization's data maturity.
Visivo is built to be the first kind. The examples gallery and /get-started are the fastest way to see it with a real project. For related reading, see our guides on BI-as-code scalable systems, python data pipelines, and visualizations as code.