Create AWS QuickSight Folders

The aws:quicksight/folder:Folder resource, part of the Pulumi AWS provider, provisions QuickSight folders that organize dashboards, analyses, and datasets into hierarchical structures. This guide focuses on three capabilities: root-level folder creation, permission assignment, and nested folder hierarchies.

Folders can reference parent folders for nesting and require QuickSight user or group ARNs for permission assignment. The examples are intentionally small. Combine them with your own QuickSight users, groups, and asset organization strategy.

Create a root-level folder with a name

Most QuickSight deployments start with a root-level folder that serves as a top-level container for organizing assets.

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

const example = new aws.quicksight.Folder("example", {
    folderId: "example-id",
    name: "example-name",
});

import pulumi
import pulumi_aws as aws

example = aws.quicksight.Folder("example",
    folder_id="example-id",
    name="example-name")

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.NewFolder(ctx, "example", &quicksight.FolderArgs{
			FolderId: pulumi.String("example-id"),
			Name:     pulumi.String("example-name"),
		})
		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.Folder("example", new()
    {
        FolderId = "example-id",
        Name = "example-name",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.quicksight.Folder;
import com.pulumi.aws.quicksight.FolderArgs;
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 Folder("example", FolderArgs.builder()
            .folderId("example-id")
            .name("example-name")
            .build());

    }
}

resources:
  example:
    type: aws:quicksight:Folder
    properties:
      folderId: example-id
      name: example-name

The folderId property sets a unique identifier for the folder within your AWS account. The name property defines the display name users see in the QuickSight console. Without a parentFolderArn, this creates a root-level folder at the top of your organizational hierarchy.

Grant user access with folder permissions

Teams control who can view, modify, or manage folders by assigning permissions to specific users or groups.

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

const example = new aws.quicksight.Folder("example", {
    folderId: "example-id",
    name: "example-name",
    permissions: [{
        actions: [
            "quicksight:CreateFolder",
            "quicksight:DescribeFolder",
            "quicksight:UpdateFolder",
            "quicksight:DeleteFolder",
            "quicksight:CreateFolderMembership",
            "quicksight:DeleteFolderMembership",
            "quicksight:DescribeFolderPermissions",
            "quicksight:UpdateFolderPermissions",
        ],
        principal: exampleAwsQuicksightUser.arn,
    }],
});

import pulumi
import pulumi_aws as aws

example = aws.quicksight.Folder("example",
    folder_id="example-id",
    name="example-name",
    permissions=[{
        "actions": [
            "quicksight:CreateFolder",
            "quicksight:DescribeFolder",
            "quicksight:UpdateFolder",
            "quicksight:DeleteFolder",
            "quicksight:CreateFolderMembership",
            "quicksight:DeleteFolderMembership",
            "quicksight:DescribeFolderPermissions",
            "quicksight:UpdateFolderPermissions",
        ],
        "principal": example_aws_quicksight_user["arn"],
    }])

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.NewFolder(ctx, "example", &quicksight.FolderArgs{
			FolderId: pulumi.String("example-id"),
			Name:     pulumi.String("example-name"),
			Permissions: quicksight.FolderPermissionArray{
				&quicksight.FolderPermissionArgs{
					Actions: pulumi.StringArray{
						pulumi.String("quicksight:CreateFolder"),
						pulumi.String("quicksight:DescribeFolder"),
						pulumi.String("quicksight:UpdateFolder"),
						pulumi.String("quicksight:DeleteFolder"),
						pulumi.String("quicksight:CreateFolderMembership"),
						pulumi.String("quicksight:DeleteFolderMembership"),
						pulumi.String("quicksight:DescribeFolderPermissions"),
						pulumi.String("quicksight:UpdateFolderPermissions"),
					},
					Principal: pulumi.Any(exampleAwsQuicksightUser.Arn),
				},
			},
		})
		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.Folder("example", new()
    {
        FolderId = "example-id",
        Name = "example-name",
        Permissions = new[]
        {
            new Aws.Quicksight.Inputs.FolderPermissionArgs
            {
                Actions = new[]
                {
                    "quicksight:CreateFolder",
                    "quicksight:DescribeFolder",
                    "quicksight:UpdateFolder",
                    "quicksight:DeleteFolder",
                    "quicksight:CreateFolderMembership",
                    "quicksight:DeleteFolderMembership",
                    "quicksight:DescribeFolderPermissions",
                    "quicksight:UpdateFolderPermissions",
                },
                Principal = exampleAwsQuicksightUser.Arn,
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.quicksight.Folder;
import com.pulumi.aws.quicksight.FolderArgs;
import com.pulumi.aws.quicksight.inputs.FolderPermissionArgs;
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 Folder("example", FolderArgs.builder()
            .folderId("example-id")
            .name("example-name")
            .permissions(FolderPermissionArgs.builder()
                .actions(                
                    "quicksight:CreateFolder",
                    "quicksight:DescribeFolder",
                    "quicksight:UpdateFolder",
                    "quicksight:DeleteFolder",
                    "quicksight:CreateFolderMembership",
                    "quicksight:DeleteFolderMembership",
                    "quicksight:DescribeFolderPermissions",
                    "quicksight:UpdateFolderPermissions")
                .principal(exampleAwsQuicksightUser.arn())
                .build())
            .build());

    }
}

resources:
  example:
    type: aws:quicksight:Folder
    properties:
      folderId: example-id
      name: example-name
      permissions:
        - actions:
            - quicksight:CreateFolder
            - quicksight:DescribeFolder
            - quicksight:UpdateFolder
            - quicksight:DeleteFolder
            - quicksight:CreateFolderMembership
            - quicksight:DeleteFolderMembership
            - quicksight:DescribeFolderPermissions
            - quicksight:UpdateFolderPermissions
          principal: ${exampleAwsQuicksightUser.arn}

The permissions array defines access control for the folder. Each permission entry specifies a principal (user or group ARN) and the actions they can perform. The actions list includes folder management operations like CreateFolder, UpdateFolder, and UpdateFolderPermissions. QuickSight evaluates these permissions when users attempt to access the folder or its contents.

Nest folders to build hierarchies

Organizations build multi-level folder structures by creating child folders that reference parent folders.

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

const parent = new aws.quicksight.Folder("parent", {
    folderId: "parent-id",
    name: "parent-name",
});
const example = new aws.quicksight.Folder("example", {
    folderId: "example-id",
    name: "example-name",
    parentFolderArn: parent.arn,
});

import pulumi
import pulumi_aws as aws

parent = aws.quicksight.Folder("parent",
    folder_id="parent-id",
    name="parent-name")
example = aws.quicksight.Folder("example",
    folder_id="example-id",
    name="example-name",
    parent_folder_arn=parent.arn)

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 {
		parent, err := quicksight.NewFolder(ctx, "parent", &quicksight.FolderArgs{
			FolderId: pulumi.String("parent-id"),
			Name:     pulumi.String("parent-name"),
		})
		if err != nil {
			return err
		}
		_, err = quicksight.NewFolder(ctx, "example", &quicksight.FolderArgs{
			FolderId:        pulumi.String("example-id"),
			Name:            pulumi.String("example-name"),
			ParentFolderArn: parent.Arn,
		})
		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 parent = new Aws.Quicksight.Folder("parent", new()
    {
        FolderId = "parent-id",
        Name = "parent-name",
    });

    var example = new Aws.Quicksight.Folder("example", new()
    {
        FolderId = "example-id",
        Name = "example-name",
        ParentFolderArn = parent.Arn,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.quicksight.Folder;
import com.pulumi.aws.quicksight.FolderArgs;
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 parent = new Folder("parent", FolderArgs.builder()
            .folderId("parent-id")
            .name("parent-name")
            .build());

        var example = new Folder("example", FolderArgs.builder()
            .folderId("example-id")
            .name("example-name")
            .parentFolderArn(parent.arn())
            .build());

    }
}

resources:
  parent:
    type: aws:quicksight:Folder
    properties:
      folderId: parent-id
      name: parent-name
  example:
    type: aws:quicksight:Folder
    properties:
      folderId: example-id
      name: example-name
      parentFolderArn: ${parent.arn}

The parentFolderArn property establishes the parent-child relationship. The child folder inherits its position in the hierarchy from the parent. QuickSight uses the folderPaths output to track the full ancestry chain, which appears empty for root-level folders and contains ancestor ARNs for nested folders.

Beyond these examples

These snippets focus on specific folder-level features: folder creation and naming, permission assignment, and hierarchical nesting. They’re intentionally minimal rather than full QuickSight organizational structures.

The examples may reference pre-existing infrastructure such as QuickSight users or groups for permission assignment. They focus on configuring folders rather than provisioning the complete QuickSight environment.

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

Folder type configuration (folderType defaults to SHARED)
Resource tagging for cost allocation
Cross-account folder access
Bulk permission management for multiple principals

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

Let's create AWS QuickSight Folders

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

Try Pulumi Cloud for FREE

Frequently Asked Questions

Folder Structure & Hierarchy

What's the difference between root and nested folders?

Root-level folders are created when parentFolderArn is not set. Nested folders require parentFolderArn pointing to the parent folder’s ARN.

How do I create a folder hierarchy?

Create the parent folder first, then reference its ARN in the child folder’s parentFolderArn property.

What does the folderPaths output contain?

An array of ancestor ARN strings for the folder. It’s empty for root-level folders.

Immutability & Updates

What properties are immutable after creation?

Three properties cannot be changed: folderId, awsAccountId, and parentFolderArn. Modifying these forces resource replacement.

Can I move a folder to a different parent?

No, parentFolderArn is immutable. You must recreate the folder under the new parent.

Permissions & Access Control

What permissions are needed for full folder management?

Eight QuickSight actions cover full management: CreateFolder, DescribeFolder, UpdateFolder, DeleteFolder, CreateFolderMembership, DeleteFolderMembership, DescribeFolderPermissions, and UpdateFolderPermissions.

How many permissions can I set on a folder?

Maximum of 64 permission items per folder.

Configuration & Defaults

What folder types are available?

Only SHARED is valid for folderType, which is also the default value.

Using a different cloud?

Explore analytics guides for other cloud providers:

Azure Guides GCP Guides