diff --git a/.changelog/30242.txt b/.changelog/30242.txt
new file mode 100644
index 000000000000..62e2f21ee724
--- /dev/null
+++ b/.changelog/30242.txt
@@ -0,0 +1,7 @@
+```release-note:enhancement
+resource/aws_resourcegroups_group: `resource_query` no longer conflicts with `configuration`
+```
+
+```release-note:bug
+resource/aws_resourcegroups_resource: Fix crash when resource Create fails
+```
\ No newline at end of file
diff --git a/internal/service/resourcegroups/group.go b/internal/service/resourcegroups/group.go
index 008f2cbd4730..899f64e26d55 100644
--- a/internal/service/resourcegroups/group.go
+++ b/internal/service/resourcegroups/group.go
@@ -44,9 +44,8 @@ func ResourceGroup() *schema.Resource {
 				Computed: true,
 			},
 			"configuration": {
-				Type:          schema.TypeSet,
-				Optional:      true,
-				ConflictsWith: []string{"resource_query"},
+				Type:     schema.TypeSet,
+				Optional: true,
 				Elem: &schema.Resource{
 					Schema: map[string]*schema.Schema{
 						"parameters": {
@@ -85,11 +84,10 @@ func ResourceGroup() *schema.Resource {
 				ForceNew: true,
 			},
 			"resource_query": {
-				Type:          schema.TypeList,
-				Optional:      true,
-				MinItems:      1,
-				MaxItems:      1,
-				ConflictsWith: []string{"configuration"},
+				Type:     schema.TypeList,
+				Optional: true,
+				MinItems: 1,
+				MaxItems: 1,
 				Elem: &schema.Resource{
 					Schema: map[string]*schema.Schema{
 						"query": {
@@ -178,17 +176,29 @@ func resourceGroupRead(ctx context.Context, d *schema.ResourceData, meta interfa
 		GroupName: aws.String(d.Id()),
 	})
 
-	isConfigurationGroup := false
+	hasQuery := true
 	if err != nil {
 		if tfawserr.ErrCodeEquals(err, resourcegroups.ErrCodeBadRequestException) {
 			// Attempting to get the query on a configuration group returns BadRequestException.
-			isConfigurationGroup = true
+			hasQuery = false
 		} else {
 			return diag.Errorf("reading Resource Groups Group (%s) resource query: %s", d.Id(), err)
 		}
 	}
 
-	if !isConfigurationGroup {
+	groupCfg, err := findGroupConfigurationByGroupName(ctx, conn, d.Id())
+
+	hasConfiguration := true
+	if err != nil {
+		if tfawserr.ErrCodeEquals(err, resourcegroups.ErrCodeBadRequestException) {
+			// Attempting to get configuration on a query group returns BadRequestException.
+			hasConfiguration = false
+		} else {
+			return diag.Errorf("reading Resource Groups Group (%s) configuration: %s", d.Id(), err)
+		}
+	}
+
+	if hasQuery {
 		resultQuery := map[string]interface{}{}
 		resultQuery["query"] = aws.StringValue(q.GroupQuery.ResourceQuery.Query)
 		resultQuery["type"] = aws.StringValue(q.GroupQuery.ResourceQuery.Type)
@@ -196,14 +206,7 @@ func resourceGroupRead(ctx context.Context, d *schema.ResourceData, meta interfa
 			return diag.Errorf("setting resource_query: %s", err)
 		}
 	}
-
-	if isConfigurationGroup {
-		groupCfg, err := findGroupConfigurationByGroupName(ctx, conn, d.Id())
-
-		if err != nil {
-			return diag.Errorf("reading Resource Groups Group (%s) configuration: %s", d.Id(), err)
-		}
-
+	if hasConfiguration {
 		if err := d.Set("configuration", flattenResourceGroupConfigurationItems(groupCfg.Configuration)); err != nil {
 			return diag.Errorf("setting configuration: %s", err)
 		}
diff --git a/internal/service/resourcegroups/group_test.go b/internal/service/resourcegroups/group_test.go
index f071e1ec566d..084ccc220a42 100644
--- a/internal/service/resourcegroups/group_test.go
+++ b/internal/service/resourcegroups/group_test.go
@@ -223,6 +223,40 @@ func TestAccResourceGroupsGroup_configurationParametersOptional(t *testing.T) {
 	})
 }
 
+func TestAccResourceGroupsGroup_resourceQueryAndConfiguration(t *testing.T) {
+	ctx := acctest.Context(t)
+	var v resourcegroups.Group
+	resourceName := "aws_resourcegroups_group.test"
+	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
+
+	configType := "AWS::NetworkFirewall::RuleGroup"
+
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck:                 func() { acctest.PreCheck(ctx, t) },
+		ErrorCheck:               acctest.ErrorCheck(t, resourcegroups.EndpointsID),
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
+		CheckDestroy:             testAccCheckResourceGroupDestroy(ctx),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccGroupConfig_resourceQueryAndConfiguration(rName, testAccResourceGroupQueryConfig, configType),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckResourceGroupExists(ctx, resourceName, &v),
+					resource.TestCheckResourceAttr(resourceName, "name", rName),
+					resource.TestCheckResourceAttrSet(resourceName, "arn"),
+					resource.TestCheckResourceAttr(resourceName, "resource_query.0.query", testAccResourceGroupQueryConfig+"\n"),
+					resource.TestCheckResourceAttr(resourceName, "configuration.#", "1"),
+					resource.TestCheckResourceAttr(resourceName, "configuration.0.type", configType),
+				),
+			},
+			{
+				ResourceName:      resourceName,
+				ImportState:       true,
+				ImportStateVerify: true,
+			},
+		},
+	})
+}
+
 func testAccCheckResourceGroupExists(ctx context.Context, n string, v *resourcegroups.Group) resource.TestCheckFunc {
 	return func(s *terraform.State) error {
 		rs, ok := s.RootModule().Resources[n]
@@ -425,3 +459,22 @@ resource "aws_resourcegroups_group" "test" {
 }
 `, rName, configType1, configType2)
 }
+
+func testAccGroupConfig_resourceQueryAndConfiguration(rName, query, configType string) string {
+	return fmt.Sprintf(`
+resource "aws_resourcegroups_group" "test" {
+  name = %[1]q
+
+  resource_query {
+    query = <<JSON
+%[2]s
+JSON
+
+  }
+
+  configuration {
+    type = %[3]q
+  }
+}
+`, rName, query, configType)
+}
diff --git a/internal/service/resourcegroups/resource.go b/internal/service/resourcegroups/resource.go
index 34560dbdee5e..9d4bfbee245f 100644
--- a/internal/service/resourcegroups/resource.go
+++ b/internal/service/resourcegroups/resource.go
@@ -2,20 +2,22 @@ package resourcegroups
 
 import (
 	"context"
+	"errors"
+	"fmt"
 	"log"
 	"strings"
 	"time"
 
 	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/awserr"
 	"github.com/aws/aws-sdk-go/service/resourcegroups"
 	"github.com/hashicorp/aws-sdk-go-base/v2/awsv1shim/v2/tfawserr"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/retry"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
 	"github.com/hashicorp/terraform-provider-aws/internal/conns"
-	"github.com/hashicorp/terraform-provider-aws/internal/create"
+	"github.com/hashicorp/terraform-provider-aws/internal/slices"
 	"github.com/hashicorp/terraform-provider-aws/internal/tfresource"
-	"github.com/hashicorp/terraform-provider-aws/names"
 )
 
 // @SDKResource("aws_resourcegroups_resource", name="Resource")
@@ -49,33 +51,32 @@ func ResourceResource() *schema.Resource {
 	}
 }
 
-const (
-	ResNameResource = "Resource"
-)
-
 func resourceResourceCreate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	conn := meta.(*conns.AWSClient).ResourceGroupsConn(ctx)
 
-	group := d.Get("group_arn").(string)
-	resourceArn := d.Get("resource_arn").(string)
-
-	in := &resourcegroups.GroupResourcesInput{
-		Group:        aws.String(group),
-		ResourceArns: []*string{&resourceArn},
+	groupARN := d.Get("group_arn").(string)
+	resourceARN := d.Get("resource_arn").(string)
+	id := strings.Join([]string{strings.Split(strings.ToLower(groupARN), "/")[1], strings.Split(resourceARN, "/")[1]}, "_")
+	input := &resourcegroups.GroupResourcesInput{
+		Group:        aws.String(groupARN),
+		ResourceArns: aws.StringSlice([]string{resourceARN}),
 	}
 
-	_, err := conn.GroupResourcesWithContext(ctx, in)
+	output, err := conn.GroupResourcesWithContext(ctx, input)
 
-	if err != nil {
-		return create.DiagError(names.ResourceGroups, create.ErrActionCreating, ResNameResource, d.Get("name").(string), err)
+	if err == nil {
+		err = FailedResourcesError(output.Failed)
 	}
 
-	vars := []string{
-		strings.Split(strings.ToLower(d.Get("group_arn").(string)), "/")[1],
-		strings.Split(d.Get("resource_arn").(string), "/")[1],
+	if err != nil {
+		return diag.Errorf("creating Resource Groups Resource (%s): %s", id, err)
 	}
 
-	d.SetId(strings.Join(vars, "_"))
+	d.SetId(id)
+
+	if _, err := waitResourceCreated(ctx, conn, groupARN, resourceARN, d.Timeout(schema.TimeoutDelete)); err != nil {
+		return diag.Errorf("waiting for Resource Groups Resource (%s) create: %s", d.Id(), err)
+	}
 
 	return resourceResourceRead(ctx, d, meta)
 }
@@ -83,7 +84,7 @@ func resourceResourceCreate(ctx context.Context, d *schema.ResourceData, meta in
 func resourceResourceRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	conn := meta.(*conns.AWSClient).ResourceGroupsConn(ctx)
 
-	out, err := FindResourceByARN(ctx, conn, d.Get("group_arn").(string), d.Get("resource_arn").(string))
+	output, err := FindResourceByTwoPartKey(ctx, conn, d.Get("group_arn").(string), d.Get("resource_arn").(string))
 
 	if !d.IsNewResource() && tfresource.NotFound(err) {
 		log.Printf("[WARN] ResourceGroups Resource (%s) not found, removing from state", d.Id())
@@ -92,11 +93,11 @@ func resourceResourceRead(ctx context.Context, d *schema.ResourceData, meta inte
 	}
 
 	if err != nil {
-		return create.DiagError(names.ResourceGroups, create.ErrActionReading, ResNameResource, d.Id(), err)
+		return diag.Errorf("reading Resource Groups Resource (%s): %s", d.Id(), err)
 	}
 
-	d.Set("resource_arn", out.Identifier.ResourceArn)
-	d.Set("resource_type", out.Identifier.ResourceType)
+	d.Set("resource_arn", output.Identifier.ResourceArn)
+	d.Set("resource_type", output.Identifier.ResourceType)
 
 	return nil
 }
@@ -104,37 +105,44 @@ func resourceResourceRead(ctx context.Context, d *schema.ResourceData, meta inte
 func resourceResourceDelete(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	conn := meta.(*conns.AWSClient).ResourceGroupsConn(ctx)
 
-	log.Printf("[INFO] Deleting ResourceGroups Resource %s", d.Id())
-
-	group := d.Get("group_arn").(string)
-	resourceArn := d.Get("resource_arn").(string)
-
-	_, err := conn.UngroupResourcesWithContext(ctx, &resourcegroups.UngroupResourcesInput{
-		Group:        aws.String(group),
-		ResourceArns: []*string{&resourceArn},
+	groupARN := d.Get("group_arn").(string)
+	resourceARN := d.Get("resource_arn").(string)
+	log.Printf("[INFO] Deleting Resource Groups Resource: %s", d.Id())
+	output, err := conn.UngroupResourcesWithContext(ctx, &resourcegroups.UngroupResourcesInput{
+		Group:        aws.String(groupARN),
+		ResourceArns: aws.StringSlice([]string{resourceARN}),
 	})
 
-	if err != nil {
-		return create.DiagError(names.ResourceGroups, create.ErrActionDeleting, ResNameResource, d.Id(), err)
+	if err == nil {
+		err = FailedResourcesError(output.Failed)
 	}
 
-	_, err = tfresource.RetryUntilNotFound(ctx, d.Timeout(schema.TimeoutDelete), func() (interface{}, error) {
-		return FindResourceByARN(ctx, conn, d.Get("group_arn").(string), d.Get("resource_arn").(string))
-	})
-
 	if err != nil {
-		return create.DiagError(names.ResourceGroups, create.ErrActionDeleting, ResNameResource, d.Id(), err)
+		return diag.Errorf("deleting Resource Groups Resource (%s): %s", d.Id(), err)
+	}
+
+	if _, err := waitResourceDeleted(ctx, conn, groupARN, resourceARN, d.Timeout(schema.TimeoutDelete)); err != nil {
+		return diag.Errorf("waiting for Resource Groups Resource (%s) delete: %s", d.Id(), err)
 	}
 
 	return nil
 }
 
-func FindResourceByARN(ctx context.Context, conn *resourcegroups.ResourceGroups, groupArn, resourceArn string) (*resourcegroups.ListGroupResourcesItem, error) {
+func FindResourceByTwoPartKey(ctx context.Context, conn *resourcegroups.ResourceGroups, groupARN, resourceARN string) (*resourcegroups.ListGroupResourcesItem, error) {
 	input := &resourcegroups.ListGroupResourcesInput{
-		Group: aws.String(groupArn),
+		Group: aws.String(groupARN),
 	}
+	var output []*resourcegroups.ListGroupResourcesItem
 
-	output, err := conn.ListGroupResourcesWithContext(ctx, input)
+	err := conn.ListGroupResourcesPagesWithContext(ctx, input, func(page *resourcegroups.ListGroupResourcesOutput, lastPage bool) bool {
+		if page == nil {
+			return !lastPage
+		}
+
+		output = append(output, page.Resources...)
+
+		return !lastPage
+	})
 
 	if tfawserr.ErrCodeEquals(err, resourcegroups.ErrCodeNotFoundException) {
 		return nil, &retry.NotFoundError{
@@ -147,11 +155,89 @@ func FindResourceByARN(ctx context.Context, conn *resourcegroups.ResourceGroups,
 		return nil, err
 	}
 
-	for _, resourceItem := range output.Resources {
-		if aws.StringValue(resourceItem.Identifier.ResourceArn) == resourceArn {
-			return resourceItem, nil
+	output = slices.Filter(output, func(v *resourcegroups.ListGroupResourcesItem) bool {
+		return v.Identifier != nil && aws.StringValue(v.Identifier.ResourceArn) == resourceARN
+	})
+
+	return tfresource.AssertSinglePtrResult(output)
+}
+
+func statusResource(ctx context.Context, conn *resourcegroups.ResourceGroups, groupARN, resourceARN string) retry.StateRefreshFunc {
+	return func() (interface{}, string, error) {
+		output, err := FindResourceByTwoPartKey(ctx, conn, groupARN, resourceARN)
+
+		if tfresource.NotFound(err) {
+			return nil, "", nil
+		}
+
+		if err != nil {
+			return nil, "", err
+		}
+
+		if output.Status == nil {
+			return output, "", nil
+		}
+
+		return output, aws.StringValue(output.Status.Name), nil
+	}
+}
+
+func waitResourceCreated(ctx context.Context, conn *resourcegroups.ResourceGroups, groupARN, resourceARN string, timeout time.Duration) (*resourcegroups.ListGroupResourcesItem, error) {
+	stateConf := &retry.StateChangeConf{
+		Pending: []string{resourcegroups.ResourceStatusValuePending},
+		Target:  []string{""},
+		Refresh: statusResource(ctx, conn, groupARN, resourceARN),
+		Timeout: timeout,
+	}
+
+	outputRaw, err := stateConf.WaitForStateContext(ctx)
+
+	if output, ok := outputRaw.(*resourcegroups.ListGroupResourcesItem); ok {
+		return output, err
+	}
+
+	return nil, err
+}
+
+func waitResourceDeleted(ctx context.Context, conn *resourcegroups.ResourceGroups, groupARN, resourceARN string, timeout time.Duration) (*resourcegroups.ListGroupResourcesItem, error) {
+	stateConf := &retry.StateChangeConf{
+		Pending: []string{resourcegroups.ResourceStatusValuePending},
+		Target:  []string{},
+		Refresh: statusResource(ctx, conn, groupARN, resourceARN),
+		Timeout: timeout,
+	}
+
+	outputRaw, err := stateConf.WaitForStateContext(ctx)
+
+	if output, ok := outputRaw.(*resourcegroups.ListGroupResourcesItem); ok {
+		return output, err
+	}
+
+	return nil, err
+}
+
+func FailedResourceError(apiObject *resourcegroups.FailedResource) error {
+	if apiObject == nil {
+		return nil
+	}
+
+	return awserr.New(aws.StringValue(apiObject.ErrorCode), aws.StringValue(apiObject.ErrorMessage), nil)
+}
+
+func FailedResourcesError(apiObjects []*resourcegroups.FailedResource) error {
+	var errs []error
+
+	for _, apiObject := range apiObjects {
+		if apiObject == nil {
+			continue
+		}
+
+		err := FailedResourceError(apiObject)
+
+		if err != nil {
+			errs = append(errs, fmt.Errorf("%s: %w", aws.StringValue(apiObject.ResourceArn), err))
 		}
 	}
 
-	return nil, tfresource.NewEmptyResultError(input)
+	return errors.Join(errs...)
 }
diff --git a/internal/service/resourcegroups/resource_test.go b/internal/service/resourcegroups/resource_test.go
index 2e5cce59307f..ca47eb1ef89b 100644
--- a/internal/service/resourcegroups/resource_test.go
+++ b/internal/service/resourcegroups/resource_test.go
@@ -2,32 +2,27 @@ package resourcegroups_test
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"testing"
 
 	"github.com/aws/aws-sdk-go/service/resourcegroups"
-	"github.com/hashicorp/aws-sdk-go-base/v2/awsv1shim/v2/tfawserr"
 	sdkacctest "github.com/hashicorp/terraform-plugin-testing/helper/acctest"
 	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
 	"github.com/hashicorp/terraform-plugin-testing/terraform"
 	"github.com/hashicorp/terraform-provider-aws/internal/acctest"
 	"github.com/hashicorp/terraform-provider-aws/internal/conns"
-	"github.com/hashicorp/terraform-provider-aws/internal/create"
 	tfresourcegroups "github.com/hashicorp/terraform-provider-aws/internal/service/resourcegroups"
-	"github.com/hashicorp/terraform-provider-aws/names"
+	"github.com/hashicorp/terraform-provider-aws/internal/tfresource"
 )
 
 func TestAccResourceGroupsResource_basic(t *testing.T) {
-	ctx := context.Background()
+	ctx := acctest.Context(t)
 	var r resourcegroups.ListGroupResourcesItem
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	resourceName := "aws_resourcegroups_resource.test"
 
 	resource.ParallelTest(t, resource.TestCase{
-		PreCheck: func() {
-			acctest.PreCheck(ctx, t)
-		},
+		PreCheck:                 func() { acctest.PreCheck(ctx, t) },
 		ErrorCheck:               acctest.ErrorCheck(t, resourcegroups.EndpointsID),
 		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
 		CheckDestroy:             testAccCheckResourceDestroy(ctx),
@@ -54,42 +49,39 @@ func testAccCheckResourceDestroy(ctx context.Context) resource.TestCheckFunc {
 				continue
 			}
 
-			_, err := tfresourcegroups.FindResourceByARN(ctx, conn, rs.Primary.Attributes["group_arn"], rs.Primary.Attributes["resource_arn"])
+			_, err := tfresourcegroups.FindResourceByTwoPartKey(ctx, conn, rs.Primary.Attributes["group_arn"], rs.Primary.Attributes["resource_arn"])
+
+			if tfresource.NotFound(err) {
+				continue
+			}
 
 			if err != nil {
-				if tfawserr.ErrCodeEquals(err, resourcegroups.ErrCodeNotFoundException) {
-					return nil
-				}
 				return err
 			}
 
-			return create.Error(names.ResourceGroups, create.ErrActionCheckingDestroyed, tfresourcegroups.ResNameResource, rs.Primary.ID, errors.New("not destroyed"))
+			return fmt.Errorf("Resource Groups Resource %s still exists", rs.Primary.ID)
 		}
 
 		return nil
 	}
 }
 
-func testAccCheckResourceExists(ctx context.Context, name string, resource *resourcegroups.ListGroupResourcesItem) resource.TestCheckFunc {
+func testAccCheckResourceExists(ctx context.Context, n string, v *resourcegroups.ListGroupResourcesItem) resource.TestCheckFunc {
 	return func(s *terraform.State) error {
-		rs, ok := s.RootModule().Resources[name]
+		rs, ok := s.RootModule().Resources[n]
 		if !ok {
-			return create.Error(names.ResourceGroups, create.ErrActionCheckingExistence, tfresourcegroups.ResNameResource, name, errors.New("not found"))
-		}
-
-		if rs.Primary.ID == "" {
-			return create.Error(names.ResourceGroups, create.ErrActionCheckingExistence, tfresourcegroups.ResNameResource, name, errors.New("not set"))
+			return fmt.Errorf("Not found: %s", n)
 		}
 
 		conn := acctest.Provider.Meta().(*conns.AWSClient).ResourceGroupsConn(ctx)
 
-		resp, err := tfresourcegroups.FindResourceByARN(ctx, conn, rs.Primary.Attributes["group_arn"], rs.Primary.Attributes["resource_arn"])
+		output, err := tfresourcegroups.FindResourceByTwoPartKey(ctx, conn, rs.Primary.Attributes["group_arn"], rs.Primary.Attributes["resource_arn"])
 
 		if err != nil {
-			return create.Error(names.ResourceGroups, create.ErrActionCheckingExistence, tfresourcegroups.ResNameResource, rs.Primary.ID, err)
+			return err
 		}
 
-		*resource = *resp
+		*v = *output
 
 		return nil
 	}
@@ -126,29 +118,32 @@ resource "aws_resourcegroups_group" "test" {
         "false"
       ]
     }
+
     parameters {
       name = "auto-host-recovery"
       values = [
         "false"
       ]
     }
+
     parameters {
       name = "auto-release-host"
       values = [
         "false"
       ]
     }
-
   }
 
   configuration {
     type = "AWS::ResourceGroups::Generic"
+
     parameters {
       name = "allowed-resource-types"
       values = [
         "AWS::EC2::Host"
       ]
     }
+
     parameters {
       name = "deletion-protection"
       values = [
@@ -157,8 +152,6 @@ resource "aws_resourcegroups_group" "test" {
     }
   }
 }
-
-
 `, rName))
 }
 
diff --git a/internal/service/resourcegroups/sweep.go b/internal/service/resourcegroups/sweep.go
new file mode 100644
index 000000000000..67894c9c64a3
--- /dev/null
+++ b/internal/service/resourcegroups/sweep.go
@@ -0,0 +1,65 @@
+//go:build sweep
+// +build sweep
+
+package resourcegroups
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/resourcegroups"
+	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
+	"github.com/hashicorp/terraform-provider-aws/internal/sweep"
+)
+
+func init() {
+	resource.AddTestSweepers("aws_resourcegroups_group", &resource.Sweeper{
+		Name: "aws_resourcegroups_group",
+		F:    sweepGroups,
+	})
+}
+
+func sweepGroups(region string) error {
+	ctx := sweep.Context(region)
+	client, err := sweep.SharedRegionalSweepClient(ctx, region)
+	if err != nil {
+		return fmt.Errorf("error getting client: %s", err)
+	}
+	conn := client.ResourceGroupsConn(ctx)
+	input := &resourcegroups.ListGroupsInput{}
+	sweepResources := make([]sweep.Sweepable, 0)
+
+	err = conn.ListGroupsPagesWithContext(ctx, input, func(page *resourcegroups.ListGroupsOutput, lastPage bool) bool {
+		if page == nil {
+			return !lastPage
+		}
+
+		for _, v := range page.GroupIdentifiers {
+			r := ResourceGroup()
+			d := r.Data(nil)
+			d.SetId(aws.StringValue(v.GroupName))
+
+			sweepResources = append(sweepResources, sweep.NewSweepResource(r, d, client))
+		}
+
+		return !lastPage
+	})
+
+	if sweep.SkipSweepError(err) {
+		log.Printf("[WARN] Skipping Resource Groups Group sweep for %s: %s", region, err)
+		return nil
+	}
+
+	if err != nil {
+		return fmt.Errorf("error listing Resource Groups Groups (%s): %w", region, err)
+	}
+
+	err = sweep.SweepOrchestratorWithContext(ctx, sweepResources)
+
+	if err != nil {
+		return fmt.Errorf("error sweeping Resource Groups Groups (%s): %w", region, err)
+	}
+
+	return nil
+}
diff --git a/internal/service/ssmincidents/replication_set_data_source_test.go b/internal/service/ssmincidents/replication_set_data_source_test.go
index dc01754f336c..593afdffb001 100644
--- a/internal/service/ssmincidents/replication_set_data_source_test.go
+++ b/internal/service/ssmincidents/replication_set_data_source_test.go
@@ -1,7 +1,6 @@
 package ssmincidents_test
 
 import (
-	"context"
 	"fmt"
 	"regexp"
 	"testing"
@@ -16,8 +15,7 @@ func testReplicationSetDataSource_basic(t *testing.T) {
 		t.Skip("skipping long-running test in short mode")
 	}
 
-	ctx := context.Background()
-
+	ctx := acctest.Context(t)
 	dataSourceName := "data.aws_ssmincidents_replication_set.test"
 	resourceName := "aws_ssmincidents_replication_set.test"
 
diff --git a/internal/service/ssmincidents/replication_set_test.go b/internal/service/ssmincidents/replication_set_test.go
index ef74f6d7ec71..dd0b05533a4a 100644
--- a/internal/service/ssmincidents/replication_set_test.go
+++ b/internal/service/ssmincidents/replication_set_test.go
@@ -24,8 +24,7 @@ func testReplicationSet_basic(t *testing.T) {
 		t.Skip("skipping long-running test in short mode")
 	}
 
-	ctx := context.Background()
-
+	ctx := acctest.Context(t)
 	resourceName := "aws_ssmincidents_replication_set.test"
 	region1 := acctest.Region()
 	region2 := acctest.AlternateRegion()
@@ -70,8 +69,7 @@ func testReplicationSet_updateRegionsWithoutCMK(t *testing.T) {
 		t.Skip("skipping long-running test in short mode")
 	}
 
-	ctx := context.Background()
-
+	ctx := acctest.Context(t)
 	resourceName := "aws_ssmincidents_replication_set.test"
 	region1 := acctest.Region()
 	region2 := acctest.AlternateRegion()
@@ -156,8 +154,7 @@ func testReplicationSet_updateRegionsWithCMK(t *testing.T) {
 		t.Skip("skipping long-running test in short mode")
 	}
 
-	ctx := context.Background()
-
+	ctx := acctest.Context(t)
 	resourceName := "aws_ssmincidents_replication_set.test"
 
 	resource.Test(t, resource.TestCase{
@@ -233,8 +230,7 @@ func testReplicationSet_updateTags(t *testing.T) {
 		t.Skip("skipping long-running test in short mode")
 	}
 
-	ctx := context.Background()
-
+	ctx := acctest.Context(t)
 	resourceName := "aws_ssmincidents_replication_set.test"
 
 	rKey1 := sdkacctest.RandString(26)
@@ -330,8 +326,7 @@ func testReplicationSet_updateEmptyTags(t *testing.T) {
 		t.Skip("skipping long-running test in short mode")
 	}
 
-	ctx := context.Background()
-
+	ctx := acctest.Context(t)
 	resourceName := "aws_ssmincidents_replication_set.test"
 
 	rKey1 := sdkacctest.RandString(26)
@@ -393,8 +388,7 @@ func testReplicationSet_disappears(t *testing.T) {
 		t.Skip("skipping long-running test in short mode")
 	}
 
-	ctx := context.Background()
-
+	ctx := acctest.Context(t)
 	resourceName := "aws_ssmincidents_replication_set.test"
 	region1 := acctest.Region()
 	region2 := acctest.AlternateRegion()
diff --git a/internal/service/ssmincidents/response_plan_data_source_test.go b/internal/service/ssmincidents/response_plan_data_source_test.go
index 9e7a55f40ec0..f36ecd1cc339 100644
--- a/internal/service/ssmincidents/response_plan_data_source_test.go
+++ b/internal/service/ssmincidents/response_plan_data_source_test.go
@@ -1,7 +1,6 @@
 package ssmincidents_test
 
 import (
-	"context"
 	"fmt"
 	"regexp"
 	"testing"
@@ -13,8 +12,7 @@ import (
 )
 
 func testResponsePlanDataSource_basic(t *testing.T) {
-	ctx := context.Background()
-
+	ctx := acctest.Context(t)
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	rTitle := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	dataSourceName := "data.aws_ssmincidents_response_plan.test"
diff --git a/internal/service/ssmincidents/response_plan_test.go b/internal/service/ssmincidents/response_plan_test.go
index 474ec38c5be9..1e53dc96004d 100644
--- a/internal/service/ssmincidents/response_plan_test.go
+++ b/internal/service/ssmincidents/response_plan_test.go
@@ -22,8 +22,7 @@ func testResponsePlan_basic(t *testing.T) {
 		t.Skip("skipping long-running test in short mode")
 	}
 
-	ctx := context.Background()
-
+	ctx := acctest.Context(t)
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	rTitle := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	rImpact := "3"
@@ -72,8 +71,7 @@ func testResponsePlan_updateRequiredFields(t *testing.T) {
 		t.Skip("skipping long-running test in short mode")
 	}
 
-	ctx := context.Background()
-
+	ctx := acctest.Context(t)
 	iniName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	updName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 
@@ -153,8 +151,7 @@ func testResponsePlan_updateTags(t *testing.T) {
 		t.Skip("skipping long-running test in short mode")
 	}
 
-	ctx := context.Background()
-
+	ctx := acctest.Context(t)
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	rTitle := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 
@@ -253,8 +250,7 @@ func testResponsePlan_updateEmptyTags(t *testing.T) {
 		t.Skip("skipping long-running test in short mode")
 	}
 
-	ctx := context.Background()
-
+	ctx := acctest.Context(t)
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	rTitle := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 
@@ -324,8 +320,7 @@ func testResponsePlan_disappears(t *testing.T) {
 		t.Skip("skipping long-running test in short mode")
 	}
 
-	ctx := context.Background()
-
+	ctx := acctest.Context(t)
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	rTitle := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	impact := "3"
@@ -357,8 +352,7 @@ func testResponsePlan_incidentTemplateOptionalFields(t *testing.T) {
 		t.Skip("skipping long-running test in short mode")
 	}
 
-	ctx := context.Background()
-
+	ctx := acctest.Context(t)
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	rTitle := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 
@@ -431,8 +425,7 @@ func testResponsePlan_displayName(t *testing.T) {
 		t.Skip("skipping long-running test in short mode")
 	}
 
-	ctx := context.Background()
-
+	ctx := acctest.Context(t)
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	oldDisplayName := rName + "-old-display-name"
 	newDisplayName := rName + "-new-display-name"
@@ -483,8 +476,7 @@ func testResponsePlan_chatChannel(t *testing.T) {
 		t.Skip("skipping long-running test in short mode")
 	}
 
-	ctx := context.Background()
-
+	ctx := acctest.Context(t)
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	chatChannelTopic1 := "aws_sns_topic.topic1"
 	chatChannelTopic2 := "aws_sns_topic.topic2"
@@ -565,8 +557,7 @@ func testResponsePlan_engagement(t *testing.T) {
 		t.Skip("skipping long-running test in short mode")
 	}
 
-	ctx := context.Background()
-
+	ctx := acctest.Context(t)
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	//lintignore:AWSAT003
 	//lintignore:AWSAT005
@@ -651,8 +642,7 @@ func testResponsePlan_action(t *testing.T) {
 		t.Skip("skipping long-running test in short mode")
 	}
 
-	ctx := context.Background()
-
+	ctx := acctest.Context(t)
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 
 	resourceName := "aws_ssmincidents_response_plan.test"
@@ -798,8 +788,7 @@ func testResponsePlan_action(t *testing.T) {
 //		t.Skip("skipping long-running test in short mode")
 //	}
 //
-//	ctx := context.Background()
-//
+//  ctx := acctest.Context(t)
 //	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 //
 //	resourceName := "aws_ssmincidents_response_plan.test"
diff --git a/internal/sweep/sweep_test.go b/internal/sweep/sweep_test.go
index 6d7396637bfe..fb7fac9b3fed 100644
--- a/internal/sweep/sweep_test.go
+++ b/internal/sweep/sweep_test.go
@@ -117,6 +117,7 @@ import (
 	_ "github.com/hashicorp/terraform-provider-aws/internal/service/redshift"
 	_ "github.com/hashicorp/terraform-provider-aws/internal/service/redshiftserverless"
 	_ "github.com/hashicorp/terraform-provider-aws/internal/service/resourceexplorer2"
+	_ "github.com/hashicorp/terraform-provider-aws/internal/service/resourcegroups"
 	_ "github.com/hashicorp/terraform-provider-aws/internal/service/route53"
 	_ "github.com/hashicorp/terraform-provider-aws/internal/service/route53recoverycontrolconfig"
 	_ "github.com/hashicorp/terraform-provider-aws/internal/service/route53resolver"