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: hourly, weekly, and monthly refresh intervals, full vs incremental refresh types, and timezone and day-of-week/month scheduling.

Refresh schedules depend on existing QuickSight datasets. Incremental refreshes require datasets with ingestion time columns that track when records were added. 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 interval property sets the cadence; HOURLY runs at the top of each hour. The dataSetId and scheduleId uniquely identify which dataset to refresh and which schedule configuration to use.

Schedule weekly incremental refreshes

Datasets that accumulate new records can use incremental refreshes to load only changed data, reducing processing time.

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

When refreshType is INCREMENTAL_REFRESH, QuickSight loads only records added since the last refresh. The timeOfTheDay property sets when the refresh runs (24-hour format), and timezone ensures it runs at the correct local time. The dayOfWeek property pins the refresh to a specific day; here, Monday at 1:00 AM London time.

Schedule monthly refreshes on specific days

Monthly reporting workflows often align refreshes with billing cycles or month-end processes.

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'

The dayOfMonth property replaces dayOfWeek for monthly schedules, running the refresh on a specific calendar day. Here, the dataset refreshes on the first day of each month at 1:00 AM London time. Monthly schedules still require timeOfTheDay and timezone configuration.

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 for incremental refresh, datasets with ingestion time columns. They focus on configuring the schedule rather than provisioning datasets or data sources.

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

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

These omissions are intentional: the goal is to illustrate how each refresh schedule feature is wired, not provide drop-in analytics 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

Refresh Types & Intervals

What refresh types are available for QuickSight datasets?

You can use FULL_REFRESH to reload all data or INCREMENTAL_REFRESH to update only changed data.

What schedule intervals can I configure?

QuickSight supports HOURLY, WEEKLY, and MONTHLY refresh intervals.

Schedule Configuration

What's required for weekly or monthly refresh schedules?

Both require timeOfTheDay and timezone. Weekly schedules use refreshOnDay.dayOfWeek (e.g., “MONDAY”), while monthly schedules use refreshOnDay.dayOfMonth (e.g., “1”).

Do hourly refreshes need a specific time or timezone?

No, the hourly example only requires interval: "HOURLY" without timeOfTheDay or timezone fields.

Import & Management

How do I import an existing QuickSight refresh schedule?

Use the format account-id,dataset-id,schedule-id with comma separators (e.g., 123456789012,dataset-id,schedule-id).

Using a different cloud?

Explore analytics guides for other cloud providers:

Azure Guides GCP Guides