Amazon QuickSight: A Complete Guide for BI Teams

Amazon QuickSight is AWS’s native business intelligence service, and it occupies an interesting position in the BI landscape: it is not as feature-rich as Tableau or as deeply integrated with Microsoft ecosystems as Power BI, but for organisations already running their data stack on AWS, it offers a combination of native integration, serverless operation, and per-session pricing that competing tools cannot match. This guide covers what BI teams need to know to use QuickSight effectively in production.

Understanding SPICE: QuickSight’s In-Memory Engine

SPICE (Super-fast, Parallel, In-memory Calculation Engine) is the defining architectural feature of QuickSight and the source of both its performance advantages and its most significant operational limitations.

When you import data into a SPICE dataset, QuickSight copies the data into its distributed in-memory store. Queries against SPICE datasets run in milliseconds regardless of the underlying source complexity, because they operate on data already loaded into memory — not on live S3 or Redshift queries.

SPICE capacity limits: Each QuickSight account gets 10 GB of SPICE storage per user purchased, with a minimum of the Author tier. Additional SPICE capacity is purchasable at $0.25 per GB-month. A single SPICE dataset cannot exceed 500 million rows or 500 GB. If your dataset is larger than 500 GB, you must use direct query mode rather than SPICE import.

Refresh scheduling: SPICE datasets must be refreshed to reflect new data. You can schedule refreshes at intervals from hourly to monthly. As of 2023, QuickSight supports incremental refreshes for Athena, S3, and several database sources — only new or changed rows are re-imported, which dramatically reduces refresh time and cost for large datasets. Configure incremental refresh using a “lookback window” or a specific timestamp column:

Incremental refresh configuration:
- Lookback window: 3 days (re-import last 3 days on each refresh)
- Timestamp column: event_timestamp
- Schedule: Every 4 hours

Direct Query mode: For datasets that are too large for SPICE or require real-time data, QuickSight can query Athena, Redshift, Aurora, or RDS directly. Direct query dashboards are slower (query latency is visible to users) and generate query costs each time a dashboard is loaded or a filter is changed. Use direct query for operational dashboards where data freshness matters more than speed, and SPICE for executive and strategic dashboards where users expect sub-second response times.

Dataset Architecture and Calculated Fields

QuickSight’s dataset model has three layers: data sources (connections to S3, Athena, Redshift, etc.), datasets (the specific tables, queries, or joined views you build), and analyses (the visuals built on datasets).

Joins and Custom SQL

For complex data models, use a custom SQL query as your dataset source rather than importing a single table. QuickSight passes this SQL to the underlying engine (Athena, Redshift) and then imports the result into SPICE:

-- Custom SQL for a QuickSight dataset sourced from Athena
SELECT
    o.order_id,
    o.customer_id,
    o.order_date,
    o.order_amount,
    o.currency,
    c.country_code,
    c.customer_segment,
    p.product_category,
    p.product_name,
    DATE_TRUNC('month', o.order_date) AS order_month
FROM "commerce_db"."orders" o
JOIN "commerce_db"."customers" c ON o.customer_id = c.customer_id
JOIN "commerce_db"."order_items" oi ON o.order_id = oi.order_id
JOIN "commerce_db"."products" p ON oi.product_id = p.product_id
WHERE o.order_date >= DATE_ADD('month', -24, CURRENT_DATE)

Keep SPICE datasets focused — import only the columns and row ranges you need for the specific dashboard. Importing entire warehouse tables wastes SPICE capacity and increases refresh times.

Calculated Fields

QuickSight’s calculated field language is ANSI SQL-like with additional window functions. Common patterns:

# Year-over-year growth (calculated field)
(sum({order_amount}) - sum({order_amount}, PRE_FILTER)) / 
nullIf(sum({order_amount}, PRE_FILTER), 0)

# Rolling 7-day average using window functions
windowAvg(sum({daily_revenue}), [order_date ASC], 7, 0)

# Conditional categorisation
ifelse(
    {order_amount} >= 10000, "Enterprise",
    {order_amount} >= 1000, "Mid-Market",
    "SMB"
)

QuickSight’s Level Aware Aggregations (LAA) are a powerful feature that many users miss. They let you compute aggregations at different levels of granularity within a single visual:

# Customer-level average order value, displayed in an order-level table
avg({order_amount}, [customer_id])

Row-Level Security

For multi-tenant dashboards where different users should see different subsets of data, QuickSight’s Row-Level Security (RLS) is essential. RLS applies a per-user or per-group filter to every query automatically.

Configure RLS by creating a permission dataset — a table that maps QuickSight usernames or group names to the dimension values they are allowed to see:

UserName,country_code,customer_segment
alice@myorg.com,CA,Enterprise
bob@myorg.com,GB,Enterprise
carlos@myorg.com,NG,SMB
carlos@myorg.com,ZA,SMB

Upload this as a QuickSight dataset and attach it to your main dataset as an RLS rule. QuickSight automatically adds WHERE country_code IN ('NG', 'ZA') AND customer_segment = 'SMB' to every query Carlos makes, without any changes to the underlying data or the dashboard visuals.

RLS performance note: RLS filters are applied post-SPICE import, so they do not reduce the amount of data loaded into SPICE — they only affect what each user sees at query time. Ensure your SPICE dataset covers all the data you need for all users, and let RLS handle per-user visibility.

Embedding QuickSight in Applications

QuickSight’s embedded analytics capability is a significant differentiator for product teams. You can embed individual visuals, full dashboards, or the entire QuickSight console into a web application with fine-grained access control.

Use the QuickSight Embedding SDK with “Anonymous Embedding” (registered users who are not QuickSight users) for customer-facing analytics:

import boto3
import json

def get_dashboard_embed_url(dashboard_id: str, user_arn: str) -> str:
    qs = boto3.client('quicksight', region_name='ca-central-1')
    
    response = qs.generate_embed_url_for_registered_user(
        AwsAccountId='123456789012',
        ExpiresInSeconds=3600,
        UserArn=user_arn,
        ExperienceConfiguration={
            'Dashboard': {
                'InitialDashboardId': dashboard_id,
                'FeatureConfigurations': {
                    'StatePersistence': {'Enabled': True},
                    'Bookmarks': {'Enabled': True}
                }
            }
        },
        AllowedDomains=['https://app.myorg.com']
    )
    
    return response['EmbedUrl']

The AllowedDomains parameter is a security control — the embed URL only works when loaded from the specified domains, preventing URL leakage from exposing dashboards to unauthorised parties.

For internal applications where users are QuickSight registered users, the Q embedding (QuickSight Q is the natural language query interface) lets users ask questions in plain English and get chart responses — a significant time-saver for analyst-heavy workflows.

Pricing: Understanding Reader vs. Author vs. Q Costs

QuickSight’s pricing model is one of its most significant advantages over Tableau and Power BI for organisations with large numbers of occasional dashboard viewers. Understanding the pricing tiers prevents bill shock:

User Type	Monthly Cost (Standard)	Monthly Cost (Enterprise)
Author	$18	$24
Reader	$5 (or per-session, $0.30/session, max $5/month)	Same
Q Author	+$260/month/account (shared)	+$260/month

The Reader per-session pricing is the key insight: a user who opens QuickSight dashboards twice a month pays $0.60 rather than $5. For large organisations with hundreds of infrequent dashboard consumers — executives, regional managers — this makes QuickSight dramatically cheaper than tools with per-seat licensing.

SPICE storage cost: $0.25 per GB-month for storage beyond the 10 GB per Author included allocation. For a team of 10 authors, you have 100 GB included. Most BI datasets are compressed efficiently in SPICE — a 500-million-row fact table typically requires 50–150 GB of SPICE capacity.

Connecting QuickSight to Your Data Lake

For organisations running an analytics stack on AWS, QuickSight connects directly to:

• Amazon Athena: Query S3-based data lakes. SPICE imports the query result; direct query mode passes queries to Athena on demand.
• Amazon Redshift: Connect to a cluster or Redshift Serverless endpoint. QuickSight can use Redshift’s query result cache.
• Amazon S3: Connect directly to S3 files (CSV, Parquet, JSON). Best for small, stable reference datasets.
• AWS IoT Analytics: For IoT time-series data.

The Athena connection is the workhorse for data lake analytics. Pair QuickSight with the Athena SQL best practices covered in our dedicated guide to keep Athena query costs in check when refreshing large SPICE datasets.

For comparing QuickSight against other BI tools available to AWS shops, see our QuickSight vs. Tableau vs. Power BI comparison.

Production Best Practices

Version control your analyses: QuickSight does not natively integrate with Git. Use the QuickSight API to export analysis definitions as JSON and store them in version control. The describe-analysis-definition and create-analysis API calls support full round-trip import/export.

Separate datasets from analyses: Create one well-structured dataset and build multiple analyses on top of it rather than creating a new dataset for every analysis. This ensures SPICE data is consistent across dashboards and reduces storage costs.

Use themes for brand consistency: Define a QuickSight theme with your organisation’s colour palette and typography. Apply it at the account level so all new analyses inherit it. Nothing undermines executive confidence in a BI platform faster than inconsistent colours across dashboards.

Monitor SPICE refresh failures: SPICE dataset refresh failures are silent by default. Create a CloudWatch Events rule on QuickSight Dataset SPICE Ingestion events with IngestionStatus = FAILED and route alerts to your data engineering team’s SNS topic.

Conclusion

Amazon QuickSight is a capable, cost-efficient BI platform that fits naturally into AWS-native data stacks. Its strengths — the SPICE engine’s performance, per-session reader pricing, native AWS integrations, and embedded analytics SDK — make it the right default choice for organisations whose data lives in Athena, Redshift, or S3. Its limitations — a learning curve for complex calculated fields and a less mature ecosystem than Tableau — are real but manageable with good dataset architecture.

Infra IT Consulting helps BI teams deploy and optimise Amazon QuickSight dashboards on top of their AWS data platforms. Get in touch to discuss your analytics reporting requirements.