A common ask from teams evaluating Sigma is migrating their Amazon QuickSight footprint — usually to take advantage of all the amazing things Sigma offers. The conversion itself can be a blocker — and the part this QuickStart automates.

The usual QuickSight-to-Sigma migration loop is recreate each dataset and its data-prep, re-author every calculated field as a Sigma formula, rebuild each sheet's visuals and layout, then eyeball the numbers and hope nothing drifted in the translation. Done on a single analysis it's tedious. Across an account with dozens of analyses reading from shared datasets, it's the reason migration projects slip.

This QuickStart walks through a Claude Code skill called quicksight-to-sigma that automates the loop.

Point it at a QuickSight analysis (or dashboard); it extracts the analysis definition, the datasets it depends on, and the data sources behind them over the AWS CLI, translates each calculated field's QuickSight expression into a Sigma formula, builds a Sigma data model from the warehouse tables the datasets point at, mirrors each sheet's visuals as a Sigma workbook page, and runs a row-level parity pass that compares Sigma's output to the QuickSight aggregation. It surfaces a punch list of anything it couldn't auto-translate — instead of silently producing a broken workbook.

What else this enables

A pure lift-and-shift is the floor, not the ceiling. The same skill family supports three follow-on moves that turn a migration into an upgrade:

Sample dashboard

For the demonstration, we'll convert a QuickSight analysis called Sales Pipeline — a sales-ops dashboard tracking opportunities across stages, segments, and regions. The analysis shows forecasted and weighted revenue by salesperson, opportunity counts by stage (Prospecting → Closed Won/Lost), and pipeline distribution across customer segments (Enterprise / Mid-Market / SMB / Startup) and US regions. The underlying dataset is a single 800-row pipeline table at one-row-per-opportunity grain, covering sales activity from January 2025 through May 2026:

Target Audience

Sigma SEs, technical CSMs, and migration partners running QuickSight-to-Sigma conversions — or scoping a batch migration with the companion quicksight-assessment skill.

Prerequisites

Sigma Free Trial

Footer

quicksight-to-sigma is one of two skills that ship together as a single repo (cloned in the next section). Most of this QuickStart focuses on the converter — but knowing where the assessment skill fits saves dead ends later when scoping a batch migration.

Skill

Role

When to reach for it

quicksight-assessment

Scoping

Auditing a QuickSight account before committing to a conversion plan. Emits a per-analysis complexity readout (visual-type mix, calculated-field count, window-function detection, dataset source types, RLS flags), and a value/cost-ranked migration shortlist that quicksight-to-sigma can consume. Read-only — only describe-* calls against the QuickSight API.

quicksight-to-sigma

Conversion

The subject of this QuickStart. Converts a single QuickSight analysis or dashboard (or a batch via shortlist) to a Sigma data model and matching workbook with verified row-level parity.

Here's how the two skills connect in a full migration — quicksight-assessment hands the converter a ranked shortlist, and quicksight-to-sigma produces the Sigma workbooks with a verified parity report:

Which skill for your situation

Not every migration needs both skills. Use the table below to map your scenario to the smallest set that fits.

In this QuickStart we're in the first row — one QuickSight analysis whose dataset reads from warehouse tables that we'll land in Snowflake — then run quicksight-to-sigma.

Your situation

Skill(s) to use

1 analysis, dataset reads from your warehouse

quicksight-to-sigma

1 analysis, dataset reads from a warehouse Sigma can't connect to

Land the data in your warehouse first (covered in Prepare the Demo Data), then quicksight-to-sigma

10+ analyses (any data source)

quicksight-assessment → quicksight-to-sigma in batch mode

Auditing QuickSight sprawl without converting yet

quicksight-assessment only

Footer

First we need to clone the skill's GitHub repository, configure AWS CLI access to QuickSight, and capture your Sigma credentials.

The two skills live in sigmacomputing/quickstarts-public under quicksight-migration-skills/.

From a terminal, run each command below one at a time so you can confirm each step before moving on.

Step 1: Create a local folder for the clone

mkdir -p ~/quickstarts-public

Step 2: Move into the new folder

cd ~/quickstarts-public

Step 3: Clone the repo without pulling any files yet

git clone --filter=blob:none --sparse https://github.com/sigmacomputing/quickstarts-public.git .

Step 4: Fill in only the quicksight-migration-skills folder

git sparse-checkout set quicksight-migration-skills

Step 5: Symlink quicksight-to-sigma into the Claude skills folder

ln -s ~/quickstarts-public/quicksight-migration-skills/quicksight-to-sigma ~/.claude/skills/quicksight-to-sigma

Step 6: Symlink quicksight-assessment

ln -s ~/quickstarts-public/quicksight-migration-skills/quicksight-assessment ~/.claude/skills/quicksight-assessment

Steps 5 and 6 should return with no error.

divider

Step 7: Install the Python dependency the skill uses.
 The skill calls QuickSight via boto3 when it's importable and falls back to the AWS CLI otherwise. Installing boto3 keeps everything in-process and avoids one subprocess per call.

python3 -m pip install boto3

divider

Step 8: Capture your Sigma API credentials.
 This script prompts for SIGMA_BASE_URL, SIGMA_CLIENT_ID, and SIGMA_CLIENT_SECRET and writes them into Claude's settings + the neutral ~/.sigma-migration/env file that the skill family uses to mint Sigma API tokens at runtime.

Run once per machine.

ruby ~/.claude/skills/quicksight-to-sigma/scripts/setup.rb

The final prompt asks for a Connection ID (full warehouse-connection UUID, optional — Enter to skip). You can press Enter to skip — the kickoff prompt later in this QuickStart supplies the Snowflake connection ID inline. Capturing it here is useful only if you plan to run multiple migrations and want it persisted in ~/.sigma-migration/env.

divider

Step 9: Install AWS CLI v2.
 The skill calls QuickSight's REST APIs through AWS CLI / boto3. If you've never installed AWS CLI before, the simplest path on macOS is Homebrew:

brew install awscli

For non-Homebrew installs or other platforms, follow AWS's official installer instructions at Install or update to the latest version of the AWS CLI

Verify it landed:

aws --version

You should see aws-cli/2.x.x or higher.

divider

Step 10: Configure AWS CLI authentication.
 The skill needs an AWS CLI profile that can call QuickSight's describe-* APIs against the account that owns the analysis you'll migrate. How you create that profile depends on what credentials your AWS admin gave you. Pick the option that matches.

Substitute {your-profile} with whatever profile name you want (e.g., sigma-qs) — you'll reuse it in the kickoff prompt later.

Option A — IAM user access key + secret (most common for one-off testing):

aws configure --profile {your-profile}

aws configure prompts for four values. Paste what your admin sent you for the first two, set the region to us-east-1 (see the note below about identity region), and use json as the output:

AWS Access Key ID [None]:      {your-access-key-id}
AWS Secret Access Key [None]:  {your-secret-access-key}
Default region name [None]:    us-east-1
Default output format [None]:  json

Option B — AWS IAM Identity Center (SSO):

aws configure sso --profile {your-profile}

That walks you through the SSO start URL, account, and role. After the initial setup, you'll run aws sso login --profile {your-profile} to refresh the session when it expires.

Option C — Okta-fronted AWS (install gimme-aws-creds first with pip install gimme-aws-creds):

gimme-aws-creds --profile {your-profile}

divider

Step 11: Verify access.

aws sts get-caller-identity --profile {your-profile}

You should see the AWS account ID and the IAM identity the skill will use. If you get Unable to locate credentials or ExpiredToken, re-run the appropriate Option above first.

Make a note of your AWS account ID for the kickoff prompt:

aws sts get-caller-identity --profile {your-profile} --query Account --output text

divider

Step 12: Verify Claude Code can invoke the skill.
 Type claude in your terminal to start Claude Code, then invoke the skill:

claude

/quicksight-to-sigma

Claude should start reading the reference files and ask what analysis you want to convert.

Pause at that prompt — we'll hand it everything in one shot via the kickoff prompt in Run the Conversion:

Footer

The QuickSight Sales Pipeline analysis reads from a single denormalized pipeline table — 10 columns covering opportunity, salesperson, segment, region, stage, and revenue. For the migration to land in Sigma cleanly, the same table needs to exist in a connection your Sigma org can reach.

Data prep has two halves:

  1. QuickSight side — nothing to do here for this QuickStart. We've already exported the source table and hosted it as a CSV in Amazon S3. The Snowflake COPY INTO statement below reads from S3 directly — no local download needed.
  2. Sigma side (this section) — the same data needs to live in a Snowflake schema your Sigma connection can read. We'll create one.
USE ROLE ACCOUNTADMIN;
USE WAREHOUSE COMPUTE_WH;

CREATE DATABASE IF NOT EXISTS QUICKSTARTS;
CREATE SCHEMA  IF NOT EXISTS QUICKSTARTS.QS_SALES_PIPELINE;
USE SCHEMA QUICKSTARTS.QS_SALES_PIPELINE;

CREATE OR REPLACE FILE FORMAT csv_format
  TYPE = CSV
  FIELD_DELIMITER = ','
  SKIP_HEADER = 1
  FIELD_OPTIONALLY_ENCLOSED_BY = '"'
  NULL_IF = ('', 'NULL')
  EMPTY_FIELD_AS_NULL = TRUE;

CREATE OR REPLACE STAGE qs_pipeline_stage
  URL = 's3://sigma-quickstarts-main/QuickSight/'
  FILE_FORMAT = csv_format;

CREATE OR REPLACE TABLE SALES_PIPELINE (
  SALE_DATE                   DATE,
  SALESPERSON                 VARCHAR,
  LEAD_NAME                   VARCHAR,
  SEGMENT                     VARCHAR,
  REGION                      VARCHAR,
  TARGET_CLOSE                DATE,
  FORECASTED_MONTHLY_REVENUE  NUMBER(38,2),
  OPPORTUNITY_STAGE           VARCHAR,
  WEIGHTED_REVENUE            NUMBER(38,2),
  ACTIVE                      BOOLEAN
);

COPY INTO SALES_PIPELINE FROM @qs_pipeline_stage/sales_pipeline.csv ON_ERROR = ABORT_STATEMENT;

GRANT USAGE  ON DATABASE QUICKSTARTS                                  TO ROLE SIGMA_SERVICE_ROLE;
GRANT USAGE  ON SCHEMA   QUICKSTARTS.QS_SALES_PIPELINE                TO ROLE SIGMA_SERVICE_ROLE;
GRANT SELECT ON ALL    TABLES IN SCHEMA QUICKSTARTS.QS_SALES_PIPELINE TO ROLE SIGMA_SERVICE_ROLE;
GRANT SELECT ON FUTURE TABLES IN SCHEMA QUICKSTARTS.QS_SALES_PIPELINE TO ROLE SIGMA_SERVICE_ROLE;

-- Sanity-check row count. Expected: 800.
SELECT COUNT(*) AS ROW_COUNT FROM SALES_PIPELINE;

-- Forecasted revenue baseline (~$35,632,675.44 for the warehouse snapshot).
SELECT TO_CHAR(SUM(FORECASTED_MONTHLY_REVENUE), '$999,999,999.99') AS FORECASTED_BASELINE
FROM SALES_PIPELINE;

If the load completes cleanly, the forecasted-revenue check returns $35,632,675.44. Any mismatch means either a COPY partial-load error (check Snowflake's load history) or a different S3 file than expected.

Footer

The converter needs a Sigma folder to land the new data model and workbook in. The skill will ask for the folder's UUID — it will be easier to have it ready before you return to the Claude prompt that's still paused after the skill loaded.

To keep this simple, we will use a plain folder and not a workspace.

Step 1: Create (or pick) a folder in Sigma.
 Open your Sigma org, navigate to where you want the migrated workbook to live, and create a folder for it. Something like:

QuickSight Migration Demo

Step 2: Grab the folder ID.
 Open the folder. The ID is the last segment of the URL — a short alphanumeric string, 21 characters. Copy it from the address bar and keep it on the clipboard for the next section.

Footer

The skill can run interactively, asking for the analysis, AWS account, warehouse, and Sigma destination one at a time. For a known target — like ours — it's faster to give Claude the entire job in one message. The skill recognizes a structured kickoff prompt and assembles the migrate-quicksight.rb command directly, going straight from "go" through discover → convert → data model → workbook build → layout → parity.

If Claude is still running and paused at the skill's first prompt from Install and Configure the Skill, return to that terminal. If you closed Claude after that step, restart it now:

claude

/quicksight-to-sigma

When Claude finishes loading the skill and asks what to migrate, choose Chat about this:

Paste the block below. Substitute your own values where the placeholders are:

Run /quicksight-to-sigma on the following. Use migrate-quicksight.rb end-to-end and stop only if a hard gate fails.

QuickSight
- AWS account ID: {your-aws-account-id}
- AWS profile: {your-aws-cli-profile-name}
- Region: us-east-1
- Analysis ID: {your-analysis-id}

Warehouse (Snowflake)
- Database: QUICKSTARTS
- Schema: QS_SALES_PIPELINE

Sigma
- SIGMA_API_TOKEN = mint from ~/.sigma-migration/env
- SIGMA_CONNECTION_ID: {your-snowflake-connection-id}
- SIGMA_FOLDER_ID: {your-folder-id}

Options
- Name prefix: QuickSight Sales Pipeline
- Auto-approve mid-pipeline questions: yes
- Parity: tolerate row-count drift between QuickSight (live) and the warehouse snapshot — this QuickStart uses a frozen CSV copy of the source. Report the delta with a row-level diff, but treat warehouse-snapshot staleness as a soft fail (not a gate-red).

Don't declare GREEN until the parity gate passes (or the tolerance above applies) and the visual-QA loop passes.

Claude reads the block, mints a fresh Sigma token from ~/.sigma-migration/env, assembles the migrate-quicksight.rb command with the right flags, and runs it end-to-end. The rest of the run is hands-off until a gate or decision point.

Footer

When the migration completes, Claude prints a final summary covering the whole pipeline — every phase's result, the visual-QA outcome, the hard-gate verdict, and the URLs of the new Sigma data model and workbook.

Despite making a few mistakes in the values provided, Claude was still able to complete the conversion:

The summary walks through six phases plus a visual-QA pass:

Open the new workbook in Sigma to see the migrated dashboard:

Open the data model to see how the converter wired up the dataset and calc fields:

Hand-polish items the skill flags rather than silently working around:

Footer

A single analysis is the easy case. Real migrations involve QuickSight accounts with dozens or hundreds of analyses reading from a handful of shared datasets — and migrating them one-by-one through the converter loses the leverage of doing the planning work once. That's where the companion quicksight-assessment skill comes in.

Point quicksight-assessment at a QuickSight account and it inventories every analysis, dashboard, and dataset, scoring each on:

The output is a Sigma-branded readout.md you can share with stakeholders, plus a ranked migration shortlist sorted by value / (1 + cost) — the cheapest, highest-value analyses to convert first.

The shortlist becomes input to a batch conversion plan — quicksight-assessment groups analyses that share the same dataset so one Sigma data model can serve a whole family of workbooks instead of producing N near-duplicate DMs. quicksight-to-sigma consumes that plan in batch mode and runs the conversions concurrently.

Typical flow for a real migration engagement:

  1. Run quicksight-assessment against the target account; review the shortlist with stakeholders.
  2. Pick the top N analyses to convert first — or drop the cold ones entirely.
  3. Hand the batch plan to quicksight-to-sigma and let it work through them.
  4. Spot-check each output; file the inevitable gap items upstream.

Footer

The following is a "grab bag" of things that might come up during real conversions, with the fix for each.

Footer

What you built is less a single conversion and more a repeatable migration path. The skill took a QuickSight analysis — datasets, calculated fields, visual layout, RLS rules — and produced a Sigma data model, a workbook, and a row-level parity report against the live warehouse, all from a single structured prompt. No one rebuilt the dashboard by hand, and the parity numbers are evidence rather than hope.

The patterns worth carrying into your next migration:

A first-pass conversion produces a working starting point and a documented punch list, not a hand-polished workbook. The polish loop is short, and you know exactly what to look at. That's the migration approach you can scale across an entire QuickSight account.

Additional Resource Links

Blog
Community
Help Center
QuickStarts

Be sure to check out all the latest developments at Sigma's First Friday Feature page!

   

Footer