Enhance Amazon Quick Suite dashboards with on-demand data refresh

Learn Blogs
1

Amazon Quick Suite is an agentic AI-powered digital workspace that provides business users with a set of agentic teammates that quickly answer questions at work and turn those answers into action. It also helps in transforming scattered data into strategic insights, helping customers make faster decisions and achieve better business outcomes. As organizations expand analytics workloads in Quick Suite, providing timely data without compromising dashboard performance becomes critical. For structured data sources, Quick Suite offers two primary connection methods: Super-fast, Parallel, In-memory Calculation Engine (SPICE), which caches data in memory for fast queries, and direct query, which retrieves data live from the source. SPICE delivers subsecond performance but relies on scheduled refreshes. Direct query mode provides real-time results but can introduce latency, especially with large datasets or complex queries during peak usage.

Many enterprise use cases require both high performance and up-to-date insights. For instance, a retail analytics team might need to update sales, inventory, and engagement data every 10–15 minutes. However, scheduled SPICE refreshes might not align with these frequent updates, and direct queries can slow down dashboards during peak usage when performance is critical.

On-demand SPICE refresh makes it possible for users to trigger dataset updates directly from the dashboard, providing real-time data without compromising performance. Because the API has usage limits (such as how often refreshes can occur within a day), this feature should be limited to admins or authorized users to prevent overuse. This approach combines SPICE’s fast query performance with the flexibility to update data when needed, providing accurate, timely insights for critical business decisions while maintaining optimal dashboard performance.

In this post, we show you how to enable on-demand SPICE refresh with a custom button in Quick Suite, as shown in the following screenshot, so you can maintain fast, interactive dashboards while giving users control over when data updates occur.

1266×729 45.6 KB

Solution overview

The solution is built on a SPICE dataset as the performance layer for the dashboard. The dataset ingests data from a supported source such as Amazon Relational Database Service (Amazon RDS), Amazon Redshift, Amazon Athena, or Amazon Simple Storage Service (Amazon S3). Although these are some of the most commonly used data sources, Quick Suite also supports a wide range of other data sources. A single SPICE dataset can also support many dashboards used across an organization, providing a shared, high-performance data layer that maintains consistency and reduces duplication. Scheduled refreshes maintain baseline data currency, and the on-demand refresh capability extends the architecture to support immediate updates triggered by users at critical moments.

This solution integrates a refresh control into a Quick Suite dashboard to initiate a SPICE dataset ingestion on demand. The refresh control is implemented as a Quick Suite custom action that sends a request to an Amazon API Gateway endpoint. API Gateway invokes an AWS Lambda function, which calls the Quick Suite CreateIngestion API to refresh the specified dataset. You can manually refresh datasets in an Enterprise edition account 32 times in a 24-hour period. You can manually refresh datasets in a Standard edition account 8 times in a 24-hour period. Each 24-hour period is measured starting 24 hours before the current date and time. After the ingestion is complete, the dashboard automatically presents the updated data to users.

The architecture of the solution is shown in the following diagram and includes the following components:

  • Quick Suite – Contains the dashboard and Refresh custom action
  • API Gateway – Serves as the secure REST API endpoint that Quick Suite invokes
  • Lambda – Receives the request and calls the Quick Suite API to start SPICE ingestion
  • Amazon S3 – Is the data source

569×484 22.8 KB

Prerequisites

The following prerequisites are required for this solution:

  • AWS account
  • Basic knowledge of AWS services
  • Quick Suite Enterprise edition
  • SPICE capacity under Quick Suite

Deployment

In the following sections, we walk through the steps needed to implement an on-demand SPICE ingestion pipeline using AWS services.

Create S3 bucket and upload dataset

In this first step, you create an S3 bucket for data storage and upload a dataset.

Create S3 bucket

  • Create an S3 bucket with the following steps:
  • On the Amazon S3 console, choose Create bucket.
  • Enter a bucket name, such as refresh-iris-data.
  • Select the AWS Region where you want to create the bucket.
  • Leave other settings as default or modify them based on your security or policy needs.
  • Choose Create bucket.

Upload dataset

Complete the following steps to upload your dataset:

  • On the Amazon S3 console, go to the S3 bucket you just created.
  • Choose Upload and choose Add files.
  • Select your dataset file (in this example, iris-parquet.csv).
  • Choose Upload.

936×306 58.2 KB

Create a manifest file for Quick Suite

Quick Suite uses a manifest file to understand the structure of files in Amazon S3. Use the following code to create a manifest file with the name iris-parquet.csv:

{
  "fileLocations": [
    {
      "URIs": [
        "s3://refresh-iris-data/iris-parquet.csv"
      ]
    }
  ],
  "globalUploadSettings": {
    "format": "CSV",
    "delimiter": ",",
    "textqualifier": "\"",
    "containsHeader": "true"
  }
}

Add Amazon S3 permissions to Quick Suite

Complete the following steps to add Amazon S3 permissions to Quick Suite:

  • On the Quick Suite console, choose your user name on the top right and choose Manage Quick Suite.
  • Under Permissions in the navigation pane, choose AWS resources.
  • In the Select Amazon S3 buckets section, select Select buckets, select the bucket you created (in this example, refresh-iris-data), then choose Finish.
  • Choose Save.

Create SPICE dataset in Quick Suite

In this step, you create a SPICE dataset with the data you have uploaded to Amazon S3.

Create dataset

Complete the following steps to create a dataset:

  • On the Quick Suite console, choose Datasets in the navigation pane.
  • Choose Create dataset.
  • Choose Create data source.
  • Choose S3 as the data source.
  • For Data source name, enter a name (for example, IrisDataFromS3).
  • For Upload a manifest file, enter the S3 URI of the manifest file (for example, s3://refresh-iris-data/manifest.json.)
  • Choose Connect.

Import dataset to SPICE

Quick Suite will read the file and show a preview. Complete the following steps to import the dataset to SPICE:

  • In the Data source details section, choose Visualize.

932×458 24.7 KB

  • Note the dataset ID. You can get it by opening the dataset and copying the URL. In the following example URL, the dataset ID is 2423b7: https://us-east- 1.quicksight.aws.amazon.com/data-sets/2423b7xxxx/view.

Create Lambda function to trigger ingestion

In this step, you create a Lambda function to trigger ingestion of the latest data.

Create Lambda function

Complete the following steps to create a Lambda function:

  • On the Lambda console, choose Create function.
  • For Function name, enter a name (for example, quicksuite_refresh).
  • For Runtime, choose Python 3.12 or newer.
  • Choose Create a new role with basic Lambda permissions.
  •  Choose Create function.
  • Create the Lambda function by entering the following code. This Lambda function is written in Python to trigger a SPICE ingestion refresh API for a Quick Suite dataset.
import json
import boto3
import uuid
def lambda_handler(event, context):
    print("Full event:", event)
    qs_params = event.get("queryStringParameters") or {}
    account_id = qs_params.get("QUICKSUITE_ACCOUNT_ID")
    dataset_id = qs_params.get("DATASET_ID")
    ingestion_type = "FULL_REFRESH"  # or "INCREMENTAL_REFRESH"
    if not account_id or not dataset_id:
        return {
            "statusCode": 400,
            "body": json.dumps({
                "message": "Missing required parameters: QUICKSUITE_ACCOUNT_ID and/or DATASET_ID"
            })
        }
    ingestion_id = str(uuid.uuid4())
    client = boto3.client("quicksight")
    try:
        response = client.create_ingestion(
            AwsAccountId=account_id,
            DataSetId=dataset_id,
            IngestionId=ingestion_id,
            IngestionType=ingestion_type
        )
        print("Full response:", response)
        return {
            "body": json.dumps({
                "StatusCode" : response.get("ResponseMetadata", {}).get("HTTPStatusCode"),
                "Arn": response.get("Arn"),
                "IngestionId": response.get("IngestionId"),
                "IngestionStatus": response.get("IngestionStatus"),
                "RequestId": response.get("RequestId")
            })
        }
    except Exception as e:
        print("Error:", str(e))
        return {
            "statusCode": 500,
            "body": json.dumps({
                "message": "Failed to start ingestion",
                "error": str(e)
            })
        }
  • Choose Deploy.

584×632 113 KB

Configure IAM role for Lambda

Complete the following steps to configure an AWS Identity and Access Management (IAM) role for Lambda:

  • On the Configurations tab, choose Permissions.
  • Under Execution role, choose the Role name link.
  • Attach the following inline policy to your Lambda function’s execution role:
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "logs:CreateLogGroup",
            "Resource": "arn:aws:logs:us-east-1::*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "logs:CreateLogStream",
                "logs:PutLogEvents"
            ],
            "Resource": [
                "arn:aws:logs:us-east-1: :log-group:/aws/lambda/quicksuitet_refresh:*"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "quicksight:CreateIngestion",
                "quicksight:DescribeIngestion"
            ],
            "Resource": "arn:aws:quicksight:us-east-1: :dataset/*"
        }
    ]
}

Test Lambda function

Complete the following steps to test your function:

  • On your function details page, choose Test.
  • Create a new event and enter a name, such as Refresh.
  • Provide the account ID and dataset ID as query parameters.
  • Choose Test.

Lambda should have a successful execution, as shown in the following screenshot.

842×302 56.7 KB

Create API Gateway endpoint integrated with Lambda function

Use the integrated endpoint to trigger your Lambda function (which starts Quick Suite ingestion) using a REST GET request.

Create new REST API

Complete the following steps to create a new REST API:

  • On the API Gateway console, in the navigation pane, choose APIs.
  • Choose Create API.
  • Select REST API.
  • Choose Build.
  • For API name, enter a name (for example, quicksuite_refresh).
  • For Endpoint type, choose Regional (the default value).
  • Choose Create API.

846×376 51.4 KB

  • In the navigation pane, under your new API, choose Create resource.
  • For the Resource name, enter refresh.
  • Choose Create resource.

936×208 22.8 KB

Create GET method for resource

Complete the following steps to create a GET method for the resource:

  • On the Resources page, choose the /refresh resource.
  • Choose Create method.

936×212 29.7 KB

  • Choose GET on the dropdown menu.
  • For Integration type, select Lambda function.
  • Enable Lambda proxy integration.
  • For Lambda function, enter the Lambda function you created earlier.
  • Choose Create method.

Deploy API

Complete the following steps to deploy the API:

  • On the API Gateway console, in the navigation pane, choose Deploy API.
  • For Deployment stage, select New stage.
  • For Stage name, enter prod (or dev).
  • Choose Deploy.

Test API

Complete the following steps to test the API:

  • On the API details page, choose the Test tab.
  • Enter the account ID and dataset ID as query parameters.
  • Choose Test.

The API should have a successful execution, as shown in the following screenshot.

936×182 50.1 KB

Add refresh dataset button in Quick Suite

To complete the solution, add a button to refresh the dataset.

Create parameter

Complete the following steps to create a parameter:

  • In Quick Suite, go to your analyses.
  • Under Parameters, choose Add.
    936×570 62.8 KB
  • Name the parameter refresh, set Data type to String, and enter Click here to refresh data for the Static default value.
  • Choose Create.

568×558 46.6 KB

Create calculated field

Complete the following steps to create a calculated field:

  • Choose Calculated field to create a new calculated field with the expression ${refresh}.
  • Name it refresh_field.

342×274 13 KB

Add table visual

Complete the following steps to add a table visual:

  • In the Visuals pane, add a new table visual to your analysis.
  • Drag refresh_field into the Group by section.

This creates a single-row table that displays your parameter value.

468×232 18.9 KB

Add custom action

Complete the following steps to add a custom action:

  • Choose the visual, choose Actions, and select Add URL action.
  • In the URL field, enter your API Gateway endpoint that triggers the ingestion, for example: https://your-api-url.amazonaws.com/dev/refresh?QUICKSUITE_ACCOUNT_ID=&DATASET_ID=.
  • For Open in, select New browser tab.
  • Choose Save.

Customize button

You can customize the button you just created as needed:

  • Hide column headers if needed.
  • Resize the visual to make it look like a button.
  • Customize formatting to make it more user-friendly (for example, change the font size, color, border, and so on).

Secure API gateway with resource policy

To help make sure only authorized users (for example, those accessing the solution from your organization’s proxy or specific IP addresses) can trigger the on-demand SPICE ingestion, use a resource policy on the API gateway to restrict access by IP address. Complete the following steps:

  • Identify the trusted IP address or range.
  • Identify the public IP address or CIDR block that your users will be coming from. For example, 22.01.13.11 /32 (single IP) or 22.01.13.11/24 (range).
  • On the API Gateway console, go to the API you created (for example, quicksuite_refresh).
  • In the navigation pane, choose Resource policy.
  • Enter the following policy:
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "AllowFromCorporateProxy",
      "Effect": "Allow",
      "Principal": "*",
      "Action": "execute-api:Invoke",
      "Resource": "arn:aws:execute-api:us-east-1::4muro2t76a/*/GET/refresh",
      "Condition": {
        "IpAddress": {
          "aws:SourceIp": [
            "”,
            ""
          ]
        }
      }
    },
    {
      "Sid": "DenyAllOthers",
      "Effect": "Deny",
      "Principal": "*",
      "Action": "execute-api:Invoke",
      "Resource": "arn:aws:execute-api:us-east-1::4muro2t76a/*/GET/refresh",
      "Condition": {
        "NotIpAddress": {
          "aws:SourceIp": [
            "”
          ]
        }
      }
    }
  ]
}
  • Choose Deploy to deploy your API.

Test the flow

With the solution complete, you can test it by choosing Refresh. You should see a JSON response with the ingestion status.

If you correctly configured the resource policy, the allowed environment receives an HTTP 201 OK response. Rerun the same command from an environment without an allowed IP address. A denied environment will receive an HTTP 403 Forbidden error.

You can view your refresh history on the console, as shown in the following screenshot.

718×404 46.9 KB

Conclusion

By implementing an on-demand SPICE refresh solution, you can maintain high-performance dashboards in Quick Suite while helping make sure data reflects the most recent updates when it matters most, all while providing end-users with direct control over when data is refreshed. This architecture gives decision-makers immediate access to accurate insights without compromising responsiveness or scalability. With the ability to trigger dataset refreshes directly from the dashboard, teams can align data updates with critical decision points, optimize resource usage, and reduce unnecessary ingestion jobs.

Adopt this solution to improve the timeliness and relevance of analytics, enhance the user experience, and increase the operational efficiency of enterprise BI workloads on AWS.

If you have any questions, comments, or suggestions, leave a comment. You can also visit AWS re:Post.

About the Authors

100×115 19.3 KB
Kanwar Bajwa is a Principal Enterprise Account Engineer at AWS who works with customers to optimize their use of AWS services and achieve their business objectives.

100×133 5.72 KB
Zainab Syeda is a Technical Account Manager at Amazon Web Services in Toronto. She works with customers in the Financial Services segment, helping them leverage cloud-native solutions at scale.

This is a companion discussion topic for the original entry at https://aws.amazon.com/blogs/business-intelligence/enhance-amazon-quick-suite-dashboards-with-on-demand-data-refresh/