From Database to Natural Language Queries: Amazon QuickSuite End-to-End Data Analysis

A step-by-step guide to connecting databases, building dashboards, creating Topics for natural language Q&A, and setting up collaborative Spaces in Amazon QuickSuite.

zhuermu · · 15 min
Amazon QuickSuiteData AnalysisNL2SQLAWSBINatural Language

In the age of digital transformation, enterprises have accumulated massive volumes of business data. Traditional data analysis typically requires specialized engineers writing complex SQL queries — a bottleneck that limits how quickly teams can extract insights. Amazon QuickSuite is AWS’s AI-powered digital workspace that integrates the BI capabilities of Amazon QuickSight into a unified platform for data access, visualization, and natural language Q&A.

This article walks through the complete process: connecting a database (via public internet or private VPC), creating datasets and dashboards, setting up Topics for natural language queries, and bringing everything together in a collaborative Space.

Background

Amazon QuickSuite addresses three core needs:

  • Unified data access — Connect to databases, data warehouses, and SaaS applications from a single console, regardless of whether they sit on the public internet or inside a VPC.
  • AI-driven analytics — Go beyond static charts. The platform’s AI agent translates natural language questions into SQL queries and returns visual answers in seconds.
  • Collaborative Spaces — Share dashboards, Topics, and AI-generated insights across teams without emailing spreadsheets or screenshots.

The goal of this guide is to take you from a raw database to a working natural language Q&A system in five steps.

Core Components

Before diving into the implementation, here is a quick overview of the key building blocks:

ComponentPurpose
Data SourceA connection to a database (RDS, Redshift, MySQL, PostgreSQL, etc.) or SaaS application. Supports both public and VPC-based connectivity.
DatasetA defined set of data imported from a data source. Can be loaded into the SPICE engine for fast querying or queried directly against the source.
DashboardAn interactive visualization built from one or more datasets. Supports charts, filters, parameters, and drill-downs.
TopicA curated data model that maps database columns to business-friendly names, synonyms, and aggregation rules — enabling natural language queries.
SpaceA collaborative workspace where dashboards, Topics, and AI agents are shared with team members.
AI AgentThe natural language Q&A engine that interprets user questions, generates SQL, and returns visual answers.
SPICE EngineSuper-fast Parallel In-memory Calculation Engine — an in-memory store that accelerates queries by caching data from the source.

Step 1: Connect Your Database

Amazon QuickSuite supports two connectivity methods depending on your database’s network configuration.

1.1 Public Internet Connection

This is the simpler path, suitable for databases that are accessible over the public internet (for example, an RDS instance with a public endpoint).

Prerequisites:

  • The database instance has a public endpoint enabled.
  • The database security group allows inbound connections from the QuickSuite IP address range for your AWS region. You can find these IP ranges in the AWS IP address ranges documentation.

Steps:

  1. Log in to the Amazon QuickSuite console.
  2. Navigate to Datasets and click New dataset.
  3. Select your data source type (e.g., MySQL, PostgreSQL, MariaDB, Amazon Redshift).
  4. Enter the connection parameters:
    • Host: The public endpoint of your database (e.g., mydb.abc123.us-east-1.rds.amazonaws.com)
    • Port: The database port (e.g., 3306 for MySQL, 5432 for PostgreSQL)
    • Database name: The specific database to connect to
    • Username and password: Credentials with read access to the target tables
  5. Click Validate connection to test connectivity.
  6. Once validated, click Create data source to save.

1.2 VPC Private Connection

For databases that sit inside a VPC with no public endpoint, you need to configure a VPC connection so that QuickSuite can reach the database through a private network path.

When to use this:

  • The database is in a private subnet with no public IP.
  • Your organization’s security policy prohibits public database endpoints.
  • You need encryption in transit over a private network path.

Prerequisites:

  • Amazon QuickSuite Enterprise Edition (VPC connections are not available in Standard Edition).
  • System administrator permissions in QuickSuite.
  • A VPC with at least one subnet in the same Availability Zone as the database, and a security group that allows traffic from QuickSuite.

Steps:

  1. In the QuickSuite console, go to Manage QuickSuite and select VPC connections.
  2. Click Add VPC connection and provide:
    • VPC ID: The VPC where your database resides
    • Subnet ID: A subnet in the same AZ as your database instance
    • Security group ID: A security group that allows outbound traffic to the database port
  3. Save the VPC connection. QuickSuite will create an Elastic Network Interface (ENI) in the specified subnet.
  4. Update the database’s security group to allow inbound traffic from the QuickSuite ENI’s security group on the database port.
  5. Now create a new data source (as in Step 1.1), but select the VPC connection you just configured instead of using a public endpoint.
  6. Validate and save the connection.

Cross-region scenario: If your database is in a different AWS region than your QuickSuite deployment, you can use VPC Peering or AWS Transit Gateway to establish network connectivity between the two VPCs before configuring the VPC connection in QuickSuite.

Step 2: Create a Dataset

With the data source connected, the next step is to define a dataset that QuickSuite will use for dashboards and Topics.

  1. In the QuickSuite console, go to Datasets and click New dataset.
  2. Select the data source you created in Step 1.
  3. Choose your data selection method:
    • Select tables: Pick one or more tables from a visual browser. QuickSuite will auto-detect relationships if foreign keys are defined.
    • Custom SQL: Write a SQL query to define exactly which data to include. This is useful for joins, filters, or computed columns that you want to define at the dataset level.
  4. Choose the import mode:
    • SPICE: Imports data into the in-memory SPICE engine. Queries are fast because they run against the cache, not the source database. Best for datasets that don’t need real-time freshness.
    • Direct query: Runs queries directly against the source database. Data is always current, but query performance depends on the database’s capacity.
  5. In the data preparation screen, you can:
    • Rename fields to business-friendly names
    • Change data types (e.g., cast a string column to a date)
    • Add calculated fields (e.g., profit = revenue - cost)
    • Apply filters to exclude irrelevant rows
    • Define hierarchies (e.g., Year > Quarter > Month)
  6. If using SPICE, configure a refresh schedule (e.g., daily at 2:00 AM UTC) so the cached data stays reasonably current.
  7. Click Save & publish to make the dataset available for dashboards and Topics.

Step 3: Build a Dashboard

Dashboards turn raw data into interactive visualizations that business users can explore without writing SQL.

3.1 Create an Analysis

  1. Go to Analyses and click New analysis.
  2. Select the dataset you created in Step 2.
  3. QuickSuite opens the analysis editor — a drag-and-drop canvas where you build visualizations.

3.2 Add Visualizations

QuickSuite supports a wide range of chart types:

  • Bar charts for categorical comparisons (e.g., revenue by product category)
  • Line charts for time series trends (e.g., monthly active users)
  • Pie/donut charts for proportional breakdowns
  • Pivot tables for multi-dimensional aggregation
  • KPI widgets for single-metric highlights (e.g., total revenue this quarter)
  • Geospatial maps for location-based data

To add a visualization:

  1. Click Add > Add visual.
  2. Select a chart type.
  3. Drag fields from the field list to the chart’s configuration wells (e.g., drag product_category to the X axis and revenue to the Value well).
  4. QuickSuite automatically applies a default aggregation (SUM for numeric fields, COUNT for dimensions). You can change this by clicking the field in the well and selecting a different aggregation.

3.3 Add Filters and Interactivity

  • Filters: Add sheet-level or visual-level filters so users can narrow the data (e.g., filter by date range or region).
  • Parameters: Define parameters that users can set (e.g., a target revenue threshold) and reference them in calculated fields or conditional formatting.
  • Actions: Configure drill-down actions and cross-visual filtering so clicking a bar in one chart filters data in another.

3.4 Publish the Dashboard

Once your analysis is complete:

  1. Click Share > Publish dashboard.
  2. Give the dashboard a name and description.
  3. Select which users or groups should have access.
  4. The published dashboard is now a read-only, interactive view that stakeholders can access from the QuickSuite console.

Step 4: Create Topics for Natural Language Q&A

Topics are where Amazon QuickSuite’s AI capabilities come to life. A Topic is a curated layer on top of a dataset that teaches the AI agent how to interpret natural language questions.

4.1 What a Topic Defines

A well-configured Topic includes:

  • Business-friendly field names: Instead of prod_cat_id, the Topic maps this to “Product Category” so users can ask about “product category” in plain English.
  • Synonyms: Multiple names for the same concept. For example, “revenue”, “sales”, “income”, and “earnings” might all map to the same field. This dramatically improves recognition accuracy.
  • Field relationships and hierarchies: How fields relate to each other (e.g., a product belongs to a category, a city belongs to a region).
  • Common question patterns: Example questions that users might ask, which help the AI agent understand intent.
  • Default aggregations and calculations: Whether a field should be summed, averaged, or counted by default when mentioned in a question.

4.2 Create a Topic

  1. In the QuickSuite console, navigate to Topics.
  2. Click Create Topic.
  3. Give the Topic a name and description (e.g., “Sales Analytics” — “Ask questions about product sales, revenue, and customer trends”).
  4. Select the dataset(s) to include. QuickSuite automatically analyzes the data structure and suggests field configurations.
  5. For each field, review and configure:
    • Display name: A human-readable name (e.g., change order_dt to “Order Date”).
    • Description: A brief explanation of what the field represents (e.g., “The date when the customer placed the order”). This helps the AI agent disambiguate similar fields.
    • Synonyms: Add alternative names. For a field called “Revenue”, you might add “sales”, “total sales”, “income”, “earnings”.
    • Aggregation: Set the default aggregation (SUM, AVG, COUNT, MIN, MAX). Revenue fields typically default to SUM; rating fields to AVG.
    • Data type semantic: Mark fields as dimensions, measures, or date fields so the AI agent knows how to group and aggregate them.
  6. Configure field relationships if your Topic spans multiple tables. For example, link orders.customer_id to customers.id so the agent can answer questions that span both tables.
  7. Add sample questions to help train the AI agent:
    • “What was total revenue last quarter?”
    • “Show me the top 10 products by sales”
    • “How does revenue compare across regions this year vs. last year?”
  8. Click Save to publish the Topic.

4.3 Test and Refine

After creating a Topic, test it with natural language questions:

  1. Open the Topic and use the built-in Q&A interface.
  2. Type questions in plain English, such as “What are the top 5 selling products this month?”
  3. Review the generated SQL and results. If the AI misinterprets a question, go back and:
    • Add more synonyms to the relevant fields
    • Improve field descriptions
    • Add the misinterpreted question as a sample question with the correct interpretation
  4. Iterate until the Topic reliably answers the questions your users are likely to ask.

Step 5: Bring It All Together in a Space

A Space is a collaborative workspace where you assemble dashboards, Topics, and AI agents into a unified experience for your team.

  1. Navigate to Spaces and click Create Space.
  2. Give the Space a name (e.g., “Sales Analytics Hub”) and description.
  3. Add content to the Space:
    • Dashboards: Add the dashboard you created in Step 3.
    • Topics: Add the Topic you created in Step 4. This enables the natural language Q&A bar directly within the Space.
    • AI Agent: Enable the AI agent for the Space so team members can ask questions and get instant answers.
  4. Configure access permissions:
    • Add individual users or groups.
    • Set roles (Viewer, Contributor, Admin) to control who can view, edit, or manage the Space.
  5. Save and share the Space URL with your team.

Team members can now open the Space, browse the dashboard for visual insights, and type natural language questions into the Q&A bar to get instant, AI-generated answers — all without writing a single line of SQL.

Summary

The end-to-end workflow covered in this guide follows five steps:

  1. Connect — Establish a data source connection (public or VPC private).
  2. Model — Create a dataset with business-friendly field names, calculated fields, and refresh schedules.
  3. Visualize — Build interactive dashboards with charts, filters, and cross-visual actions.
  4. Curate — Create Topics with synonyms, descriptions, and sample questions to enable accurate natural language Q&A.
  5. Collaborate — Assemble everything in a Space where team members can explore dashboards and ask questions in plain English.

The key to a good natural language Q&A experience is investing time in Step 4 — the better your Topics are configured with synonyms, descriptions, and sample questions, the more accurately the AI agent will interpret and answer user queries. Start with a small, well-defined dataset, get the Topic working reliably, and then expand from there.