Migrating from AWS QuickSight to Apache Superset

Why Teams Move Away from QuickSight

AWS QuickSight is a managed service, and for many organizations, that feels like a safe choice. It integrates natively with your AWS infrastructure, requires minimal DevOps overhead, and comes with AWS’s support umbrella. But as your analytics scale—as you embed dashboards into your product, as you need more control over query logic, as your per-user costs climb into five or six figures annually—QuickSight’s constraints become friction points.

The core issue isn’t QuickSight’s capability. It’s flexibility and cost. QuickSight charges per user (author and reader licenses), which means every new analyst, every product embed, every dashboard consumer adds to your bill. It also locks you into AWS’s data pipeline ecosystem. If your data lives in Snowflake, Postgres, or a data lake outside AWS, you’re paying for data transfer and managing external connections. And if you want to customize the UI, integrate with your own AI models, or run complex analytics logic outside QuickSight’s constraint model, you hit walls quickly.

Apache Superset, by contrast, is open-source and API-first. You own the infrastructure, you control the data flow, and you can extend it with your own models and logic. The trade-off is that you manage the platform yourself—or you use a managed service like D23 to handle the operational overhead while retaining full control and flexibility.

This guide walks you through the migration decision, the technical planning, and the execution steps to move from QuickSight to Superset without losing your dashboards, data connections, or team momentum.

Understanding the Cost Equation

Before you migrate, quantify the economics. This is the primary driver for most teams.

QuickSight Pricing Model

Amazon QuickSight charges based on user tiers:

• Author licenses: $15/month per user (data engineers, analysts who create dashboards)
• Reader licenses: $5/month per user (business users, stakeholders who view dashboards)
• Premium capacity: $24,000/year for unlimited authors and readers in a region

If you have 10 authors and 50 readers, you’re paying $150 + $250 = $400/month, or $4,800/year, before any data transfer or query costs. Scale to 50 authors and 500 readers, and you’re at $750 + $2,500 = $3,250/month, or $39,000/year. Premium capacity ($24,000/year) becomes attractive only if you have enough concurrent users.

Add to this:

• Data transfer out of AWS (if your data lives elsewhere): $0.02/GB egress
• SPICE (in-memory data store) capacity: $0.25/GB/month
• Query costs if you’re using Athena or Redshift as your data source

For a mid-market company with 100+ analysts and embedded dashboards in a product, QuickSight costs easily reach $50,000–$150,000 annually.

Superset Cost Structure

Superset itself is free—it’s Apache licensed open-source software. Your costs are:

• Infrastructure: Kubernetes cluster, database (Postgres/MySQL), Redis for caching. Expect $500–$2,000/month for a production setup at scale, depending on your cloud provider and query volume.
• Managed service (optional): If you use D23’s managed Apache Superset platform, you pay for hosting and support, typically $5,000–$20,000/month depending on scale, but you eliminate DevOps burden and get expert consulting included.
• Data infrastructure: Same as QuickSight (data warehouse, transfer costs), but you have more control over optimization.

For many teams, even a fully managed Superset service is 50–70% cheaper than QuickSight at scale, with no per-user licensing.

Comparing Feature Parity

Before migration, ensure Superset covers your use cases. It does—with caveats.

What Superset Does Better

• API-first architecture: Every dashboard, chart, and dataset is accessible via REST API. You can programmatically create, update, and delete assets. QuickSight has APIs, but they’re less comprehensive.
• Embedded analytics: Superset was built for embedding. You can embed dashboards in your product, control row-level security (RLS) at the API level, and customize the UI without fighting the platform.
• Text-to-SQL and AI integration: Superset integrates with LLMs via its Model Context Protocol (MCP) server, enabling natural language queries. This is a native feature in D23’s managed platform, not a bolt-on.
• Open-source extensibility: Want a custom visualization? Custom data connector? Custom authentication? You can build it. QuickSight forces you into its extension model.
• No per-user licensing: Scale your dashboards to 1,000 users without incrementing license costs.

What QuickSight Does Better

• Native AWS integration: If your entire data stack is AWS (Redshift, Athena, S3), QuickSight’s tight integration is convenient.
• Managed overhead: AWS handles patching, scaling, and availability. Superset requires you (or a managed provider) to run the platform.
• Q (natural language): QuickSight’s Q feature (natural language queries) is mature and integrated. Superset’s AI capabilities are newer, though rapidly evolving with LLM integration.
• Mobile apps: QuickSight has native mobile apps. Superset’s mobile experience is responsive but browser-based.

For most engineering and data teams at scale-ups and mid-market companies, Superset’s advantages outweigh QuickSight’s. The per-user licensing model is the deal-breaker for embedded analytics and large analyst teams.

Pre-Migration Audit

Don’t migrate blind. Audit your QuickSight environment first.

Inventory Your Assets

Using the Amazon QuickSight User Guide, document:

1. Dashboards: Count them, note their owners, list the visualizations in each.
2. Data sources: Which databases, data lakes, or SaaS tools do you connect to? QuickSight supports Redshift, Athena, RDS, S3, Salesforce, Google Analytics, and 40+ others.
3. Datasets: How many? Are they direct database connections, SPICE imports, or calculated fields?
4. Analyses: QuickSight distinguishes between analyses (editable, multi-user) and dashboards (published, read-only). Superset uses a simpler model: charts, dashboards, and datasets.
5. Custom visuals: QuickSight’s extension visuals. Note which ones you use—you’ll need to find Superset equivalents or build custom plugins.
6. Row-level security (RLS): How many dashboards use RLS? QuickSight’s RLS model is column/row filtering. Superset handles RLS via filters and dataset-level permissions.
7. Scheduled refreshes: How often do your SPICE datasets refresh? Superset uses cache invalidation and query scheduling differently.
8. Users and permissions: Export your user list and permission matrix. Superset’s permission model is role-based (Admin, Alpha, Gamma, SQL Lab, etc.).

Assess Complexity

Rate your migration difficulty:

• Low complexity: 10–20 dashboards, simple data sources (Postgres, Snowflake, Redshift), no custom visuals, standard RLS.
• Medium complexity: 20–50 dashboards, mixed data sources, some custom visuals, complex RLS logic.
• High complexity: 50+ dashboards, custom visuals, embedded use cases, real-time data requirements, complex governance.

If you’re high complexity, plan for 2–4 months and consider working with a Superset expert like D23’s data consulting team to guide the migration.

Technical Architecture Comparison

Understanding how these platforms differ architecturally helps you plan the migration.

QuickSight Architecture

QuickSight is a fully managed SaaS:

• Data ingestion: You connect QuickSight to your data sources. QuickSight queries them on-demand or imports data into SPICE (in-memory store).
• Metadata layer: Dashboards, analyses, and datasets are stored in AWS-managed databases.
• Rendering: Dashboards render in the browser via AWS’s frontend, or embedded via iframes/APIs.
• Scaling: AWS handles horizontal scaling, failover, and availability.

You have no control over infrastructure, query optimization, or caching strategy.

Superset Architecture

Superset is self-hosted (or managed by a provider):

• Web application: Python/Flask backend, React frontend.
• Metadata store: Postgres or MySQL database stores dashboard definitions, user permissions, chart configs.
• Query execution: Superset translates dashboard queries into SQL, executes them against your data sources, and caches results in Redis.
• Data sources: Superset connects to 30+ databases (Postgres, Snowflake, Redshift, BigQuery, Elasticsearch, etc.) via SQLAlchemy.
• Scaling: You scale horizontally by running multiple Superset instances behind a load balancer, scaling the metadata database, and scaling Redis cache.

You own the infrastructure, but you have full control over query logic, caching, and customization.

Data Flow Implications

In QuickSight, your data flows:

Your Data Source → QuickSight (AWS) → Browser/Embed

If your data is outside AWS, you pay egress costs. If you want to apply custom transformations, you do them upstream in your data warehouse.

In Superset, your data flows:

Your Data Source → Superset → Redis Cache → Browser/Embed

Superset queries your data source directly (or from cache). You can apply transformations in Superset’s SQL layer, custom Python code, or your data warehouse. You control the entire pipeline.

Planning Your Migration Path

Migration strategy depends on your complexity and risk tolerance.

Big Bang Migration (Low-Risk for Small Environments)

If you have fewer than 20 dashboards and simple data sources:

1. Set up a new Superset environment (self-hosted or managed).
2. Recreate data source connections in Superset.
3. Manually recreate dashboards in Superset (takes 2–4 hours per dashboard, depending on complexity).
4. Run both systems in parallel for 1–2 weeks.
5. Sunset QuickSight.

Timeline: 2–4 weeks for 10–20 dashboards.

Phased Migration (Lower Risk for Larger Environments)

For 20–50 dashboards or complex setups:

1. Phase 1 (Weeks 1–2): Set up Superset, migrate data sources, validate connectivity.
2. Phase 2 (Weeks 3–6): Migrate low-risk dashboards (simple, few users). Validate that data matches QuickSight.
3. Phase 3 (Weeks 7–10): Migrate medium-risk dashboards (more complex, more users). Run A/B testing if embedded.
4. Phase 4 (Weeks 11+): Migrate high-risk, business-critical dashboards. Sunset QuickSight.

Timeline: 2–3 months for 30–50 dashboards.

Parallel Operation with Gradual Cutover (Lowest Risk for Mission-Critical Environments)

For 50+ dashboards, embedded use cases, or high business impact:

1. Set up Superset in parallel to QuickSight.
2. Migrate and validate dashboards one team at a time.
3. Run both systems for 2–3 months.
4. Gradually shift users from QuickSight to Superset via URL redirects or product changes.
5. Monitor performance and correctness before sunsetting QuickSight.

Timeline: 3–6 months, depending on scale.

For teams with complex embedded analytics or high-stakes dashboards, working with D23’s managed Superset service can accelerate this process—they handle the technical heavy lifting and provide expert guidance.

Step-by-Step Migration Playbook

Step 1: Set Up Your Superset Environment

You have two options:

Option A: Self-Hosted Superset

Deploy Superset on your infrastructure:

# Using Docker Compose (simplest for testing)
git clone https://github.com/apache/superset.git
cd superset
docker-compose -f docker-compose-non-dev.yml up

For production, deploy to Kubernetes:

# Using Helm (recommended for production)
helm repo add superset https://apache.github.io/superset
helm install superset superset/superset

You’ll need:

• Kubernetes cluster (EKS, GKE, or self-managed)
• Postgres or MySQL for metadata
• Redis for caching
• Proper networking and security groups

Option B: Managed Superset (D23)

If you want to avoid DevOps overhead, D23’s managed Apache Superset platform handles infrastructure, scaling, and updates. You focus on data and dashboards.

Step 2: Connect Your Data Sources

In Superset, navigate to Data > Databases and add your data sources.

Superset supports:

• Cloud data warehouses: Snowflake, BigQuery, Redshift, Azure Synapse
• Open-source databases: Postgres, MySQL, MariaDB
• Data lakes: Athena, Presto, Trino
• SaaS: Salesforce, Google Analytics, Stripe (via connectors)

For each connection, provide:

• Host, port, username, password (or IAM role for AWS)
• Database name
• Connection string (optional, for advanced configs)

Test the connection before proceeding.

Step 3: Create Datasets

In Superset, a dataset is a virtual table that maps to a database table or SQL query.

For each QuickSight dataset:

1. Go to Data > Datasets > Create Dataset.
2. Select the database and table (or write a custom SQL query).
3. Configure columns:
   • Metric vs. Dimension: Metrics are numeric (sum, avg, count). Dimensions are categorical (date, region, product).
   • Aggregation: Set default aggregations (sum for revenue, count distinct for users, etc.).
   • Format: Set number format, date format, etc.
4. Save the dataset.

Superset automatically infers metric vs. dimension, but review and adjust. This is where you replicate QuickSight’s dataset logic.

Step 4: Migrate Dashboards

Unlike QuickSight, Superset doesn’t have a bulk dashboard import tool. You’ll recreate them, but it’s faster than you’d think.

For each QuickSight dashboard:

1. Document the dashboard in QuickSight:

   • Screenshot each visualization.
   • Note the title, filters, and underlying dataset.
   • List the exact metrics and dimensions in each chart.

2. Create a new dashboard in Superset:

   • Go to Dashboards > Create Dashboard.
   • Set the title and description.

3. Add charts:

   • Go to Charts > Create Chart.
   • Select the dataset.
   • Choose the visualization type (bar, line, table, etc.).
   • Configure metrics, dimensions, and filters to match the QuickSight chart.
   • Save the chart.
   • Add the chart to the dashboard.

4. Configure dashboard filters:

   • In Superset, filters are applied at the dashboard level.
   • Create filter widgets (date range, dropdown, etc.) and link them to charts.

5. Set refresh and caching:

   • For each chart, set the cache TTL (time-to-live). Default is 1 hour.
   • For real-time dashboards, set TTL to 1 minute or less (with performance implications).

Estimation: 2–4 hours per dashboard for simple dashboards, 4–8 hours for complex ones with many charts or custom logic.

Step 5: Implement Row-Level Security (RLS)

If you use RLS in QuickSight, replicate it in Superset.

QuickSight’s RLS model: Define rules like “Sales team sees only their region’s data.”

Superset’s RLS model: Use SQL WHERE clauses or dataset-level filters based on user attributes.

Example: Sales team sees only their region

1. In your dataset, add a filter:

   WHERE region = '{{ current_user_attribute("region") }}'

2. In Superset’s admin, set user attributes:

   • User: john_sales@company.com
   • Attribute: region = “North America”

3. When john_sales views a dashboard, Superset automatically filters data to North America.

For complex RLS, you can use D23’s expertise to design and implement governance models.

Step 6: Embed Dashboards (If Applicable)

If you embed QuickSight dashboards in your product, replicate that in Superset.

Superset’s embedding is API-first:

1. Get a guest token:

   POST /api/v1/security/guest_token/
   {
     "user": {"username": "guest_user"},
     "resources": [{"type": "dashboard", "id": 1}],
     "rls": [{"clause": "region = 'North America'"}]
   }

2. Embed the dashboard:

   <iframe src="https://your-superset.com/embedded/dashboard?token=GUEST_TOKEN"></iframe>

You can also embed individual charts, apply RLS at the API level, and customize styling.

Step 7: Validate Data Accuracy

Before sunsetting QuickSight, validate that metrics match.

1. Pick 5–10 critical dashboards (revenue, KPIs, business metrics).
2. Compare numbers between QuickSight and Superset:
   • Run the same query in both systems.
   • Check for rounding differences, timezone issues, or filter logic mismatches.
3. Document discrepancies:
   • Different aggregation logic (e.g., QuickSight sums revenue, but Superset counts transactions).
   • Timezone differences (QuickSight uses UTC, Superset uses server timezone).
   • Filter differences (QuickSight excludes nulls, Superset includes them).
4. Resolve discrepancies before go-live.

Common issues:

• Aggregation logic: Superset’s default aggregations might differ from QuickSight’s. Explicitly set aggregations in Superset’s dataset config.
• Null handling: Superset includes nulls in counts; QuickSight excludes them. Use COALESCE or FILTER in your SQL.
• Timezone: Ensure both systems use the same timezone for date filtering.

Step 8: Migrate Users and Permissions

Export your QuickSight user list and recreate roles in Superset.

Superset’s roles:

• Admin: Full access, can manage users and configurations.
• Alpha: Can create dashboards and datasets.
• Gamma: Can view dashboards and run SQL queries (SQL Lab).
• SQL Lab Only: Can only access SQL Lab (query editor).

Map QuickSight roles to Superset roles:

• QuickSight Author → Superset Alpha
• QuickSight Reader → Superset Gamma
• QuickSight Admin → Superset Admin

Bulk-create users via Superset’s API or CSV import.

Step 9: Set Up Monitoring and Alerting

Superset has built-in monitoring, but you’ll want to add observability.

1. Monitor query performance:

   • Superset logs query times in the metadata database.
   • Set up alerts if queries exceed a threshold (e.g., 30 seconds).

2. Monitor cache hit rates:

   • If cache hit rates are low, increase cache TTL or optimize queries.

3. Monitor uptime:

   • Set up health check monitoring on your Superset instance.
   • Use Prometheus + Grafana for metrics.

If you use D23’s managed platform, monitoring is included.

Step 10: Sunset QuickSight

Once you’ve validated Superset and migrated all users:

1. Set a sunset date (e.g., 30 days post-migration).
2. Redirect QuickSight URLs to Superset dashboards (if possible).
3. Communicate the change to stakeholders.
4. Archive QuickSight dashboards (don’t delete immediately, in case you need to reference them).
5. Cancel QuickSight subscriptions and reclaim budget.

Handling Edge Cases

Custom Visuals

QuickSight supports custom visuals via its extension framework. Superset has community-built visualizations, but not all QuickSight custom visuals have equivalents.

Solution:

• Use Superset’s built-in visualizations (30+ types) as replacements.
• For unique visuals, build a custom Superset plugin (requires React/TypeScript knowledge).
• Use D23’s consulting to help design custom visualizations.

Real-Time Dashboards

If you have real-time dashboards (sub-minute latency), Superset’s caching model might not fit.

Solution:

• Set cache TTL to 10–30 seconds (with performance tradeoffs).
• Use Superset’s API to push real-time data via WebSockets (advanced).
• Consider a hybrid approach: Superset for analytical dashboards, a dedicated real-time tool (e.g., Grafana) for operational metrics.

Complex Calculated Fields

QuickSight’s calculated fields allow complex logic (nested IFs, string manipulation, etc.). Superset handles this via SQL expressions in the dataset.

Example: QuickSight calculated field

if(Region = "North America", Revenue * 1.1, Revenue)

Superset SQL expression

CASE WHEN region = 'North America' THEN revenue * 1.1 ELSE revenue END

For very complex logic, move calculations to your data warehouse (dbt, SQL views) and reference them in Superset.

Scheduled Refreshes and Alerts

QuickSight has scheduled SPICE refreshes. Superset uses cache invalidation and query scheduling.

Solution:

• For periodic reports, use Superset’s scheduler to run queries at intervals.
• For alerts (e.g., “notify me if revenue drops below $X”), use Superset’s alerts feature (alert on chart thresholds).
• For more complex scheduling, use your data warehouse’s native scheduling (Snowflake tasks, Redshift Spectrum, etc.).

Cost Validation Post-Migration

After migration, track your actual costs:

1. Infrastructure costs: Monitor your Superset cluster’s compute, storage, and data transfer.
2. Data warehouse costs: Query volume should be similar to QuickSight (unless you optimize queries).
3. License savings: Calculate QuickSight cost avoidance.

Example cost comparison (100 analysts, 500 readers, embedded dashboards):

Cost Category	QuickSight	Superset (Self-Hosted)	Superset (D23 Managed)
User licenses	$39,000/year	$0	$0
Infrastructure	$0 (managed)	$12,000/year	Included
Data transfer	$2,000/year	$2,000/year	$2,000/year
Support	Included	$0	$24,000/year
Total	$41,000/year	$14,000/year	$26,000/year

Even with managed support, Superset is 30–65% cheaper at scale.

Leveraging AI and Advanced Features

Once you’re on Superset, take advantage of features QuickSight doesn’t offer.

Text-to-SQL Queries

Superset’s AI integration with LLMs enables natural language queries:

User: "Show me revenue by region for Q4"
Superset: Generates SQL, executes, returns chart

This is available natively in D23’s platform and works via the Model Context Protocol (MCP) server.

API-First Analytics

Build custom dashboards, programmatically update charts, and integrate Superset into your product:

import requests

# Create a dashboard
response = requests.post(
    "https://your-superset.com/api/v1/dashboards/",
    json={"dashboard_title": "Sales Dashboard"},
    headers={"Authorization": f"Bearer {token}"}
)

Custom Metrics and KPIs

Define business metrics once in Superset, reuse across all dashboards. Update the metric definition, and all dashboards using it update automatically.

Common Pitfalls and How to Avoid Them

1. Underestimating migration time: Plan for 2–4 hours per dashboard. Don’t assume bulk import tools exist.
2. Ignoring data validation: Always compare metrics between QuickSight and Superset before go-live.
3. Forgetting RLS: If you use row-level security, plan for 2–4 weeks to implement it in Superset.
4. Not optimizing queries: Superset is fast, but poorly written SQL is slow everywhere. Optimize your queries upfront.
5. Skipping monitoring: Set up observability from day one. You’ll need it to debug issues.
6. Rushing the cutover: Run both systems in parallel for at least 2 weeks. Let users test Superset before you sunset QuickSight.

When to Use a Managed Service

Self-hosting Superset saves money but requires DevOps expertise. Consider a managed service like D23 if:

• You have 50+ dashboards or 100+ analysts.
• You need embedded analytics in your product.
• You want AI-powered analytics (text-to-SQL, LLM integration).
• You lack in-house Kubernetes or database administration expertise.
• You value expert consulting and hands-on migration support.

Managed Superset providers handle infrastructure, scaling, security, and updates. You focus on data and dashboards.

Conclusion

Migrating from AWS QuickSight to Apache Superset is a strategic move for data and engineering leaders who prioritize flexibility, cost, and control. The migration is straightforward—especially for teams with fewer than 50 dashboards—and the ROI is significant: 30–70% cost savings, full API access, AI integration, and no per-user licensing.

Start with a small pilot (5–10 dashboards), validate data accuracy, and scale from there. If you need expert guidance, D23’s managed Superset platform accelerates the process and eliminates infrastructure overhead.

The question isn’t whether Superset can replace QuickSight. It can. The question is whether you’re ready to own your analytics stack—and for most scaling teams, the answer is yes.

Review the Apache Superset official documentation for detailed setup instructions, and check out comparative analyses from the Superset community for deeper technical comparisons. For teams evaluating open-source BI as an alternative to Looker, Tableau, and Power BI, DataCamp’s guide provides a comprehensive feature breakdown. The dbt Labs analysis focuses specifically on analytics capabilities and data team workflows, while Towards Data Science offers practical insights into Superset’s setup and ecosystem. For quantitative data on adoption trends, State of Databases surveys developer preferences and real-world usage patterns.