Introduction

AWS Extended Support charges apply when running older versions of Amazon RDS, EKS, OpenSearch Service, and ElastiCache past standard support timeline. While you can query these costs using Amazon Athena, this article shows how to build a complete AI-powered analysis platform using Amazon Quick Suite—AWS's unified BI platform that evolved from QuickSight in October 2025, combining dashboards, natural language queries, AI-powered research, custom AI agents and automated workflows that alert teams when costs spike. This solution helps enterprises move beyond static reports to create a dynamic, self-service cost optimization system that scales across your organization.

Prerequisites

Before starting, ensure you have:

1. AWS Cost and Usage Report (CUR): Enable CUR with resource IDs, hourly granularity, and CUR 2.0 format, delivered to an S3 bucket with AWS Glue integration for data cataloging.
2. Amazon Athena: Configure Athena with your CUR data cataloged in AWS Glue and set up a workgroup with a query results location.
3. IAM Permissions: Grant quicksight: for Quick Suite operations, athena: for querying CUR data, s3:GetObject on your CUR bucket, and glue:GetTable for data catalog access.
4. Amazon Quick Suite Access: Subscribe to Pro tier ($35/month per user) for dashboard creation and AI features, or Reader tier ($3/month per user) for view-only access. Quick Suite is available in US East (N. Virginia, us-east-1), US West (Oregon, us-west-2), Europe (Dublin, eu-west-1), and Asia Pacific (Sydney, ap-southeast-2).

Architecture Overview

Data Flow:

1. CUR data stored in S3, cataloged in AWS Glue
2. Athena queries CUR data with optimized view
3. Quick Suite imports data to SPICE (Super-fast, Parallel, In-memory Calculation Engine, in-memory engine)
4. Users interact via dashboards, natural language, or automation

Step 1: Create optimized Athena view

Create a view that pre-aggregates Extended Support data for Quick Suite:

CREATE OR REPLACE VIEW extended_support_analysis AS
SELECT 
    -- Account Information
    bill_payer_account_id,
    line_item_usage_account_id,
    -- Service and Resource
    line_item_product_code AS service,
    line_item_resource_id AS resource_arn,
    -- Region (handles CUR 2.0 variations)
    COALESCE(
        NULLIF(regexp_replace(line_item_availability_zone, '[a-z]$', ''), ''),
        NULLIF(product_region_code, ''),
        NULLIF(product_location, '')
    ) AS region,
    -- Engine and Version
    product_database_engine AS engine,
    CASE 
        WHEN line_item_product_code = 'AmazonRDS' THEN
            COALESCE(
                regexp_extract(line_item_usage_type, '.*:([^:]+)$', 1),
                regexp_extract(line_item_line_item_description, '.*:([^:]+)$', 1)
            )
        ELSE ''
    END AS engine_version,
    -- Pricing Details
    product_extended_support_pricing_year AS pricing_year,
    line_item_usage_type, 
    -- Time Dimensions
    CAST(line_item_usage_start_date AS DATE) AS usage_date,
    year(line_item_usage_start_date) AS year,
    month(line_item_usage_start_date) AS month,
    -- Cost Metrics
    SUM(line_item_usage_amount) AS usage_amount,
    pricing_unit,
    SUM(line_item_unblended_cost) AS unblended_cost,
    SUM(line_item_net_unblended_cost) AS net_cost
FROM your_cur_table --REPLACE THIS: Use your actual CUR table name
WHERE 
    (
        regexp_like(line_item_usage_type, '(?i)extended ?support')
        OR regexp_like(line_item_line_item_description, '(?i)extended ?support')
    )
    AND line_item_line_item_type IN ('Usage', 'DiscountedUsage')
    AND line_item_usage_start_date >= date_add('month', -12, current_date)
GROUP BY 
    bill_payer_account_id,
    line_item_usage_account_id,
    line_item_product_code,
    line_item_resource_id,
    COALESCE(
        NULLIF(regexp_replace(line_item_availability_zone, '[a-z]$', ''), ''),
        NULLIF(product_region_code, ''),
        NULLIF(product_location, '')
    ),
    product_database_engine,
    CASE 
        WHEN line_item_product_code = 'AmazonRDS' THEN
            COALESCE(
                regexp_extract(line_item_usage_type, '.*:([^:]+)$', 1),
                regexp_extract(line_item_line_item_description, '.*:([^:]+)$', 1)
            )
        ELSE ''
    END,
    product_extended_support_pricing_year,
    line_item_usage_type,
    CAST(line_item_usage_start_date AS DATE),
    year(line_item_usage_start_date),
    month(line_item_usage_start_date),
    pricing_unit;

Key optimizations:

• Pre-aggregated metrics reduce dashboard query time
• Standardized region handling across services
• 12-month rolling window for trend analysis
• Tags excluded by default (see optional version below if you have resource tags enabled)
• Regex pattern captures ALL Extended Support charges across current and future AWS services
• Usage_date field is a DATE type that you'll aggregate by month in Quick Suite

Optional: Adding Resource Tags

If you enabled resource-level tagging in your CUR configuration, you can add tag columns to the view. Add these lines after line_item_usage_type:

-- Resource Tags (customize tag keys for your environment)
element_at(resource_tags, 'Environment') AS environment,
element_at(resource_tags, 'Application') AS application,
element_at(resource_tags, 'CostCenter') AS cost_center,

And add them to the GROUP BY clause:

element_at(resource_tags, 'Environment'),
element_at(resource_tags, 'Application'),
element_at(resource_tags, 'CostCenter'),

Note: The resource_tags column is only available if you enabled "Include resource IDs" when creating your CUR. If you get a "COLUMN_NOT_FOUND" error, your CUR doesn't have resource tags enabled.

Step 2: Connect Quick Suite to your data

1. Create Dataset:

• Navigate to Quick Suite → Quick Sight → Datasets → New dataset
• Select Athena as data source
• Choose extended_support_analysis view
• Import to SPICE for faster performance

2. Configure Refresh:

• Set daily incremental refresh
• Schedule during off-peak hours
• Enable email notifications for refresh failures

Step 3: Build Quick Sight dashboards

Create Analysis

1. Start New Analysis:

• Navigate to Quick Suite → Quick Sight → Analyses → New analysis
• Select your extended_support_analysis dataset
• Choose "Interactive sheet" layout

2. Add Calculated Fields:

• Click "Add" → "Add calculated field" and create: Cost per Resource Average cost per resource (useful for identifying high-cost outliers)

costPerResource = sum({net_cost}) / distinctCount({resource_arn})

• Apply to visualizations as needed

3. Add Visualizations:

• Drag fields from the dataset panel to create charts
• Use the visual types menu to select chart types (line, bar, donut, etc.)
• Configure field wells (X-axis, Y-axis, Group/Color, Size)

Recommended visualizations:

• KPIs: Total Extended Support Cost, Month-over-Month % Change, Number of Resources, Projected Annual Cost
• line chart: Monthly cost trend with usage_date aggregated by month
• Stacked bar: Cost by service (RDS, EKS, ElastiCache, OpenSearch)
• Donut chart: Cost distribution by pricing year (Year 1, Year 2, Year 3+)
• Heat map: Cost by account and region
• Table: Top 20 resources by cost with columns for Resource ARN, Service, Engine Version, Region, Monthly Cost, and Pricing Year (highlight Year 3+ in red)
• Bar chart: Cost by engine version
• Tree map: Cost hierarchy showing Account → Region → Service
• Table: Upgrade candidates showing potential savings

Sample visualization

Monthly Extended support costs (last 12 months) Trend

Extended Support Cost by pricing year

Extended Support Cost by account and region

Extended Support cost by database engine version

Configuration Tips:

• Enable auto-refresh for real-time updates (recommended: every 24 hours)
• Set up row-level security to restrict account visibility by user (critical for multi-account organizations)
• Add dashboard filters: Include controls for Account, Service, Region, Pricing Year, and Date Range to enable interactive filtering across all visualizations
• Use conditional formatting: Red for Year 3+, Yellow for Year 2, Green for Year 1

Publish and Share Dashboards

Once your analysis is complete, publish it as a dashboard by clicking "Share" → "Publish dashboard", then share with users by setting permissions (Viewer for read-only access, Co-owner for editing rights) and optionally enable embedding or scheduled email delivery for broader distribution.

Step 4: Create Quick Space

Create a Quick Space to organize your Extended Support knowledge and data:

1. Create Space: Quick Suite → Spaces → Create space → Enter name and description
2. Add Content: Select Add knowledge dropdown → Choose Dashboards and Topics (create topic first if needed). Optionally add File uploads or Knowledge bases for additional context.
3. Create Topic: Quick Suite → Topics → Create Topic → Add your dataset → Customize field names in Data tab for natural language queries
4. Share: Click Share → Add Owners (FinOps leads) and Viewers (engineering teams)

Step 5: Create custom chat agent for natural language analysis

Quick Suite includes a default "My Assistant" chat agent that works with all your data. For focused Extended Support analysis, create a custom agent:

1. Create Agent: Quick Suite console → Chat agents → Create chat agent → Skip to Builder view
2. Configure Core Settings:
   • Title: Enter a descriptive name for your agent
   • Agent Identity: "FinOps expert specializing in AWS Extended Support cost optimization and upgrade planning"
   • Persona Instructions: "You help teams optimize AWS Extended Support costs by analyzing spending patterns and identifying upgrade opportunities. When answering questions: (1) Understand the user's specific need, (2) Analyze costs by service, region, and pricing year using available data, (3) Prioritize Year 3+ resources first (3x cost multiplier), then Year 2 resources (2x multiplier), (4) Provide specific recommendations with cost breakdowns and potential savings estimates, (5) Always cite data sources from linked dashboards and topics. Focus on actionable insights that drive upgrade decisions."
   • Communication Style: Professional, data-driven, concise. Present findings with specific numbers and actionable next steps.
3. Link Knowledge: Choose "Link spaces" → Select the Space you created in Step 4
4. Add Suggested Prompts:
   • "Show me my top 10 costliest Extended Support resources"
   • "Which MySQL 5.7 instances should I prioritize for upgrade?"
   • "What are my total Extended Support costs by service?"
5. Launch: Test with "Update preview", then "Launch chat agent" and share with teams

You can also use Quick Flows to automate repetitive tasks- create workflows for weekly cost alerts, upgrade notifications, or monthly reports using natural language, no coding required.

Troubleshooting

• Missing Extended Support charges: Verify CUR includes Extended Support line items, check date range filters, confirm SPICE refresh completed, and validate regex patterns match your CUR version.
• Slow dashboard performance: Import data to SPICE instead of direct query, reduce date range, and pre-aggregate data in your Athena view.
• Quick chat returns unexpected results: Verify data source connections in Quick Spaces, simplify query phrasing, and ensure dataset includes necessary fields.

Additional Resources

• Amazon Quick Suite: https://aws.amazon.com/quick/
• AWS Cost and Usage Report User Guide: https://docs.aws.amazon.com/cur/latest/userguide/
• AWS RDS Extended Support Pricing: https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/extended-support.html
• AWS EKS Extended Support: https://docs.aws.amazon.com/eks/latest/userguide/kubernetes-versions-extended.html