You pick an open source BI tool because you want control. No vendor lock-in. No per-seat tax that doubles when you add users. You pick wrong, you trade one kind of lock-in for another: a tool that works for dashboards but blocks you on embedding. Or a tool that sings with time-series data but chokes on SQL joins.
We deploy Metabase and Grafana across client projects at Cloud Intelligence. We evaluated Apache Superset for two engagements and chose not to use it. This comparison draws from production scars, not spec sheets.
1. Setup experience
Metabase
You download a single JAR file. java -jar metabase.jar. Point it at your database. Your first dashboard renders within five minutes. For production, Docker wraps the same JAR. A 2GB VPS runs Metabase without complaint. The application stores its config in a PostgreSQL database. You back that up, you back up everything.
When we deployed Metabase for Crossroads Health, we layered it on their existing PostgreSQL infrastructure. Zero new infrastructure. The analytics layer sat next to the application, reading the same databases. Setup took an afternoon.
Grafana
Grafana itself installs in minutes. Single binary. Docker, apt, or brew install grafana. The setup time hides elsewhere. Grafana visualizes data. It does not store it. You bring InfluxDB, Prometheus, PostgreSQL, or Loki. Each data source demands its own configuration, its own backup strategy, its own monitoring.
For our F1 telemetry demo, we ran Grafana with InfluxDB (read the full write-up). Two containers. The pipeline: FastF1 Python scripts pulling live telemetry into InfluxDB, Grafana querying InfluxDB every second. Grafana itself took fifteen minutes. The data pipeline took days.
Superset
You do not install Superset with a single command. Docker Compose is the supported path. The stack spins up: PostgreSQL for metadata, Redis for caching, Celery workers for async queries, Gunicorn for the web server. Our first deployment took three hours to stabilize. A subsequent upgrade from 3.x to 4.x broke our config format and consumed a full day.
Superset wants a team behind it. A single developer can run Metabase or Grafana. Superset demands someone who understands connection pooling, Celery queues, and Python virtual environments.
Bottom line
Metabase: one command, five minutes. Grafana: one command for Grafana, days for the pipeline behind it. Superset: Docker Compose, patience, and a full workday.
2. Embedding
You embed analytics because your customers live outside your organization. They log into your application, not your BI tool. They see their data, not everyone’s data. They never hear the word “Metabase” or “Grafana.” The dashboard appears as a native feature of your product.
Metabase
Metabase builds embedding into its core. You generate a signed JWT, pass it as a URL parameter, and render the dashboard in an iframe. The JWT carries filter values. Metabase enforces the scope at render time. A hospital CFO opens the portal and sees her facility. A billing analyst in the same organization opens the same portal and sees his department.
We embedded Metabase into the Crossroads Health Provider Portal this way. Providers log in, see their credit balance dashboards, drill into transactions. No indication the analytics layer is a separate tool. The same pattern powers Right Refund’s operational dashboards and the AI Market Pulse public dashboard (see it live).
The embedding API gives you signed URLs, filter passthrough, and CSS customization. You white-label with a few lines of CSS. What you do not get: a JavaScript SDK. No React component. No programmatic dashboard builder. You work through HTTP endpoints and iframes. For most embedded analytics use cases, this is enough. If you need headless dashboard composition from code, look elsewhere.
Metabase supports public sharing at the flick of a toggle. One dashboard publishes with a secret URL. We use this for demo dashboards. Anyone with the link can view and interact. No login required.
Grafana
Grafana renders in an iframe. The gap is authentication. Grafana assumes every viewer has a Grafana user account. No signed embedding. No parameterized filter passthrough without an auth proxy in front. You can configure OAuth to auto-create users, but each embedded viewer still registers as a Grafana user.
For internal teams, this works. Your ops team logs into Grafana, views dashboards, sets up alerts. Grafana’s embedding serves internal portals, not customer-facing products. The SaaS Retention Pulse demo (see the post) uses Grafana for internal dashboards. We would not embed it into a customer portal.
Superset
Superset offers public dashboards via URL. Guest tokens arrived in a recent release and remain incomplete. No signed embedding. No parameterized filter passthrough comparable to Metabase’s. You can embed an iframe and share a public link. You cannot scope data per user session without building a proxy layer yourself.
Of the three, Superset has the weakest embedding story. It assumes every user is an authenticated Superset user working inside the Superset UI.
Bottom line
Metabase: built for it. We embed it into production portals every day. Grafana: works for internal dashboards, fails for customer-facing use. Superset: do not embed it.
3. Data sources
Your BI tool connects to your databases or nothing else matters.
Metabase
Metabase connects to PostgreSQL, MySQL, MongoDB, BigQuery, Snowflake, Redshift, SQL Server, Druid, Presto, and several others. You add a database in the admin panel. Metabase introspects the schema and builds a data model on top. Foreign keys become click paths. Columns become filterable dimensions.
What Metabase does not connect to: InfluxDB. Prometheus. Any time-series database. Metabase lives in the world of SQL tables and documents. For our F1 telemetry demo, we needed real-time lap data streaming from InfluxDB. Metabase could not touch it. We used Grafana.
Grafana
Grafana connects to everything. Prometheus, InfluxDB, Graphite, Elasticsearch, Loki, Tempo, PostgreSQL, MySQL, CloudWatch, Azure Monitor, Google Cloud Monitoring. The data source catalog is Grafana’s superpower. Each data source ships a dedicated query builder. The InfluxDB builder works. The PostgreSQL builder is adequate. The Prometheus builder is the best in class.
Grafana’s strength is time-series. It plots metrics over time with native understanding of aggregation windows, downsampling, and alert thresholds. Relational databases work, but they feel like second-class data sources. Complex joins, subqueries, and cross-database queries stretch Grafana’s query layer.
Superset
Superset uses SQLAlchemy. Any database with a SQLAlchemy dialect works: PostgreSQL, MySQL, BigQuery, Snowflake, Redshift, Druid, Presto, ClickHouse, and dozens more. Superset includes native Druid support for high-cardinality time-series workloads.
Superset excels with analytical databases. ClickHouse and Druid queries run through Superset’s caching layer for sub-second response times on billion-row tables. Like Metabase, Superset does not connect to InfluxDB or Prometheus.
Bottom line
Metabase: SQL databases and document stores. Strong and narrow. Grafana: everything, with time-series as first-class. Superset: analytical databases. Deepest support for Druid and ClickHouse.
4. Query layer
The query layer determines who builds dashboards. Your data team. Or everyone.
Metabase
Metabase gives you three ways to ask a question.
The simple builder: pick a table, click columns, apply filters. No SQL. No concept of joins (Metabase handles those behind the scenes if you configure foreign keys). A marketing manager builds a customer cohort analysis without ever seeing a SELECT statement.
The custom builder: add aggregations, groupings, and multi-step filters. You drag dimensions and metrics onto a canvas. The builder generates SQL that you can inspect but not modify.
The SQL editor: full SQL with variables, snippets, and saved questions. You write SELECT * FROM orders WHERE created_at BETWEEN {{start}} AND {{end}}. The variables become dashboard filters. Saved SQL questions feed into other questions as source tables.
Metabot, Metabase’s natural language query, generates SQL from English. We tested it across client datasets. For simple queries (“show me revenue by month”), it works. For anything with joins, window functions, or nested aggregations, it hallucinates. We turned it off in production.
The query layer is where Metabase earns its keep. Non-technical users build dashboards. Analysts write SQL when they need it. Both coexist without friction.
Grafana
Grafana has no universal query builder. Each data source provides its own editor. The InfluxDB editor lets you pick measurements, fields, and tags. The Prometheus editor gives you autocomplete on metric names and labels. The PostgreSQL editor gives you a text box.
Grafana query editors vary in quality. The InfluxDB editor works. The Prometheus editor works. The SQL editors feel like afterthoughts: a text area, a run button, and a table output. No schema browser. No autocomplete. You type raw SQL or you do not query.
Grafana does not target non-technical users. Your ops team configures dashboards, and everyone else views them. If a product manager wants to explore data, Grafana sends them to Metabase.
Superset
Superset splits queries across two surfaces.
SQL Lab: a SQL IDE with schema browser, query history, and result export. You write queries, save them as datasets, and build charts on those datasets.
Explore: a drag-and-drop interface for building charts from datasets. You assign columns to dimensions and metrics. You add filters, sort orders, and time ranges. The Explore workflow is powerful but confusing. Dimensions and metrics are separate concepts with separate UI panels. New users struggle to understand which columns go where.
Superset does not offer natural language query. The gap between SQL Lab and Explore is wide. Analysts live in SQL Lab. Everyone else needs training on Explore.
Bottom line
Metabase: the best self-service. Non-technical users thrive. Grafana: ops teams love it. Everyone else needs an analyst. Superset: powerful for analysts. Steep for everyone else.
5. Dashboard interactivity
Metabase
Metabase dashboards support click-to-filter. Click a bar in a chart, every other card on the dashboard filters to that value. Filters reach every card. You cannot configure one chart to filter a subset of other charts while leaving the rest unchanged.
Drill-through works: click a data point, Metabase shows the underlying rows. You inspect individual transactions from a summary view.
What Metabase does not do: custom actions. Clicking a chart cannot trigger a webhook, navigate to an external URL, or open a modal with additional context. Dashboards are read-only views with filter widgets and drill-through.
Grafana
Grafana panels link to other dashboards. You click a spike in CPU usage, Grafana navigates to the server detail dashboard with the time range preserved. Variables make this work: select a region from a dropdown, all panels refresh for that region.
Grafana does not support drill-through to raw data. It does not support cross-filtering between panels on the same dashboard. Each panel runs its own query. Clicking a bar in one panel does not update the other panels.
Grafana dashboards serve observation. You watch metrics. You spot anomalies. You navigate to other dashboards for deeper views. You do not explore data within a single dashboard.
Superset
Superset offers the most interactivity. Cross-filtering works: selecting a bar in one chart filters other charts on the same dashboard. Drill-to-detail opens a modal with the underlying rows. Native filters sit at the dashboard level and apply to all charts.
Superset dashboards feel exploratory. You click around, filter, drill, and discover patterns. The interaction model matches what analysts expect from tools like Tableau.
Bottom line
Metabase: solid drill-through, basic cross-filtering, no custom actions. Grafana: variables and panel linking. Observation, not exploration. Superset: the best cross-chart interactivity. Built for exploration.
6. RBAC and multi-tenancy
Metabase
Metabase groups users and assigns permissions. Groups map to collections (folders for dashboards) and databases. A user in the “Marketing” group sees marketing dashboards but not finance dashboards.
Sandboxing (row-level security) is an Enterprise feature. You define rules that filter data per user or group. A hospital CFO sees all facilities. A department manager sees one. Without Enterprise, every user in a group sees the same data.
For Crossroads Health, we built multi-tenancy through signed embedding. Each provider’s JWT carries a facility ID parameter. Metabase applies the filter at query time. The provider sees their data. No Enterprise license required. This pattern works for embedding. For internal multi-tenant use without embedding, you pay for Enterprise.
Grafana
Grafana manages access through organizations, teams, and roles (Viewer, Editor, Admin). Folders group dashboards and inherit permissions. Data sources have their own permissions.
Grafana has no row-level security. Every viewer of a dashboard sees the same data. If you need per-tenant data scoping, you build it outside Grafana: separate data sources per tenant, or a proxy that rewrites queries per user. Both approaches require engineering work and increase maintenance.
Grafana serves internal teams. Your ops team watches production metrics. Your product team tracks feature adoption. Everyone belongs to the same organization. Multi-tenancy beyond internal teams is not Grafana’s domain.
Superset
Superset provides the most granular RBAC. Roles (Admin, Alpha, Gamma, and custom) control access to datasets, dashboards, and SQL Lab. Row-level security rules filter data at query time based on user attributes. A rule can say “users with department=X see rows where department=X.”
Superset’s permission model is correct in theory and confusing in practice. The role hierarchy defies intuition. Permissions overlap in ways that surprise new administrators. You spend time debugging why a user with “Gamma” role cannot see a chart that “Alpha” users can. Once configured, it works. Getting there takes patience.
Bottom line
Metabase: good enough for internal use. Embedding solves multi-tenancy for customer-facing use. Row-level security costs money. Grafana: fine for internal teams. Not for multi-tenant. Superset: the best RBAC, but you earn it through configuration.
7. Self-hosted complexity
Metabase
Metabase is the simplest to self-host. A single JAR file. One process. One PostgreSQL database for application state. Upgrades swap the JAR and run a migration.
Pain points exist. Major version upgrades sometimes break saved SQL questions when Metabase changes its internal SQL dialect. The v0.46 to v0.47 upgrade deprecated several query syntax patterns. The v0.49 to v0.50 upgrade refactored the permissions model. We lost a weekend to each migration.
For daily operation, Metabase hums along. Memory usage stays flat under 2GB for moderate loads. CPU spikes during dashboard refreshes and returns to baseline. Backups are a single pg_dump.
Grafana
Grafana itself is stable. The single binary starts, serves dashboards, and stays up. Upgrades are smooth and well-documented.
Your complexity lives outside Grafana. InfluxDB needs monitoring. Prometheus needs storage planning. Loki needs log ingestion pipelines. Grafana visualizes what your data pipeline produces. Invest in the pipeline, and Grafana rewards you. Neglect the pipeline, and Grafana shows empty charts.
We run Grafana for the F1 telemetry demo with a Docker Compose stack: Grafana, InfluxDB, and a Python data loader. Three containers. The Python script is the fragile piece. It fetches live telemetry from FastF1 and writes to InfluxDB. Network blips, rate limits, and session timeouts interrupt the data flow. Grafana stays up, but the dashboard goes dark.
Superset
Superset demands the most operational attention. The stack includes PostgreSQL, Redis, Celery workers, Gunicorn, and the Superset application. Five services. Each one needs configuration, monitoring, and backup.
Upgrades carry risk. Breaking changes between major versions require config rewrites, database migrations, and Python dependency reconciliation. A Superset deployment that works today may not survive a version bump without manual intervention.
Superset consumes more resources. Our pilot deployment needed 8GB RAM for a development instance with five dashboards and one user. Production requires more. If your infrastructure budget covers managed services, Superset’s self-hosted overhead may push you toward a paid alternative.
Bottom line
Metabase: runs on a small VPS. Upgrades need attention every six months. Grafana: stable but incomplete. The pipeline is the hard part. Superset: a part-time job to maintain.
8. Honest verdict
Pick Metabase if you need:
Embedded analytics for customers. Signed JWT embedding with parameterized filters works in production. We run it for Crossroads Health, Right Refund, and public dashboards like the AI Market Pulse (see it live). Read our embedding guide (How to Embed a Metabase Dashboard) and our introduction to the concept (What Is Embedded Analytics?).
Non-technical users who build their own reports. The simple question builder lets marketing managers, operations leads, and finance analysts answer their own questions without SQL.
Fast deployment on existing databases. Point Metabase at your PostgreSQL instance. Dashboards appear within minutes. Crossroads Health went from zero to a client-facing portal in weeks.
Avoid Metabase if you need:
Real-time time-series monitoring. Metabase has no InfluxDB or Prometheus connector. Build a real-time pipeline (see our guide) and send data to Grafana instead.
Complex cross-chart interactivity. Metabase dashboards are presentation surfaces. Filters reach every card. You cannot configure selective cross-filtering between specific charts.
Row-level security on the open source tier. Sandboxing requires an Enterprise license. For multi-tenant internal use without embedding, factor this cost into your decision.
Pick Grafana if you need:
Real-time operational monitoring. CPU, memory, request latency, error rates. Grafana watches your infrastructure. Our F1 telemetry demo (see it live) pushes live lap data through InfluxDB to Grafana with sub-second refresh.
Time-series data. InfluxDB, Prometheus, Loki, Tempo. Grafana is the visualization layer the observability ecosystem builds against.
A tool your DevOps team already knows. Grafana is the default dashboard for monitoring stacks. No training required. No new concepts to learn.
Avoid Grafana if you need:
Customer-facing embedded analytics. Grafana assumes authenticated Grafana users. Building a multi-tenant embedded experience requires an auth proxy and significant engineering work.
Non-technical dashboard builders. Grafana query editors assume you understand the data source’s query language. There is no drag-and-drop builder for casual users.
Row-level security. Grafana has no concept of per-user data scoping.
Pick Superset if you need:
Complex analytical dashboards with cross-filtering. Select a region in one chart, every other chart updates. Superset’s interactivity is the closest open source alternative to Tableau.
Granular RBAC at the row level. Superset’s permission model supports row-level security, dataset-level access control, and custom roles. Multi-tenant analytics with data scoping works without a separate Enterprise license.
Big data backends. ClickHouse, Druid, Presto. Superset’s SQLAlchemy foundation and caching layer handle billion-row analytical tables.
Avoid Superset if you need:
Simple deployment. Superset requires Docker orchestration skills, Python environment management, and patience with upgrades.
Customer-facing embedding. The embedding story lags behind Metabase by years. No signed URLs. No parameterized filter passthrough. Public dashboard sharing exists, but it is all-or-nothing.
Low operational overhead. Five services. Complex upgrades. Superset needs a team.
The choice we made
Cloud Intelligence uses Metabase for every embedded analytics deployment. The embedding API works. The query builder works for non-technical users. The deployment stays up with minimal maintenance. When a client asks us to put analytics in front of their customers, we reach for Metabase.
We use Grafana for real-time monitoring. The F1 telemetry demo, the SaaS Retention Pulse. Any problem where time-series data streams in and needs sub-second visualization. Grafana owns that domain.
We evaluated Superset for two engagements. Both times we concluded the operational burden exceeded the benefit. If a client needs cross-chart interactivity and row-level RBAC without Metabase Enterprise pricing, we will revisit Superset. For now, Metabase and Grafana cover every production use case we encounter.