Configure AWS QuickSight Refresh Schedules

The aws:quicksight/refreshSchedule:RefreshSchedule resource, part of the Pulumi AWS provider, defines when and how QuickSight datasets reload data from their sources. This guide focuses on three capabilities: refresh intervals (hourly, weekly, monthly), full vs incremental refresh types, and timezone and time-of-day controls.

Refresh schedules depend on existing QuickSight datasets. Incremental refreshes require datasets configured with ingestion time columns that track when records were added or modified. The examples are intentionally small. Combine them with your own dataset configurations and data source connections.

Schedule hourly full refreshes

Hourly schedules provide near-real-time visibility for dashboards tracking operational metrics.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.quicksight.RefreshSchedule("example", {
    dataSetId: "dataset-id",
    scheduleId: "schedule-id",
    schedule: {
        refreshType: "FULL_REFRESH",
        scheduleFrequency: {
            interval: "HOURLY",
        },
    },
});

import pulumi
import pulumi_aws as aws

example = aws.quicksight.RefreshSchedule("example",
    data_set_id="dataset-id",
    schedule_id="schedule-id",
    schedule={
        "refresh_type": "FULL_REFRESH",
        "schedule_frequency": {
            "interval": "HOURLY",
        },
    })

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/quicksight"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := quicksight.NewRefreshSchedule(ctx, "example", &quicksight.RefreshScheduleArgs{
			DataSetId:  pulumi.String("dataset-id"),
			ScheduleId: pulumi.String("schedule-id"),
			Schedule: &quicksight.RefreshScheduleScheduleArgs{
				RefreshType: pulumi.String("FULL_REFRESH"),
				ScheduleFrequency: &quicksight.RefreshScheduleScheduleScheduleFrequencyArgs{
					Interval: pulumi.String("HOURLY"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var example = new Aws.Quicksight.RefreshSchedule("example", new()
    {
        DataSetId = "dataset-id",
        ScheduleId = "schedule-id",
        Schedule = new Aws.Quicksight.Inputs.RefreshScheduleScheduleArgs
        {
            RefreshType = "FULL_REFRESH",
            ScheduleFrequency = new Aws.Quicksight.Inputs.RefreshScheduleScheduleScheduleFrequencyArgs
            {
                Interval = "HOURLY",
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.quicksight.RefreshSchedule;
import com.pulumi.aws.quicksight.RefreshScheduleArgs;
import com.pulumi.aws.quicksight.inputs.RefreshScheduleScheduleArgs;
import com.pulumi.aws.quicksight.inputs.RefreshScheduleScheduleScheduleFrequencyArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new RefreshSchedule("example", RefreshScheduleArgs.builder()
            .dataSetId("dataset-id")
            .scheduleId("schedule-id")
            .schedule(RefreshScheduleScheduleArgs.builder()
                .refreshType("FULL_REFRESH")
                .scheduleFrequency(RefreshScheduleScheduleScheduleFrequencyArgs.builder()
                    .interval("HOURLY")
                    .build())
                .build())
            .build());

    }
}

resources:
  example:
    type: aws:quicksight:RefreshSchedule
    properties:
      dataSetId: dataset-id
      scheduleId: schedule-id
      schedule:
        refreshType: FULL_REFRESH
        scheduleFrequency:
          interval: HOURLY

The refreshType property controls whether QuickSight reloads all data (FULL_REFRESH) or only new records (INCREMENTAL_REFRESH). The scheduleFrequency block sets the interval; HOURLY runs at the top of each hour. This configuration keeps dashboards current without specifying exact times or timezones.

Schedule weekly incremental refreshes

Large datasets often use incremental refreshes to reduce processing time by loading only changed records.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.quicksight.RefreshSchedule("example", {
    dataSetId: "dataset-id",
    scheduleId: "schedule-id",
    schedule: {
        refreshType: "INCREMENTAL_REFRESH",
        scheduleFrequency: {
            interval: "WEEKLY",
            timeOfTheDay: "01:00",
            timezone: "Europe/London",
            refreshOnDay: {
                dayOfWeek: "MONDAY",
            },
        },
    },
});

import pulumi
import pulumi_aws as aws

example = aws.quicksight.RefreshSchedule("example",
    data_set_id="dataset-id",
    schedule_id="schedule-id",
    schedule={
        "refresh_type": "INCREMENTAL_REFRESH",
        "schedule_frequency": {
            "interval": "WEEKLY",
            "time_of_the_day": "01:00",
            "timezone": "Europe/London",
            "refresh_on_day": {
                "day_of_week": "MONDAY",
            },
        },
    })

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/quicksight"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := quicksight.NewRefreshSchedule(ctx, "example", &quicksight.RefreshScheduleArgs{
			DataSetId:  pulumi.String("dataset-id"),
			ScheduleId: pulumi.String("schedule-id"),
			Schedule: &quicksight.RefreshScheduleScheduleArgs{
				RefreshType: pulumi.String("INCREMENTAL_REFRESH"),
				ScheduleFrequency: &quicksight.RefreshScheduleScheduleScheduleFrequencyArgs{
					Interval:     pulumi.String("WEEKLY"),
					TimeOfTheDay: pulumi.String("01:00"),
					Timezone:     pulumi.String("Europe/London"),
					RefreshOnDay: &quicksight.RefreshScheduleScheduleScheduleFrequencyRefreshOnDayArgs{
						DayOfWeek: pulumi.String("MONDAY"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var example = new Aws.Quicksight.RefreshSchedule("example", new()
    {
        DataSetId = "dataset-id",
        ScheduleId = "schedule-id",
        Schedule = new Aws.Quicksight.Inputs.RefreshScheduleScheduleArgs
        {
            RefreshType = "INCREMENTAL_REFRESH",
            ScheduleFrequency = new Aws.Quicksight.Inputs.RefreshScheduleScheduleScheduleFrequencyArgs
            {
                Interval = "WEEKLY",
                TimeOfTheDay = "01:00",
                Timezone = "Europe/London",
                RefreshOnDay = new Aws.Quicksight.Inputs.RefreshScheduleScheduleScheduleFrequencyRefreshOnDayArgs
                {
                    DayOfWeek = "MONDAY",
                },
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.quicksight.RefreshSchedule;
import com.pulumi.aws.quicksight.RefreshScheduleArgs;
import com.pulumi.aws.quicksight.inputs.RefreshScheduleScheduleArgs;
import com.pulumi.aws.quicksight.inputs.RefreshScheduleScheduleScheduleFrequencyArgs;
import com.pulumi.aws.quicksight.inputs.RefreshScheduleScheduleScheduleFrequencyRefreshOnDayArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new RefreshSchedule("example", RefreshScheduleArgs.builder()
            .dataSetId("dataset-id")
            .scheduleId("schedule-id")
            .schedule(RefreshScheduleScheduleArgs.builder()
                .refreshType("INCREMENTAL_REFRESH")
                .scheduleFrequency(RefreshScheduleScheduleScheduleFrequencyArgs.builder()
                    .interval("WEEKLY")
                    .timeOfTheDay("01:00")
                    .timezone("Europe/London")
                    .refreshOnDay(RefreshScheduleScheduleScheduleFrequencyRefreshOnDayArgs.builder()
                        .dayOfWeek("MONDAY")
                        .build())
                    .build())
                .build())
            .build());

    }
}

resources:
  example:
    type: aws:quicksight:RefreshSchedule
    properties:
      dataSetId: dataset-id
      scheduleId: schedule-id
      schedule:
        refreshType: INCREMENTAL_REFRESH
        scheduleFrequency:
          interval: WEEKLY
          timeOfTheDay: 01:00
          timezone: Europe/London
          refreshOnDay:
            dayOfWeek: MONDAY

Incremental refreshes require a dataset column that tracks ingestion time. The timeOfTheDay property sets when the refresh runs (24-hour format), and timezone ensures it fires in the correct region. The refreshOnDay block specifies dayOfWeek for weekly schedules. This configuration extends the basic example with precise timing controls.

Schedule monthly refreshes on specific days

Monthly refreshes suit datasets that aggregate historical data or support month-end reporting.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.quicksight.RefreshSchedule("example", {
    dataSetId: "dataset-id",
    scheduleId: "schedule-id",
    schedule: {
        refreshType: "INCREMENTAL_REFRESH",
        scheduleFrequency: {
            interval: "MONTHLY",
            timeOfTheDay: "01:00",
            timezone: "Europe/London",
            refreshOnDay: {
                dayOfMonth: "1",
            },
        },
    },
});

import pulumi
import pulumi_aws as aws

example = aws.quicksight.RefreshSchedule("example",
    data_set_id="dataset-id",
    schedule_id="schedule-id",
    schedule={
        "refresh_type": "INCREMENTAL_REFRESH",
        "schedule_frequency": {
            "interval": "MONTHLY",
            "time_of_the_day": "01:00",
            "timezone": "Europe/London",
            "refresh_on_day": {
                "day_of_month": "1",
            },
        },
    })

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/quicksight"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := quicksight.NewRefreshSchedule(ctx, "example", &quicksight.RefreshScheduleArgs{
			DataSetId:  pulumi.String("dataset-id"),
			ScheduleId: pulumi.String("schedule-id"),
			Schedule: &quicksight.RefreshScheduleScheduleArgs{
				RefreshType: pulumi.String("INCREMENTAL_REFRESH"),
				ScheduleFrequency: &quicksight.RefreshScheduleScheduleScheduleFrequencyArgs{
					Interval:     pulumi.String("MONTHLY"),
					TimeOfTheDay: pulumi.String("01:00"),
					Timezone:     pulumi.String("Europe/London"),
					RefreshOnDay: &quicksight.RefreshScheduleScheduleScheduleFrequencyRefreshOnDayArgs{
						DayOfMonth: pulumi.String("1"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var example = new Aws.Quicksight.RefreshSchedule("example", new()
    {
        DataSetId = "dataset-id",
        ScheduleId = "schedule-id",
        Schedule = new Aws.Quicksight.Inputs.RefreshScheduleScheduleArgs
        {
            RefreshType = "INCREMENTAL_REFRESH",
            ScheduleFrequency = new Aws.Quicksight.Inputs.RefreshScheduleScheduleScheduleFrequencyArgs
            {
                Interval = "MONTHLY",
                TimeOfTheDay = "01:00",
                Timezone = "Europe/London",
                RefreshOnDay = new Aws.Quicksight.Inputs.RefreshScheduleScheduleScheduleFrequencyRefreshOnDayArgs
                {
                    DayOfMonth = "1",
                },
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.quicksight.RefreshSchedule;
import com.pulumi.aws.quicksight.RefreshScheduleArgs;
import com.pulumi.aws.quicksight.inputs.RefreshScheduleScheduleArgs;
import com.pulumi.aws.quicksight.inputs.RefreshScheduleScheduleScheduleFrequencyArgs;
import com.pulumi.aws.quicksight.inputs.RefreshScheduleScheduleScheduleFrequencyRefreshOnDayArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new RefreshSchedule("example", RefreshScheduleArgs.builder()
            .dataSetId("dataset-id")
            .scheduleId("schedule-id")
            .schedule(RefreshScheduleScheduleArgs.builder()
                .refreshType("INCREMENTAL_REFRESH")
                .scheduleFrequency(RefreshScheduleScheduleScheduleFrequencyArgs.builder()
                    .interval("MONTHLY")
                    .timeOfTheDay("01:00")
                    .timezone("Europe/London")
                    .refreshOnDay(RefreshScheduleScheduleScheduleFrequencyRefreshOnDayArgs.builder()
                        .dayOfMonth("1")
                        .build())
                    .build())
                .build())
            .build());

    }
}

resources:
  example:
    type: aws:quicksight:RefreshSchedule
    properties:
      dataSetId: dataset-id
      scheduleId: schedule-id
      schedule:
        refreshType: INCREMENTAL_REFRESH
        scheduleFrequency:
          interval: MONTHLY
          timeOfTheDay: 01:00
          timezone: Europe/London
          refreshOnDay:
            dayOfMonth: '1'

For monthly intervals, use dayOfMonth instead of dayOfWeek to specify which day of the month triggers the refresh. The value “1” runs on the first day of each month. This configuration replaces the weekly day-of-week control with monthly day-of-month scheduling.

Beyond these examples

These snippets focus on specific refresh schedule features: refresh intervals (hourly, weekly, monthly), full vs incremental refresh types, and timezone and time-of-day scheduling. They’re intentionally minimal rather than complete data pipeline configurations.

The examples reference pre-existing infrastructure such as QuickSight datasets with defined schemas, and datasets configured for incremental refresh where applicable. They focus on scheduling configuration rather than dataset provisioning.

To keep things focused, common scheduling patterns are omitted, including:

Daily refresh schedules (interval: DAILY)
Start date configuration for schedule activation
Error handling and retry behavior
Multiple schedules per dataset

These omissions are intentional: the goal is to illustrate how each scheduling feature is wired, not provide drop-in data refresh modules. See the QuickSight RefreshSchedule resource reference for all available configuration options.

Let's configure AWS QuickSight Refresh Schedules

Get started with Pulumi Cloud, then follow our quick setup guide to deploy this infrastructure.

Try Pulumi Cloud for FREE

Frequently Asked Questions

Configuration & Scheduling

What refresh types are available?

The examples show two refresh types: FULL_REFRESH and INCREMENTAL_REFRESH.

How do I schedule hourly refreshes?

Set interval to HOURLY in scheduleFrequency. The hourly example doesn’t specify timeOfTheDay or timezone.

How do I schedule weekly refreshes?

Set interval to WEEKLY and configure refreshOnDay with dayOfWeek (e.g., MONDAY). You must also specify timeOfTheDay and timezone.

How do I schedule monthly refreshes?

Set interval to MONTHLY and configure refreshOnDay with dayOfMonth (e.g., "1"). You must also specify timeOfTheDay and timezone.

When do I need to specify timeOfTheDay and timezone?

The HOURLY example doesn’t include timeOfTheDay or timezone, while the WEEKLY and MONTHLY examples do. This suggests they’re required for non-hourly intervals.

Import & Management

How do I import an existing refresh schedule?

Use the format: AWS account ID, dataset ID, and schedule ID separated by commas. For example: 123456789012,dataset-id,schedule-id.

Using a different cloud?

Explore analytics guides for other cloud providers:

Azure Guides GCP Guides