For the past four years, our reporting ran almost entirely on Power BI. It did the job while our data team was small and stakeholders were happy receiving scheduled PDF exports and opening dashboard links inside Microsoft Teams.
Over the last 18 months, our engineering and analytics setup moved to Linux and Mac, our warehouse matured on Snowflake, and three specific friction points made Power BI painful to live with:
The desktop-client bottleneck. Half our analytics engineers and product managers work on macOS or Linux. Power BI Desktop remains Windows-only. Having engineers spin up Windows VMs or cloud desktop instances simply to tweak a report or verify a measure felt absurd for a modern stack.
Logic trapped in binary .pbix files. DAX measures, table relationships, and row-level security filters lived inside individual report files or workspace models. We could not run standard git pull request reviews on metric changes, track lineage across versions, or prevent two analysts from writing slightly different versions of the same retention calculation.
License sprawl and the Fabric push. What started as $10/user/month Pro licenses steadily escalated with Premium-per-user upgrades, external viewer licensing constraints, and heavy pressure to commit to Microsoft Fabric capacity (F64+) just to access basic direct lake and copilot features.
and thing is that we spent the past month evaluating five open-source and code-first tools to replace Power BI. We wanted an architecture where metric logic lives in version-controlled code, dashboards run cross-platform in the browser, and numbers can be queried both by BI tools and by downstream applications or AI agents; here is the breakdown of our test setup, the comparison matrix, and where each option landed.
The Comparison Matrix
| Evaluation Dimension | Power BI (Baseline) | Apache Superset | Metabase (OSS) | Lightdash | Evidence.dev | Cube (Cube Core OSS) |
|---|
| Primary Mental Model | Desktop-first drag-and-drop report builder | Open-source web-based dashboard platform | Fast self-serve query builder and dashboards | dbt-native BI built directly on dbt models | Code-based reporting in Markdown + SQL | Headless semantic layer + open data APIs and web UI |
| Metric & Logic Storage | Proprietary DAX in .pbix files or Fabric semantic models | Virtual datasets and SQL Lab queries (stored in metadata DB) | Questions and Model objects in application database | Defined as metrics in dbt schema YAML files | SQL queries embedded in Markdown files | Code-first YAML/JS models in Git repositories |
| Git / PR Workflow | Difficult; Git integration requires Fabric / PBIP format | Rudimentary; requires export/import scripts or API sync | Serialization via YAML requires paid Enterprise plan | Native; metric definitions live inside your dbt repo | Native; entire project is markdown and SQL in Git | Native; repository-first with standard branch & PR workflows |
| Cross-Platform Access | Windows-only desktop client for authoring | 100% browser-based authoring and consumption | 100% browser-based authoring and consumption | 100% browser-based authoring | Browser-based, CLI local server on Mac/Linux/Win | Browser-based, CLI local server on Mac/Linux/Win |
| Downstream & API Access | Closed; XMLA endpoints require Premium capacity | REST API for metadata; chart data exportable | REST API (returns card query results) | Query API through dbt Cloud / Lightdash CLI | Static site export; not an API service | Universal SQL API (Postgres protocol) + REST/GraphQL APIs |
| AI / Agent Readiness | Copilot locked behind Fabric capacity commitments | Community AI plugins; mostly text-to-SQL over raw schemas | Metabot assistant; generates queries over Metabase models | AI chat grounded in dbt metric definitions | LLMs can generate Markdown/SQL files | Native remote MCP server and semantic layer context |
| Biggest Trade-off / Gotcha | Windows lock-in, proprietary DAX, per-seat licensing | Heavy Docker setup, permission model can get complex | Metric governance is light; joins duplicate easily | Requires dbt for everything; not independent | No ad-hoc drag-and-drop for non-technical users | You have to model data in YAML before building charts |
What We Learned Testing Each Option
Apache Superset: Great for rich charting, heavy on operational maintenance
If your primary goal is finding an open-source tool that matches Power BI's extensive chart variety, Superset is the closest visual equivalent. It handles complex dashboards, geospatial visualizations, and slice-and-dice exploration without per-seat licensing.
* Where it worked: Solid out-of-the-box dashboards, zero Windows dependencies, and strong community support.
* Where it pinched: The permission system is intricate and requires careful role configuration. While Superset has virtual datasets, business logic still ends up scattered across ad-hoc SQL snippets in different charts rather than sitting in a centralized semantic layer.
2. Metabase: Unmatched for rapid self-serve, but lighter on modeling governance
Metabase remains the fastest tool for getting non-technical team members exploring data. The graphical query builder allows sales and product managers to ask questions without writing SQL.
* Where it worked: Onboarding takes less than an afternoon. Anyone comfortable with Excel filters can build their own cards immediately.
* Where it pinched: Metric logic is stored in Metabase's application database rather than in code. Version control via YAML requires higher-tier licensing, and managing row-level security across multi-tenant departments required duplicating questions once our role hierarchies became complex.
3. Lightdash: Ideal if your team is already 100% committed to dbt
Lightdash takes a dbt-first stance: your dbt project is your single source of truth, and Lightdash auto-generates your BI layer from your dbt schema YAML files.
* Where it worked: All metric definitions live in Git pull requests alongside transformation models. Clean versioning and developer workflow.
* Where it pinched: If an analysis doesn't fit your pre-compiled dbt DAG, you cannot easily explore it on the fly. You also cannot point other non-Lightdash tools or customer-facing apps at its metric engine without going through their specific query layers.
4. Evidence.dev: Excellent for data engineers, foreign to drag-and-drop business users
Evidence replaces traditional BI dashboards with code-generated analytical markdown documents. You write SQL queries in fenced blocks and render charts with declarative tags.
* Where it worked: Code-driven, fast static rendering, and versioned cleanly in Git. Our analytics engineers liked the developer experience.
* Where it pinched: It is fundamentally a publishing tool for analysts, not an ad-hoc exploration tool for business stakeholders. If a VP wants to drag a dimension into a pivot table on Friday afternoon, Evidence won't serve that workflow.
5. Cube dev and decoupling the metric layer from the visualization
We tested Cube Core as an open-source semantic layer sitting between Snowflake and our visualization tools. Instead of defining metrics inside each dashboard tool, we defined cubes, dimensions, joins, and measures in YAML files stored in our git repository.
* Where it worked:
- Universal consumption: We can connect Superset or Metabase to Cube's SQL API (which speaks the Postgres protocol). Both tools query the exact same governed metric definitions, so nobody argues over differing numbers.
- Performance and caching: Cube's pre-aggregation engine stores partitioned rollups, serving repetitive dashboard filter changes in sub-second response times without triggering live warehouse compute on every query.
- Multi-surface readiness: Because Cube provides REST, GraphQL, and remote MCP endpoints on top of the same model, our engineers can build embedded customer portal widgets and point LLM agents at governed measures without re-implementing business logic.
* Where it pinched:
- Upfront data modeling investment: Unlike Power BI where you can drag raw tables and click auto-detect relationships, Cube requires explicit modeling of join paths and primary keys in code. If your underlying schema has messy foreign keys, you must resolve them before metrics compile.
- Dashboard building requires picking a front-end: While Cube provides built-in workbooks and web exploration, teams wanting traditional heavy dashboards typically pair it with an open-source visualizer like Superset or custom React components.
---
so how we decided to structure our stack
Rather than trading one monolithic vendor for another single closed tool, we settled on a two-tier decoupled architecture:
Semantic & Governance Tier: We use Cube Core as our open-source metric layer. All calculations (such as gross retention, ARR, and active seats), join topologies, and role-based access rules are written in code, reviewed in pull requests, and versioned in Git.
Consumption & Visualization Tier: For internal exploratory dashboards and operations teams, we point open-source Superset at Cube's SQL API. For our engineering team's customer-facing portal and agentic workflows, we query Cube's data APIs directly.
as for questions! for analytics engineers who migrated off Power BI:
- Did you replace it with an all-in-one platform like Superset or Metabase, or did you decouple the semantic layer from visualization?
- How did your analysts adapt to modeling metrics in Git and YAML instead of writing DAX formulas in desktop files?