Skip to content
Engineering deep-divesAll articles

Metabase vs Superset in 2026: Embedded Analytics & 36-Mo TCO

Engineering and 36-month TCO teardown of Metabase vs Superset in 2026, with Preset and Cube: multi-tenant B2B embedded analytics, guest embeds and Guest Token RLS, AGPLv3 vs Apache 2.0, and native React charts.

Oleh Henaliuk
Oleh HenaliukDeputy CEO · Idealogic
Author: Oleh HenaliukPublished: Updated: Reading time: 19 minHow we write →
On this page
Idealogic 2026 engineering comparison of Metabase vs Superset, Preset Cloud, Cube, and native React ECharts covering AGPLv3 vs Apache 2.0 licensing, multi-tenant RLS, and 36-month embedded analytics TCO

Most teams land on the Metabase vs Superset question the week a customer asks for reporting inside the product. Our teardown of PostHog vs Mixpanel covers internal product funnels, replays and feature flags. This 2026 guide is about customer-facing, multi-tenant embedded analytics: white-label KPI cards, drill-downs, scheduled reports and CSV/Parquet exports inside your SaaS app, modelled at 500 enterprise tenant orgs and 5,000 monthly active external viewers. Searched Superset vs Metabase for internal BI only? The first block has the quick verdict.

Metabase vs Superset at a glance

  • Metabase is an open-source BI tool (AGPLv3) that runs as one JVM app. Guest embeds are free, but the React SDK, white-labeling and data sandboxing need Pro or Enterprise.
  • Apache Superset is an open-source BI tool under Apache 2.0, built on Python and Flask, that embeds dashboards through guest-token iframes at no license cost.
  • For internal BI, Metabase is usually quicker to stand up and easier for non-engineers. For embedded analytics at thousands of viewers, self-hosted Superset costs less in licenses and more in ops, and a native React build beats both in our model.

Either choice has a cost. Open-source Metabase puts white-labeling and multi-tenant sandboxing behind commercial plans, where the $12 per-user fee gets expensive once customers sign in to interactive dashboards. Open-source Apache Superset gives you Guest Token embedding under Apache 2.0 for $0, but the UX lives inside an <iframe> and your SREs inherit Python, Celery, Redis and a headless Chromium fleet.

At Idealogic, our SaaS development, custom software development, JavaScript development, and product development squads ship Metabase, Preset/Superset, Cube, and native React analytics across fintech and logistics and supply chain. This guide pairs the comparison with a PostgreSQL row-level security and semantic compiler blueprint, plus a 36-month TCO model at 500 tenants and 5,000 active viewers.

The short version

  • Metabase wins internal BI and low-seat embeds. Metabase ships @metabase/embedding-sdk-react, but removing the "Powered by Metabase" badge and SSO Data Sandboxing need Pro ($575/mo plus $12 per extra user per month) or Enterprise (custom, from $20,000/yr).
  • Apache Superset wins on license cost and loses on ops and iframes. Apache Superset (Apache 2.0) includes Guest Token RLS with no seat fee. You pay in <iframe> friction and Python/Celery/Chromium ops, unless you run it on Preset Cloud, which charges for embedded viewers.
  • Cube (Apache 2.0 core) serves headless rollups, and Apache ECharts plus TanStack Table render natively in React with no iframe.
  • Don't rely on Superset dataset filters alone. One dataset shipped without its RLS rule or Jinja filter can leak cross-tenant rows, so enforce row-level security in PostgreSQL as well.
  • In our model at 500 tenants and 5,000 MAU, native React + PG17 comes out 62.5% ($172,200) cheaper than Metabase Enterprise over 36 months. That's $103,200 ($17,400/yr from year 2) against $114,000 for self-hosted Superset, $197,400 for Preset Embedded and $275,400 for Metabase Enterprise. License inputs are our assumptions, not list prices.

Metabase vs Superset internals: licensing, embedding and RLS traps

A Metabase vs Superset evaluation for multi-tenant SaaS turns less on chart types than on four things: open-source copyleft scope, DOM rendering (<iframe> vs React components), how tenant isolation is enforced, and per-viewer fees.

Where Metabase, Apache Superset, Preset and native React embedded analytics differ in 2026: license scope, tenant RLS, DOM integration and per-viewer fees

1. Metabase: polished UX behind AGPLv3 and seat walls

Metabase is an open-source business intelligence tool (AGPLv3, a Clojure app on the JVM) whose React SDK, white-labeling and sandboxing require Pro or Enterprise. It's quick to get from a relational schema to clean charts. Three details decide whether it fits an embedded product:

  1. Guest embeds vs the interactive React SDK. Guest embeds, which replaced the older static embedding, are signed with a JWT (RFC 7519) and render locked parameter views inside an <iframe>. They're free on every plan and don't create Metabase users, so nobody is billed per viewer. The Metabase React Embedding SDK (@metabase/embedding-sdk-react) (part of Metabase's modular embedding) mounts interactive drill-downs, filter pickers and query builders inside React apps without iframe plumbing. Pair it with Metabase Data Sandboxing to filter rows and columns per SSO/JWT user attribute.
  2. The AGPLv3 and white-label paywall. Open-source Metabase runs under the GNU Affero General Public License v3 (AGPLv3). In the free OSS JAR, every embedded chart carries a "Powered by Metabase" footer and SSO Data Sandboxing is absent. If you modify the Clojure/React source to hide that badge and serve the modified build to SaaS customers over HTTPS, AGPLv3 Section 13 network copyleft applies. Running unmodified Metabase doesn't trigger it.
  3. The authenticated-viewer pricing cliff. Metabase Pro ($575/mo monthly, or $517.50/mo billed annually at $6,210/yr, with 10 users) unlocks white-labeling and sandboxing at $12 per additional user per month ($130/yr). That's fine for 35 internal analysts ($875/mo). It isn't fine if 5,000 external customers authenticate into interactive SDK dashboards: at list rates that's about $60,000/mo ($575 plus 4,990 x $12). Metabase steers deployments that size to custom Enterprise pricing, published as starting at $20,000/yr. Our TCO model assumes a negotiated $5,800/mo, an Idealogic estimate.

2. Apache Superset and Preset: free guest tokens, iframe limits

Apache Superset is an open-source BI and SQL exploration tool under Apache 2.0, started at Airbnb, that embeds dashboards through guest-token iframes with no copyleft obligations:

  1. Apache 2.0 license and a native Guest Token API. Self-hosted Superset includes white-label Embedded Superset at no license cost. Your Node.js backend mints a short-lived guest_token via POST /api/v1/security/guest_token/ carrying RLS rules in the form { dataset: 42, clause: "tenant_id = '...'" } (the Preset embedding docs show the format), optionally alongside Superset Jinja SQL templating. It renders client-side through @superset-ui/embedded-sdk.
  2. Two production catches: iframe UX and Python fleet ops. First, @superset-ui/embedded-sdk mounts a sandboxed <iframe> with its own Ant Design stylesheet. Keeping it in sync with your Tailwind dark-mode toggle, custom typography, URL deep links and mobile table layouts (see our dashboard design patterns) stays brittle. Second, running Superset reliably takes Python Flask/Gunicorn, Redis, a Postgres metadata database, Celery workers and beat, and headless Chromium (driven by Selenium or Playwright) for PNG/PDF email reports, plus regular CVE patching. That pushes lean teams to managed Preset Cloud, where Preset's pricing page lists embedding as an add-on with viewer licenses from $500/mo per 50 viewers. At thousands of viewers expect a negotiated contract. Our model assumes $3,400/mo.

3. Cube, Lightdash and owned native React

  • Cube and Lightdash. Cube provides a headless semantic API with Cube Store pre-aggregations. Lightdash (MIT core) is built around dbt projects and aimed at internal data teams.
  • Owned native React with a typed semantic BFF and PG17 or ClickHouse rollups. Rendering Apache ECharts and TanStack Table natively inside your Next.js DOM removes the iframe and uses your own design system. The database enforces tenant isolation through PostgreSQL row-level security, with ClickHouse incremental materialized views taking over pre-aggregation above roughly 500M rows. You also avoid BI vendor lock-in and per-viewer fees.
DimensionMetabase Pro / Ent.Apache Superset (OSS)Preset Cloud EmbeddedCube Cloud + ReactOwned Native React + PG17
Open-source licenseAGPLv3 (paid Ent.)Apache 2.0 (100% free)Managed Apache 2.0Apache 2.0 core100% Owned MIT/Apache 2.0
White-label badgePaid Pro / Ent. onlyFree Day 1Included on Embedded100% native UI100% native SaaS DOM
DOM integrationReact SDK or <iframe>Sandboxed <iframe> onlySandboxed <iframe> onlyHeadless JSON -> ReactNative RSC + ECharts
Tenant RLS modelJWT / SSO SandboxesGuest Token clause + JinjaManaged Guest Token RLSsecurityContext JSDB-enforced PG17 RLS
5,000-MAU seat taxHigh (Ent. capacity)$0/viewerViewer license add-onQuery/compute units$0/viewer
Self-hosted opsLow (1 JVM + PG)High (Flask/Celery/Chrome)Fully managed SaaSMedium (Cube Store)Low (existing Next.js + PG17)

Why Superset Jinja filters leak and how PG17 RLS plus a semantic compiler fix it

In Superset, multi-tenant datasets rely on Guest Token RLS clauses or dataset-level Jinja filters. Both share one point of failure in a multi-tenant SaaS architecture: Superset connects to your analytical replica with one shared database role. If an analyst ships a new virtual dataset and forgets the filter, or misconfigures the dataset scope of a rule, the query scans all 500 customer tenants.

Take that human error out of the path. Put PostgreSQL 17 Row-Level Security (RLS) on pre-aggregated hourly rollup tables (PostgreSQL 18 behaves the same way), and put an allowlist-compiled TypeScript semantic query builder on your API integration boundary. One caution: PostgreSQL materialized views don't apply the RLS policies of their base tables. Keep historical summaries as RLS-protected tables, and never let the reader role query a materialized view directly.

The design comes down to five decisions:

DecisionWhere it livesWhat it prevents
Tenant filter enforced by FORCE ROW LEVEL SECURITY with a restrictive policy on every rollup tablePostgreSQLA chart endpoint or dataset that forgets its tenant filter still returns only the current tenant's rows, and the table owner is bound too
Restrictive policy paired with a permissive onePostgreSQLPostgreSQL ORs permissive policies together, so a second permissive rule alone could widen access
Metrics and dimensions picked from frozen allowlists, values bound as parametersSemantic BFFClient strings never become SQL identifiers, so a crafted metric name can't inject SQL
Tenant ID bound per transaction with set_config, inside a read-only transactionSemantic BFFPooled connections can't carry one tenant's context into the next request, and dashboards can't write
3000 ms statement_timeout, time-window checks and a row limit capped at 1,000Semantic BFFOne heavy drill-down can't eat replica CPU for the other 499 tenants

The compiler is the piece no BI tool gives you. It only ever pastes SQL fragments from its own frozen metric and dimension maps, rejects any name that isn't a key in them, and binds the date range as query parameters. The query it builds reads the hourly rollup table, groups by the chosen dimension and caps the result at 1,000 rows.

There's no tenant filter in that query on purpose. Row-level security adds it, so nobody can forget it.

One condition: the pool must connect as a non-superuser reader role with NOBYPASSRLS. RLS only applies if the replica connection authenticates as that role, or if the transaction switches to it with SET LOCAL ROLE before the query runs.

Hitting Metabase per-viewer walls or fighting Apache Superset iframes?
Share your tenant count, monthly active viewers, and analytical event volume. Our SaaS data engineers will design a zero-seat-tax native React + PG17 or ClickHouse analytics layer.
Benchmark your embedded analytics TCO

Metabase vs Superset 36-month TCO: 500 B2B tenants and 5,000 monthly active viewers

Model a multi-tenant B2B SaaS product over 36 months: 500 enterprise customer organizations, 15,000 provisioned customer logins (5,000 monthly active dashboard viewers), and 200,000,000 analytical rows behind white-label KPI dashboards, drill-down tables, scheduled alerts and CSV/Parquet exports.

Engineering labor uses Idealogic's $75/hr senior CEE rate against a $165/hr US agency rate (2.2x). Those are agency billing rates, not wages. For context, the EU whole-economy average labour cost was EUR 34.9 per hour in 2025 (Eurostat lc_lci_lev), and BLS wage data for US software developers (15-1252.00) puts the median at $63.98 per hour (May 2024). The license inputs for Options A and B ($5,800/mo and $3,400/mo) and every hour count are Idealogic modelling assumptions. Neither vendor publishes a price for this scale:

  1. Option A: Metabase Enterprise + analytical replica (500 tenants, 5,000 MAU):
    • Initial setup (120 hrs @ $75/hr CEE = $9,000; vs $165/hr US = $19,800): SSO JWT provisioning, @metabase/embedding-sdk-react wrapper, Data Sandboxing attributes, and theme overrides.
    • 36-month license & replica ($6,800/mo x 36 = $244,800): Assumed negotiated Enterprise white-label capacity commit ($5,800/mo, in place of about $60k/mo at linear Pro per-user list rates) + dedicated analytical Postgres replica & cache ($1,000/mo), plus 8 hrs/mo (288 hrs) BI & sandbox ops ($21,600 CEE / $47,520 US) = $275,400 ($312,120 US).
  2. Option B: Preset Cloud Embedded (managed Apache Superset) + analytical replica:
    • Initial setup (160 hrs @ $75/hr CEE = $12,000; vs $165/hr US = $26,400): Backend /guest_token/ signer, @superset-ui/embedded-sdk iframe integration, RLS-scoped datasets, and CSS theming.
    • 36-month Preset subscription & replica ($4,400/mo x 36 = $158,400): Assumed negotiated Preset Cloud embedded capacity plan ($3,400/mo, far below the listed viewer add-on scaled linearly) + analytical read replica & Redis cache ($1,000/mo), plus 10 hrs/mo (360 hrs) RLS & iframe ops ($27,000 CEE / $59,400 US) = $197,400 ($244,200 US).
  3. Option C: Self-hosted Apache Superset on EKS (Flask + Celery + Redis + Chromium):
    • Initial setup (320 hrs @ $75/hr CEE = $24,000; vs $165/hr US = $52,800): EKS Helm deployment across Gunicorn, Celery workers/beat, headless Chromium, Guest Token API, and iframe CSS overrides.
    • 36-month EKS & DB infra ($1,150/mo x 36 = $41,400): Multi-AZ EKS worker nodes, Redis, metadata DB, and analytical read replica ($0 Apache 2.0 license), plus 18 hrs/mo (648 hrs) Python/Celery/CVE upgrade & iframe ops ($48,600 CEE / $106,920 US) = $114,000 ($201,120 US, still constrained by <iframe> UX).
  4. Option D: Owned native React (Apache ECharts + TanStack Table) + semantic BFF + PG17 RLS rollups:
    • Turnkey build (680 hrs @ $75/hr CEE = $51,000; vs $165/hr US = $112,200): Native Next.js ECharts & TanStack Table components (dark-mode and design-token parity), allowlist semantic BFF, PG17 RLS hourly/daily rollups, streaming CSV/Parquet exports, and scheduled PDF/email digests.
    • 36-month AWS Graviton4 infra ($850/mo x 36 = $30,600): Graviton4 RDS PG17 rollup replica (or ClickHouse node) + Valkey cache, with no per-viewer license, plus 8 hrs/mo (288 hrs) metric & SRE ops ($21,600 CEE / $47,520 US) = $103,200 ($190,320 US).
Worked 36-month embedded analytics TCO ($k) at 500 B2B tenants and 5,000 MAU, license inputs assumed: native React + PG17 comes out $10.8k below self-hosted Superset, $94.2k (47.7%) below Preset and $172.2k (62.5%) below Metabase Enterprise
36-month line item (500 tenants, 5,000 MAU)Option A: Metabase EnterpriseOption B: Preset EmbeddedOption C: Self-Hosted SupersetOption D: Native React + PG17Primary economic driver
1. Initial build & RLS (@ $75/hr CEE)$9,000 (120h; $19.8k US)$12,000 (160h; $26.4k US)$24,000 (320h; $52.8k US)$51,000 (680h; $112.2k US)Option D builds native DOM charts, BFF & exports
2. 36-mo BI licenses & DB compute$244,800 ($6,800/mo)$158,400 ($4,400/mo)$41,400 ($1,150/mo)$30,600 ($850/mo)$0/viewer seat tax + pre-aggregated rollups
3. 36-mo BI, CVE & SRE ops (@ $75/hr)$21,600 (8h/mo; 288h)$27,000 (10h/mo; 360h)$48,600 (18h/mo; 648h)$21,600 (8h/mo; 288h)Superset Python/Celery/Chromium adds heavy SRE
Total 36-Month Embedded BI TCO$275,400$197,400$114,000$103,200 (CapEx incl.)Saves 62.5% ($172.2k) vs Metabase Ent.
Year-2+ Annual Run-Rate$88,800/yr$61,800/yr$30,000/yr$17,400/yrSaves $71,400/yr vs Metabase; $44,400/yr vs Preset
Frontend UX & IsolationReact SDK; AGPLv3<iframe> + Guest Token RLS<iframe> + Guest Token RLS100% Native DOM + PG17 RLSSub-120 ms p95 target, dark-mode parity

Sensitivity check: fewer than 100 external viewers vs 7.06-month payback at scale

  • Internal ops or fewer than 100 external B2B viewers. Launch on Metabase Pro ($575/mo base plus $12/user/mo, or $517.50/mo billed annually) or Preset Cloud ($20/user/mo Professional billed annually, $25 monthly; free 5-seat Starter).
  • Customer-facing SaaS scale (500 tenants, 1,000 to 15,000+ viewers). Option D's $42,000 incremental CapEx over Metabase Enterprise ($51,000 vs $9,000), divided by $5,950/mo recurring OpEx savings ($7,400/mo vs $1,450/mo), pays back in 7.06 months. Against Preset Embedded it's 10.54 months ($39,000 / $3,700/mo), and against self-hosted Superset 25.71 months. Even at $165/hr US agency rates across build and ops ($190,320), owning native React + PG17 beats self-hosted Superset ($201,120), Preset ($244,200, saving $53,880), and Metabase Enterprise ($312,120, saving $121,800).

2026 embedded analytics & native React BI build costs (Senior CEE vs US)

Our SaaS development, JavaScript development, and product development squads deliver multi-tenant analytics platforms at $75/hr senior CEE versus $165/hr US agency rates:

Engagement tierTimelineHoursSenior CEE ($75/hr)US Agency ($165/hr)Scope & deliverables
Metabase / Preset Embed MVP2 to 3 wks120 to 200h$9,000 to $15,000$19,800 to $33,000SSO JWT / Guest Token API, RLS rules & React wrapper
Self-Hosted Superset + EKS (320h)4 to 6 wks280 to 400h$21,000 to $30,000 ($24k)$46,200 to $66,000 ($52.8k)EKS Flask/Celery/Chromium IaC, Jinja RLS & CSS theme
Native React + Semantic BFF (680h)9 to 12 wks600 to 840h$45,000 to $63,000 ($51k)$99,000 to $138,600 ($112.2k)ECharts + TanStack, PG17 FORCE RLS rollups & exports
ClickHouse + Custom Builder13 to 17 wks960 to 1,320h$72,000 to $99,000$158,400 to $217,800ClickHouse rollups at 1B+ rows, drag-and-drop widget builder
Dedicated Data & UI PodOngoing240h/mo (2)From $18,000/moFrom $39,600/moSenior React/Next.js + PostgreSQL/ClickHouse engineers

Inside the worked 680-hour ($51,000 CEE vs $112,200 US) native React analytics build

Worked model, assumptions in text: 680-hour ($51,000 at $75/hr CEE vs $112,200 at $165/hr US) native React Apache ECharts, TanStack Table, semantic BFF & PG17 FORCE RLS analytics build
  • 1. Native React ECharts & TanStack Drill-Downs (30% / 204 hrs / $15,300 CEE vs $33,660 US): Accessible time-series, funnel, cohort, and virtualized pivot tables inheriting Tailwind dark-mode tokens, URL filter sync, and keyboard navigation.
  • 2. Allowlist Semantic BFF & Redis Cache (25% / 170 hrs / $12,750 CEE vs $28,050 US): Frozen AST metric/dimension compiler, 3000ms statement timeouts, tenant-scoped Valkey cache invalidation, and OpenAPI schema generation.
  • 3. PG17 RLS & rollup tables (20% / 136 hrs / $10,200 CEE vs $22,440 US): Incremental hourly/daily rollup workers, AS RESTRICTIVE + AS PERMISSIVE RLS policies, composite tenant foreign keys, and read-replica routing.
  • 4. Streaming CSV, Parquet & Scheduled Alerts (15% / 102 hrs / $7,650 CEE vs $16,830 US): Backpressure-safe Node.js streaming CSV/Parquet downloads to S3 presigned URLs plus threshold webhook and scheduled digest emails.
  • 5. Cross-Tenant Isolation & k6 Load QA (10% / 68 hrs / $5,100 CEE vs $11,220 US): Automated CI fuzz tests that assert zero cross-tenant leakage across 500 synthetic tenants and check a p95 latency target under 120 ms during concurrent dashboard bursts.

Metabase and Superset are terrific internal BI workbenches, yet bolting third-party iframes into a flagship B2B SaaS product eventually punishes either your gross margin or your user experience. Once five thousand external customers open your analytics tab every month, rendering native React charts atop a typed semantic API and PostgreSQL 17 Row-Level Security feels faster, matches your design system, and drops per-viewer seat licensing to zero.

Oleh Henaliuk · Deputy CEO at Idealogic

Shipped Idealogic proof & 5-step CTO decision checklist

Idealogic builds multi-tenant customer reporting, scoring telemetry, and real-time operational dashboards in production:

  • Multi-tenant scoring & 30-day monitoring analytics (Pressmerit link building platform): Next.js, NestJS, and PostgreSQL + pgvector SaaS platform computing structured 4-signal Domain Scores (0 to 100), transparent match-score breakdowns, and automated 30-day live-link verification ledgers at $0 commission.
  • Real-time operational & exception dashboards (HaulBreeze supply chain management software): Unified supply chain data layer surfacing real-time automated transaction telemetry and compliance alerts with 0 overnight reconciliation jobs.
  • Regulated consumer transaction reporting (C-Bank mobile banking app): High-clarity filterable transaction reporting engineered alongside PCI DSS v4.0.1 controls, lifting launch-quarter downloads +30%, MAU +40%, and cross-service usage +25%.

Five checks cover most Metabase vs Superset decisions for embedded analytics in 2026:

  1. Internal company BI, or fewer than 100 external B2B viewers who need ad-hoc self-serve builders? Pick Metabase Pro.
  2. Want Superset's dozens of built-in chart types under Apache 2.0 without managing Celery and Chromium yourself? Pick Preset Cloud with the embedding add-on.
  3. Strict VPC air-gap, existing Python/K8s SREs, and tolerance for <iframe> styling? Self-host Apache Superset, backed by PostgreSQL row-level security and never by Jinja filters alone.
  4. Already invested heavily in dbt or multi-engine headless caching? Pair Cube Core with custom React components.
  5. Scaling past 500 B2B tenants and 1,000 to 15,000+ external viewers, and want no iframes or per-viewer fees? Ship owned native React (ECharts + TanStack) on PG17 RLS or ClickHouse rollups ($850/mo infra and a 7.06-month payback in our model). Contact our team for a 48-hour architecture review.
Replacing Metabase seat fees or Superset iframes with native React analytics?
Send your current tenant scale, query latency targets, and warehouse schema. Our senior CEE engineers will return an embedded analytics blueprint and fixed-milestone quote within 48 hours.
Get a 48-hour embedded analytics estimate

Occasional field notes on building software, no spam

Protected by Cloudflare Turnstile · Privacy · Terms

Oleh Henaliuk
Oleh HenaliukDeputy CEO · Idealogic Development OÜ

Deputy CEO at Idealogic. Overseeing operational execution, product discovery, client partnerships, and engineering squad delivery.

Frequently asked questions

  • Choose Metabase Pro or Enterprise when you have fewer than 100 active external viewers, or when you want the React SDK and point-and-click self-service exploration with little setup. Choose Apache Superset (or Preset Cloud) when you serve thousands of external B2B users and want an Apache 2.0 license with Guest Token embedding and no per-viewer fee on the self-hosted edition. You accept iframe styling limits in exchange.

  • No. Open-source Metabase is AGPLv3, and guest embeds on the free edition carry the Powered by Metabase badge. Removing it needs a paid Pro or Enterprise plan, as do SSO-attribute Data Sandboxing and the React Embedding SDK. If you fork the source to strip the badge and serve that modified version to customers over a network, AGPLv3 Section 13 obliges you to offer them the modified source.

  • Metabase Pro starts at $575 per month ($517.50 per month billed annually) with 10 users included, then bills $12 per additional user per month ($130 per year). Guest embeds don't create Metabase users, so they aren't billed per viewer. Authenticated viewers of interactive SDK embeds are. At list rates 5,000 of them would cost about $60,000 per month, which is why Metabase points deployments that size to custom Enterprise pricing, published as starting at $20,000 per year.

  • Your backend authenticates the user and posts to Superset's /api/v1/security/guest_token/ endpoint with row-level security rules, each a dataset ID plus a SQL clause such as a tenant_id filter. The catch is human error. Superset reads through one shared database connection, so a new dataset built without an RLS rule or Jinja filter can expose other tenants' rows unless PostgreSQL row-level security backs it up.

  • Metabase runs as a single JVM process. Production Superset needs Python Flask and Gunicorn web pods, a metadata PostgreSQL instance, Redis caching, Celery workers with a Celery beat scheduler, and a headless Chromium browser (driven by Selenium or Playwright, depending on version) to render scheduled PNG or PDF reports. In our estimate, dependency upgrades, security patches and iframe CSS overrides take about 15 to 20 engineering hours a month.

  • Cube (Apache 2.0 core) is a headless semantic layer between PostgreSQL or ClickHouse and native React chart libraries such as Apache ECharts or TanStack Table. It centralizes metric definitions and serves Cube Store pre-aggregations, with no iframes. Lightdash (MIT core) is built around dbt projects. It suits internal data teams that want LookML-style YAML governance more than teams shipping lightweight white-label customer widgets.

  • Build native React charts on a typed semantic backend-for-frontend and PostgreSQL 17+ row-level security (or ClickHouse rollups) once customer-facing dashboards become core product UX or active viewers pass 1,000. Native DOM rendering removes iframe scrollbars and picks up your Tailwind dark-mode tokens directly. Our builds target sub 120 millisecond p95 query latency, and there's no per-viewer license fee.

  • With Idealogic senior Central and Eastern European TypeScript, React, and data engineers at $75 per hour (versus $165 per hour at US agencies), a 680-hour native analytics build costs $51,000 ($112,200 at US rates). That covers ECharts, TanStack Table, a semantic BFF, exports and PostgreSQL 17 row-level security. In our 36-month model it pays back against a negotiated Metabase Enterprise contract in roughly seven months.

  • For internal BI, Metabase is usually the easier pick: one JVM process plus a Postgres metadata database, and a point-and-click query builder that non-engineers can use. Superset suits SQL-heavy data teams that already run Python and Kubernetes and want an Apache 2.0 license. Embedding dashboards for customers changes the math.

Still unanswered
Ask us directly

A senior engineer replies under 4 hours.

Related expertise