Repository: great-expectations/great_expectations
Pull request #11234 (2025-06-09 20:42:45)

[DOCS] Anomaly Detection: Expectation drawer and model
Resolves https://greatexpectations.atlassian.net/browse/DOC-1137 and https://greatexpectations.atlassian.net/browse/DOC-1138 according to the plans linked in those issues

- [X] Description of PR changes above includes a link to [an existing GitHub issue](https://github.com/great-expectations/great_expectations/issues)
- [X] PR title is prefixed with one of: [BUGFIX], [FEATURE], [DOCS], [MAINTENANCE], [CONTRIB], [MINORBUMP]
- [ ] Code is linted - run `invoke lint` (uses `ruff format` + `ruff check`)
- [X] Appropriate tests and docs have been updated

For more information about contributing, visit our [community resources](https://docs.greatexpectations.io/docs/core/introduction/community_resources#contribute-code-or-documentation).

After you submit your PR, keep the page open and **monitor the statuses of the various checks made by our continuous integration process at the bottom of the page. Please fix any issues that come up** and [reach out on Slack](https://greatexpectations.io/slack) if you need help. Thanks for contributing!


netlify[bot]: ### <span aria-hidden="true">👷</span> Deploy Preview for *niobium-lead-7998* processing.


|  Name | Link |
|:-:|------------------------|
|<span aria-hidden="true">🔨</span> Latest commit | 02a8a0612d24bf466f2bf556ec728c65fc68d00f |
|<span aria-hidden="true">🔍</span> Latest deploy log | https://app.netlify.com/projects/niobium-lead-7998/deploys/68474747d3eb5f00084c3706 |

Patch:
diff --git a/docs/docusaurus/docs/cloud/expectations/manage_expectations.md b/docs/docusaurus/docs/cloud/expectations/manage_expectations.md
index cfca46fc7..62be79dbb 100644
--- a/docs/docusaurus/docs/cloud/expectations/manage_expectations.md
+++ b/docs/docusaurus/docs/cloud/expectations/manage_expectations.md
@@ -16,55 +16,55 @@ An Expectation is a verifiable assertion about your data. They make implicit ass
 
 The following table lists the available GX Cloud Expectations.
 
-| Data quality issue | Expectation                                            | Description                                                                                                                            | Dynamic Parameters? |
-|--------------------|--------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------|---------------------|
-| Completeness       | **column proportion of non-null values to be between** | Expect the proportion of non-null values to be between a minimum value and a maximum value.                                            | Yes                 |
-| Completeness       | **column values to be null**                           | Expect the column values to be null.                                                                                                   | Yes                 |
-| Completeness       | **column values to not be null**                       | Expect the column values to not be null.                                                                                               | Yes                 |
-| Multi-source       | **query results to match comparison**                  | Query multiple Data Sources and compare the results for equality.                                                                      | No                  |
-| Numeric            | **column max to be between**                           | Expect the column maximum to be between a minimum and a maximum value.                                                                 | Yes                 |
-| Numeric            | **column mean to be between**                          | Expect the column mean to be between a minimum and a maximum value.                                                                    | Yes                 |
-| Numeric            | **column median to be between**                        | Expect the column median to be between a minimum and a maximum value.                                                                  | Yes                 |
-| Numeric            | **column min to be between**                           | Expect the column minimum to be between a minimum value and a maximum value.                                                           | Yes                 |
-| Numeric            | **column pair values A to be greater than B**          | Expect the values in column A to be greater than column B.                                                                             | No                  |
-| Numeric            | **column stdev to be between**                         | Expect the column standard deviation to be between a minimum value and a maximum value.                                                | Yes                 |
-| Numeric            | **column sum to be between**                           | Expect the column sum to be between a minimum value and a maximum value.                                                               | Yes                 |
-| Numeric            | **column values to be between**                        | Expect the column entries to be between a minimum value and a maximum value.                                                           | No                  |
-| Numeric            | **column z scores to be less than**                    | Expect the Z-scores of a column's values to be less than a given threshold.                                                            | No                  |
-| Numeric            | **multicolumn sum to equal**                           | Expect that the sum of row values in a specified column list is the same for each row, and equal to a specified sum total.             | No                  |
-| Schema             | **column to exist**                                    | Checks for the existence of a specified column within a table or view.                                                                 | No                  |
-| Schema             | **column values to be in type list**                   | Expect a column to contain values from a specified type list.                                                                          | No                  |
-| Schema             | **column values to be of type**                        | Expect a column to contain values of a specified data type.                                                                            | No                  |
-| Schema             | **table column count to be between**                   | Expect the number of columns in a table or view to be between two values.                                                              | Yes                 |
-| Schema             | **table column count to equal**                        | Expect the number of columns in a table or view to equal a value.                                                                      | No                  |
-| Schema             | **table columns to match ordered list**                | Expect the columns in a table or view to exactly match a specified list.                                                               | No                  |
-| Schema             | **table columns to match set**                         | Expect the columns in a table or view to match an unordered set.                                                                       | No                  |
-| SQL                | **custom Expectation with SQL**                        | Expect a SQL query to return no rows.                                                                                                  | No                  |
-| Uniqueness         | **column distinct values to be in set**                | Expect the set of distinct column values to be contained by a given set.                                                               | No                  |
-| Uniqueness         | **column distinct values to contain set**              | Expect the set of distinct column values to contain a given set.                                                                       | No                  |
-| Uniqueness         | **column distinct values to equal set**                | Expect the set of distinct column values to equal a given set.                                                                         | No                  |
-| Uniqueness         | **column proportion of unique values to be between**   | Expect the proportion of unique values to be between a minimum value and a maximum value.                                              | Yes                 |
-| Uniqueness         | **column unique value count to be between**            | Expect the number of unique values to be between a minimum value and a maximum value.                                                  | Yes                 |
-| Uniqueness         | **column values to be unique**                         | Expect each column value to be unique.                                                                                                 | No                  |
-| Uniqueness         | **compound columns to be unique**                      | Expect the compound columns to be unique.                                                                                              | No                  |
-| Uniqueness         | **select column values to be unique within record**    | Expect the values for each record to be unique across the columns listed. Note that records can be duplicated.                         | No                  |
-| Validity           | **column most common value to be in set**              | Expect the most common value to be within the designated value set.                                                                    | No                  |
-| Validity           | **column pair values to be equal**                     | Expect the values in column A to be the same as column B.                                                                              | No                  |
-| Validity           | **column value lengths to be between**                 | Expect the column entries to be strings with length between a minimum value and a maximum value.                                       | No                  |
-| Validity           | **column value lengths to equal**                      | Expect the column entries to be strings with length equal to the provided value.                                                       | No                  |
-| Validity           | **column values to be in set**                         | Expect each column value to be in a given set.                                                                                         | No                  |
-| Validity           | **column values to not be in set**                     | Expect column entries to not be in the set.                                                                                            | No                  |
-| Validity           | **column values to match like pattern**                | Expect the column entries to be strings that match a given like pattern expression.                                                    | No                  |
-| Validity           | **column values to match like pattern list**           | Expect the column entries to be strings that match any of a provided list of like pattern expressions.                                 | No                  |
-| Validity           | **column values to match regex**                       | Expect the column entries to be strings that match a given regular expression.                                                         | No                  |
-| Validity           | **column values to match regex list**                  | Expect the column entries to be strings that can be matched to either any of or all of a list of regular expressions.                  | No                  |
-| Validity           | **column values to not match like pattern**            | Expect the column entries to be strings that do NOT match a given like pattern expression.                                             | No                  |
-| Validity           | **column values to not match like pattern list**       | Expect the column entries to be strings that do NOT match any of a provided list of like pattern expressions.                          | No                  |
-| Validity           | **column values to not match regex**                   | Expect the column entries to be strings that do NOT match a given regular expression.                                                  | No                  |
-| Validity           | **column values to not match regex list**              | Expect the column entries to be strings that do not match any of a list of regular expressions. Matches can be anywhere in the string. | No                  |
-| Volume             | **table row count to be between**                      | Expect the number of rows to be between two values.                                                                                    | Yes                 |
-| Volume             | **table row count to equal**                           | Expect the number of rows to equal a value.                                                                                            | No                  |
-| Volume             | **table row count to equal other table**               | Expect the number of rows to equal the number in another table or view within the same database.                                       | No                  |
+| Data quality issue | Expectation                                            | Description                                                                                                                            | Dynamic Parameters? | Forecasted range? |
+|--------------------|--------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------|---------------------|-------------------|
+| Completeness       | **column proportion of non-null values to be between** | Expect the proportion of non-null values to be between a minimum value and a maximum value.                                            | Yes                 | No                |
+| Completeness       | **column values to be null**                           | Expect the column values to be null.                                                                                                   | Yes                 | No                |
+| Completeness       | **column values to not be null**                       | Expect the column values to not be null.                                                                                               | Yes                 | No                |
+| Multi-source       | **query results to match comparison**                  | Query multiple Data Sources and compare the results for equality.                                                                      | No                  | No                |
+| Numeric            | **column max to be between**                           | Expect the column maximum to be between a minimum and a maximum value.                                                                 | Yes                 | No                |
+| Numeric            | **column mean to be between**                          | Expect the column mean to be between a minimum and a maximum value.                                                                    | Yes                 | No                |
+| Numeric            | **column median to be between**                        | Expect the column median to be between a minimum and a maximum value.                                                                  | Yes                 | No                |
+| Numeric            | **column min to be between**                           | Expect the column minimum to be between a minimum value and a maximum value.                                                           | Yes                 | No                |
+| Numeric            | **column pair values A to be greater than B**          | Expect the values in column A to be greater than column B.                                                                             | No                  | No                |
+| Numeric            | **column stdev to be between**                         | Expect the column standard deviation to be between a minimum value and a maximum value.                                                | Yes                 | No                |
+| Numeric            | **column sum to be between**                           | Expect the column sum to be between a minimum value and a maximum value.                                                               | Yes                 | No                |
+| Numeric            | **column values to be between**                        | Expect the column entries to be between a minimum value and a maximum value.                                                           | No                  | No                |
+| Numeric            | **column z scores to be less than**                    | Expect the Z-scores of a column's values to be less than a given threshold.                                                            | No                  | No                |
+| Numeric            | **multicolumn sum to equal**                           | Expect that the sum of row values in a specified column list is the same for each row, and equal to a specified sum total.             | No                  | No                |
+| Schema             | **column to exist**                                    | Checks for the existence of a specified column within a table or view.                                                                 | No                  | No                |
+| Schema             | **column values to be in type list**                   | Expect a column to contain values from a specified type list.                                                                          | No                  | No                |
+| Schema             | **column values to be of type**                        | Expect a column to contain values of a specified data type.                                                                            | No                  | No                |
+| Schema             | **table column count to be between**                   | Expect the number of columns in a table or view to be between two values.                                                              | Yes                 | No                |
+| Schema             | **table column count to equal**                        | Expect the number of columns in a table or view to equal a value.                                                                      | No                  | No                |
+| Schema             | **table columns to match ordered list**                | Expect the columns in a table or view to exactly match a specified list.                                                               | No                  | No                |
+| Schema             | **table columns to match set**                         | Expect the columns in a table or view to match an unordered set.                                                                       | No                  | No                |
+| SQL                | **custom Expectation with SQL**                        | Expect a SQL query to return no rows.                                                                                                  | No                  | No                |
+| Uniqueness         | **column distinct values to be in set**                | Expect the set of distinct column values to be contained by a given set.                                                               | No                  | No                |
+| Uniqueness         | **column distinct values to contain set**              | Expect the set of distinct column values to contain a given set.                                                                       | No                  | No                |
+| Uniqueness         | **column distinct values to equal set**                | Expect the set of distinct column values to equal a given set.                                                                         | No                  | No                |
+| Uniqueness         | **column proportion of unique values to be between**   | Expect the proportion of unique values to be between a minimum value and a maximum value.                                              | Yes                 | No                |
+| Uniqueness         | **column unique value count to be between**            | Expect the number of unique values to be between a minimum value and a maximum value.                                                  | Yes                 | No                |
+| Uniqueness         | **column values to be unique**                         | Expect each column value to be unique.                                                                                                 | No                  | No                |
+| Uniqueness         | **compound columns to be unique**                      | Expect the compound columns to be unique.                                                                                              | No                  | No                |
+| Uniqueness         | **select column values to be unique within record**    | Expect the values for each record to be unique across the columns listed. Note that records can be duplicated.                         | No                  | No                |
+| Validity           | **column most common value to be in set**              | Expect the most common value to be within the designated value set.                                                                    | No                  | No                |
+| Validity           | **column pair values to be equal**                     | Expect the values in column A to be the same as column B.                                                                              | No                  | No                |
+| Validity           | **column value lengths to be between**                 | Expect the column entries to be strings with length between a minimum value and a maximum value.                                       | No                  | No                |
+| Validity           | **column value lengths to equal**                      | Expect the column entries to be strings with length equal to the provided value.                                                       | No                  | No                |
+| Validity           | **column values to be in set**                         | Expect each column value to be in a given set.                                                                                         | No                  | No                |
+| Validity           | **column values to not be in set**                     | Expect column entries to not be in the set.                                                                                            | No                  | No                |
+| Validity           | **column values to match like pattern**                | Expect the column entries to be strings that match a given like pattern expression.                                                    | No                  | No                |
+| Validity           | **column values to match like pattern list**           | Expect the column entries to be strings that match any of a provided list of like pattern expressions.                                 | No                  | No                |
+| Validity           | **column values to match regex**                       | Expect the column entries to be strings that match a given regular expression.                                                         | No                  | No                |
+| Validity           | **column values to match regex list**                  | Expect the column entries to be strings that can be matched to either any of or all of a list of regular expressions.                  | No                  | No                |
+| Validity           | **column values to not match like pattern**            | Expect the column entries to be strings that do NOT match a given like pattern expression.                                             | No                  | No                |
+| Validity           | **column values to not match like pattern list**       | Expect the column entries to be strings that do NOT match any of a provided list of like pattern expressions.                          | No                  | No                |
+| Validity           | **column values to not match regex**                   | Expect the column entries to be strings that do NOT match a given regular expression.                                                  | No                  | No                |
+| Validity           | **column values to not match regex list**              | Expect the column entries to be strings that do not match any of a list of regular expressions. Matches can be anywhere in the string. | No                  | No                |
+| Volume             | **table row count to be between**                      | Expect the number of rows to be between two values.                                                                                    | Yes                 | Yes               |
+| Volume             | **table row count to equal**                           | Expect the number of rows to equal a value.                                                                                            | No                  | No                |
+| Volume             | **table row count to equal other table**               | Expect the number of rows to equal the number in another table or view within the same database.                                       | No                  | No                |
 
 
 ## Custom SQL Expectations
@@ -104,8 +104,11 @@ Keep the following limitations in mind when working with Multi-source Expectatio
 - Batches are not supported. To test a time-based interval of data, use timestamp windows in your base and comparison SQL queries.
 - The Expectation configuration and validation results are not reflected on the comparison Data Source. The Expectation is always managed on the Data Asset where you initially configure it.
 
+## Anomaly Detection
 
-## Dynamic Parameters
+Anomaly Detection Expectations evolve with your data to detect deviations from historical patterns. To speed up their creation, you can automate Anomaly Detection Expectations when you [create new Data Assets](/cloud/data_assets/manage_data_assets.md#add-a-data-asset-from-an-existing-data-source) or [add Expectations](/cloud/expectations/manage_expectations.md#add-an-expectation) for an existing Data Asset. You can also manually configure Anomaly Detection by adding Expectations with Dynamic Parameters or forecasted ranges.
+
+### Dynamic Parameters
 
 Dynamic Parameters allow you to create Expectations whose parameters update based on new data. GX Cloud can populate new Expectation parameters at runtime using the last `n` validation results. For example, you can define an Expectation to validate that the maximum value within a column does not exceed 20% above a previously recorded value.
 
@@ -127,6 +130,12 @@ When you select your `n` run count, and:
 
 - There are `>n` runs, the Expectation will take the last `n` runs into account.
 
+### Forecasted ranges
+
+Forecasted ranges are determined by GX Cloud through a continuous learning algorithm that analyzes historical patterns in your data. For example, a forecasted range for volume Anomaly Detection could detect a sudden increase when volume has been stable or stagnation in a season when volume typically grows. GX Cloud sets and updates forecasted range parameters on your behalf. 
+
+Expectations with forecasted ranges will neither pass nor fail until there have been at least 2 validation runs. This is because GX Cloud needs at least 2 data points to produce a forecast.
+
 ## Expectation condition
 
 The Expectation condition is an optional field that applies to any Expectation validating row-level data. This condition allows you to filter your data so that only a specific subset of your Batch is validated. Rows will be validated only when the condition is true.
@@ -157,15 +166,16 @@ To clear the Expectation condition, click the clear button located on the right-
 
 5. Select an Expectation type.
 
+   :::tip Automatic rules for Anomaly Detection
+   If you selected the schema, volume, or completeness data quality issue, you will have the **Automatic** option to generate Expectations for [Anomaly Detection](/cloud/overview/automating_rules.md#anomaly-detection). If you instead want to create your own rules, click **Manual** and then select an Expectation type.
+   :::
+
 6. Complete the mandatory and optional fields for the Expectation. A recurring [validation schedule](/cloud/schedules/manage_schedules.md) will be applied automatically to your Expectation. 
 
 7. Click **Save** or click **Save & Add More** and then repeat steps 4 through 7 to add additional Expectations.
 
 8. Optional. Run a Validation. See [Run a Validation](/cloud/validations/manage_validations.md#run-a-validation).
 
-:::tip Automate rules for Anomaly Detection
-When you [create a new Data Asset](/cloud/data_assets/manage_data_assets.md#add-a-data-asset-from-an-existing-data-source), you can choose to automatically generate Anomaly Detection Expectations for that Data Asset that detect column changes, non-increasing volume, and changes to the percentage of null values in each column.
-:::
 
 ## Generate Expectations with ExpectAI <span class="beta">Beta</span>
 
diff --git a/docs/docusaurus/docs/cloud/overview/automating_rules.md b/docs/docusaurus/docs/cloud/overview/automating_rules.md
index 374fdde7c..50e1ce132 100644
--- a/docs/docusaurus/docs/cloud/overview/automating_rules.md
+++ b/docs/docusaurus/docs/cloud/overview/automating_rules.md
@@ -5,25 +5,28 @@ description: Generate AI-recommended data quality rules and use Anomaly Detectio
 
 With GX Cloud, you can automatically generate data quality rules to more quickly achieve test coverage for your data. This page provides an overview of the following options:
 
-- Automating [Anomaly Detection](#anomaly-detection) rules as part of adding a new Data Asset.
-- Generating [personalized AI-recommended rules](#personalized-recommendations-with-expectai-beta) for an existing Data Asset.
+- Automating [Anomaly Detection](#anomaly-detection) rules.
+- Generating [personalized AI-recommended rules](#personalized-recommendations-with-expectai-beta).
 
 ## Anomaly Detection
 
-When you [add a new Data Asset](/cloud/data_assets/manage_data_assets.md), GX Cloud by default generates Expectations to detect anomalies in the following:
+When you [add a new Data Asset](/cloud/data_assets/manage_data_assets.md), GX Cloud by default generates Expectations to detect anomalies in the following data quality issues. You can also automate Anomaly Detection for these when you [add Expectations](/cloud/expectations/manage_expectations.md#add-an-expectation) for an existing Data Asset.
+
 - [Schema](#schema)
 - [Volume](#volume)
 - [Completeness](#completeness)
 - Uniqueness (coming soon)
 
 
+
 ### Schema
 
 To detect schema anomalies, we automatically generate a rule to [**expect table columns to match set**](/reference/learn/data_quality_use_cases/schema.md#expect-table-columns-to-match-set) using the Data Asset’s initial columns as the set to match. If the number or names of columns in the Data Asset change, this Expectation will fail.
 
 ### Volume
 
-To detect non-increasing volume, we automatically generate a rule to [**expect table row count to be between**](/reference/learn/data_quality_use_cases/volume.md#expect-table-row-count-to-be-between) with dynamic parameters that test that the current validation run has more rows than the previous run. If the row count shrinks or stays the same between runs, this Expectation will fail.
+To detect anomalies in row count, we automatically generate a rule to [**expect table row count to be between**](/reference/learn/data_quality_use_cases/volume.md#expect-table-row-count-to-be-between) a forecasted range that tests that the current validation run doesn’t deviate significantly from historical patterns. For example, if there is a sudden increase when volume has been stable or stagnation in a season when volume typically grows, then this Expectation will fail.
+
 
 ### Completeness
 
diff --git a/docs/docusaurus/docs/cloud/overview/gx_cloud_overview.md b/docs/docusaurus/docs/cloud/overview/gx_cloud_overview.md
index 38f6f75ee..4afe1fbbd 100644
--- a/docs/docusaurus/docs/cloud/overview/gx_cloud_overview.md
+++ b/docs/docusaurus/docs/cloud/overview/gx_cloud_overview.md
@@ -46,7 +46,7 @@ There are a variety of GX Cloud features that support additional enhancements to
 
 * **Data Asset profiling.** GX Cloud introspects your data schema by default on Data Asset creation, and also offers one-click fetching of additional descriptive metrics including column type and statistical summaries. Data profiling results are used to suggest parameters for Expectations that you create.
 
-* **Automate rules for Anomaly Detection.** GX Cloud can automatically generate Expectations that detect column changes, non-increasing data volume, and changes to the proportion of null values in each column. This option is available when [you create new Data Assets](/cloud/data_assets/manage_data_assets.md#add-a-data-asset-from-an-existing-data-source).
+* **Automate rules for Anomaly Detection.** GX Cloud can automatically generate Expectations that detect column changes, volume changes that deviate from historical patterns, and changes to the proportion of null values in each column. This option is available when you [create new Data Assets](/cloud/data_assets/manage_data_assets.md#add-a-data-asset-from-an-existing-data-source) or [add Expectations](/cloud/expectations/manage_expectations.md#add-an-expectation) for an existing Data Asset.
 
 * **Personalize rules with ExpectAI (BETA).** GX Cloud can generate [AI-recommended Expectations](/cloud/expectations/manage_expectations.md#generate-expectations-with-expectai-beta) for a Data Asset. These will be personalized based on an analysis of a sample of your data.
 
diff --git a/docs/docusaurus/docs/reference/learn/data_quality_use_cases/missingness.md b/docs/docusaurus/docs/reference/learn/data_quality_use_cases/missingness.md
index 9c87bb044..a7c13c199 100644
--- a/docs/docusaurus/docs/reference/learn/data_quality_use_cases/missingness.md
+++ b/docs/docusaurus/docs/reference/learn/data_quality_use_cases/missingness.md
@@ -5,7 +5,7 @@ title: 'Manage missing data with GX'
 
 Missing data, also known as missingness, poses a significant challenge in data quality management. Missing data occurs when expected information is absent from a dataset, often appearing as `NULL` values in databases or manifesting differently across various systems. Effectively managing this issue is crucial for maintaining data integrity and reliability since unaddressed missing data can lead to disrupted calculations, skewed analyses, and compromised data analytics tasks.
 
-Great Expectations (GX) offers a robust solution for addressing missing data through a comprehensive collection of Expectations that allow users to define and enforce data quality rules. You can enable Anomaly Detection to automatically generate these Expectations when you add a new Data Asset in GX Cloud. By integrating GX into your data pipelines, you can establish robust validation processes that catch issues early, ensuring your dataset remains clean, consistent, and ready for accurate reporting, predictive modeling, and other advanced analytics applications.
+Great Expectations (GX) offers a robust solution for addressing missing data through a comprehensive collection of Expectations that allow users to define and enforce data quality rules. By integrating GX into your data pipelines, you can establish robust validation processes that catch issues early, ensuring your dataset remains clean, consistent, and ready for accurate reporting, predictive modeling, and other advanced analytics applications.
 
 In this guide, you will learn how to leverage GX to effectively handle missing data. This includes applying Expectations and making informed decisions about managing various types of missingness. By following these steps, you can ensure your datasets maintain high quality, thus enabling more accurate and reliable data-driven insights.
 
@@ -43,7 +43,7 @@ This Expectation validates that the proportion of non-null values in a column is
 <br/>
 
 :::tip Automate this rule with GX Cloud
-When you [create a new Data Asset](/cloud/data_assets/manage_data_assets.md#add-a-data-asset-from-an-existing-data-source), you can enable Anomaly Detection on each column to test that column completeness doesn't change drastically between Validation runs.
+When you [create a new Data Asset](/cloud/data_assets/manage_data_assets.md#add-a-data-asset-from-an-existing-data-source) or [add an Expectation](/cloud/expectations/manage_expectations.md#add-an-expectation), you can enable Anomaly Detection on each column to test that column completeness doesn't change drastically between Validation runs.
 :::
 
 
diff --git a/docs/docusaurus/docs/reference/learn/data_quality_use_cases/schema.md b/docs/docusaurus/docs/reference/learn/data_quality_use_cases/schema.md
index 1130c0b06..5ccced790 100644
--- a/docs/docusaurus/docs/reference/learn/data_quality_use_cases/schema.md
+++ b/docs/docusaurus/docs/reference/learn/data_quality_use_cases/schema.md
@@ -17,7 +17,7 @@ established rules, such as verifying column names, data types, and the presence
 Schema changes, whether planned or unexpected, can significantly impact data integrity and the
 performance of data-dependent systems.
 
-Great Expectations (GX) provides schema-focused Expectations that allow you to define and enforce the structural integrity of your datasets. You can enable Anomaly Detection to automatically generate some of these Expectations when you add a new Data Asset in GX Cloud. These tools enable you to establish robust schema validation within your data pipelines, helping to catch and address schema-related issues before they propagate through your data ecosystem. This guide will walk you through leveraging these Expectations to implement effective schema validation in your data workflows.
+Great Expectations (GX) provides schema-focused Expectations that allow you to define and enforce the structural integrity of your datasets. These tools enable you to establish robust schema validation within your data pipelines, helping to catch and address schema-related issues before they propagate through your data ecosystem. This guide will walk you through leveraging these Expectations to implement effective schema validation in your data workflows.
 
 ## Prerequisite knowledge
 This article assumes basic familiarity with GX components and workflows. See the [GX Overview](/core/introduction/gx_overview.md) for additional content on GX fundamentals.
@@ -37,7 +37,7 @@ You can [access this dataset](https://raw.githubusercontent.com/great-expectatio
 
 ## Key schema Expectations
 
-GX offers a collection of Expectations for schema validation, all of which can be added directly in GX Cloud or GX Core. Some of them can be automatically generated by enabling Anomaly Detection when you add a new Data Asset using GX Cloud. 
+GX offers a collection of Expectations for schema validation, all of which can be added directly in GX Cloud or GX Core. 
 
 The schema Expectations provide basic practical solutions for common validation scenarios and can also be used to satisfy more nuanced validation needs.
 
@@ -138,8 +138,8 @@ flexibility where column presence is more critical than their sequence.
 ```python title="Python" name="docs/docusaurus/docs/reference/learn/data_quality_use_cases/schema_resources/schema_expectations.py ExpectTableColumnsToMatchSet"
 ```
 
-:::tip Automate this rule
-When you [create a new Data Asset with GX Cloud](/cloud/data_assets/manage_data_assets.md#add-a-data-asset-from-an-existing-data-source), you can enable Anomaly Detection to automatically generate this Expectation to test that columns don't diverge from the initial set over time.
+:::tip Automate this rule with GX Cloud
+When you [create a new Data Asset](/cloud/data_assets/manage_data_assets.md#add-a-data-asset-from-an-existing-data-source) or [add an Expectation](/cloud/expectations/manage_expectations.md#add-an-expectation), you can enable Anomaly Detection to test that columns don't diverge from the initial set over time.
 :::
 
 <small>View `ExpectTableColumnsToMatchSet` in the [Expectation
diff --git a/docs/docusaurus/docs/reference/learn/data_quality_use_cases/volume.md b/docs/docusaurus/docs/reference/learn/data_quality_use_cases/volume.md
index 3cc30c839..017c5bf8d 100644
--- a/docs/docusaurus/docs/reference/learn/data_quality_use_cases/volume.md
+++ b/docs/docusaurus/docs/reference/learn/data_quality_use_cases/volume.md
@@ -7,7 +7,7 @@ import TabItem from '@theme/TabItem';
 
 Data volume, a critical aspect of data quality, refers to the quantity of records or data points within a dataset. Managing data volume effectively is crucial for maintaining data integrity, ensuring system performance, and deriving accurate insights. Unexpected changes in data volume can signal issues in data collection, processing, or storage, potentially leading to skewed analyses or system failures. Volume management is intrinsically linked to other aspects of data quality, such as data completeness and consistency, forming a crucial part of a comprehensive data quality strategy.
 
-Great Expectations (GX) offers a powerful set of tools for monitoring and validating data volume through its volume-focused Expectations. You can enable Anomaly Detection to automatically generate some of these Expectations when you add a new Data Asset in GX Cloud. By integrating these Expectations into your data pipelines, you can establish robust checks that ensure your datasets maintain the expected volume, catch anomalies early, and prevent downstream issues in your data workflows.
+Great Expectations (GX) offers a powerful set of tools for monitoring and validating data volume through its volume-focused Expectations. By integrating these Expectations into your data pipelines, you can establish robust checks that ensure your datasets maintain the expected volume, catch anomalies early, and prevent downstream issues in your data workflows.
 
 This guide will walk you through leveraging GX to effectively manage and validate data volume, helping you maintain high-quality, reliable datasets.
 
@@ -28,7 +28,7 @@ This dataset represents daily financial transactions. In a real-world scenario,
 
 ## Key volume Expectations
 
-GX provides several Expectations specifically designed for managing data volume, all of which can be added directly in GX Cloud or GX Core. Some of them can be automatically generated by enabling Anomaly Detection when you add a new Data Asset using GX Cloud.
+GX provides several Expectations specifically designed for managing data volume, all of which can be added directly in GX Cloud or GX Core. 
 
 ### Expect Table Row Count To Be Between
 
@@ -39,8 +39,8 @@ Ensures that the number of rows in a dataset falls within a specified range.
 ```python title="Python" name="docs/docusaurus/docs/reference/learn/data_quality_use_cases/volume_resources/volume_expectations.py ExpectTableRowCountToBeBetween"
 ```
 
-:::tip Automate this rule
-When you [create a new Data Asset with GX Cloud](/cloud/data_assets/manage_data_assets.md#add-a-data-asset-from-an-existing-data-source), you can enable Anomaly Detection to automatically generate an instance of this Expectation that detects non-increasing volume over time.
+:::tip Automate this rule with GX Cloud
+When you [create a new Data Asset](/cloud/data_assets/manage_data_assets.md#add-a-data-asset-from-an-existing-data-source) or [add an Expectation](/cloud/expectations/manage_expectations.md#add-an-expectation), you can enable Anomaly Detection to catch volume changes that deviate from historical patterns.
 :::
 
 <small>View `ExpectTableRowCountToBeBetween` in the [Expectation Gallery](https://greatexpectations.io/expectations/expect_table_row_count_to_be_between).</small>
@@ -73,7 +73,7 @@ Compares the row count of the current table to another table within the same dat
 <br/>
 
 :::tip[GX tips for volume Expectations]
-- Regularly adjust your `ExpectTableRowCountToBeBetween` thresholds based on historical data and growth patterns to maintain relevance.
+- Regularly adjust your `ExpectTableRowCountToBeBetween` thresholds based on historical data and growth patterns to maintain relevance. Or to save time, automate a forecasted range with GX Cloud.
 - Use `ExpectTableRowCountToEqual` in conjunction with time-based partitioning for precise daily volume checks.
 - Implement `ExpectTableRowCountToEqualOtherTable` to ensure data integrity across your data pipeline stages.
 :::
@@ -164,7 +164,7 @@ The scenarios in this section outline common real-world use cases for data volum
 
 ## Avoid common volume validation pitfalls
 
-- **Static Thresholds**: Avoid using fixed thresholds that don't account for natural growth or seasonality. Regularly review and adjust your `ExpectTableRowCountToBeBetween` parameters. For example, an e-commerce platform might need different volume thresholds for regular days versus holiday seasons.
+- **Static Thresholds**: Avoid using fixed thresholds for `ExpectTableRowCountToBeBetween` that don't account for natural growth or seasonality. Regularly review and adjust your parameters. Or to save time, automate [Anomaly Detection](/cloud/overview/automating_rules.md#anomaly-detection) with GX Cloud. For example, an e-commerce platform might need different volume thresholds for regular days versus holiday seasons.
 
 - **Ignoring Data Skew**: Data skew refers to the uneven distribution of data across partitions or nodes in a distributed system. Failing to account for data skew when validating volume can lead to misleading results. Monitor volume at the partition level and implement checks to detect and handle data skew.
 
diff --git a/great_expectations/expectations/core/expect_table_columns_to_match_set.py b/great_expectations/expectations/core/expect_table_columns_to_match_set.py
index e90311c9c..34101ca93 100644
--- a/great_expectations/expectations/core/expect_table_columns_to_match_set.py
+++ b/great_expectations/expectations/core/expect_table_columns_to_match_set.py
@@ -371,11 +371,6 @@ class ExpectTableColumnsToMatchSet(BatchExpectation):
             renderer_configuration=renderer_configuration,
         )
 
-        expected_column_set = set(renderer_configuration.kwargs.get("column_set", []))
-        observed_column_set = set(
-            result.get("result", {}).get("observed_value", []) if result else []
-        )
-
         observed_columns = (
             (name, sch)
             for name, sch in renderer_configuration.params
@@ -386,19 +381,26 @@ class ExpectTableColumnsToMatchSet(BatchExpectation):
             for name, sch in renderer_configuration.params
             if name.startswith(expected_param_prefix)
         )
+        mismatched_columns = {"unexpected": [], "missing": []}
+        if (
+            "details" in result["result"]
+            and "mismatched" in result["result"]["details"]
+            and result["result"]["details"]["mismatched"]
+        ):
+            mismatched_columns.update(result["result"]["details"]["mismatched"])
 
         template_str_list = []
         for name, schema in observed_columns:
             render_state = (
-                ObservedValueRenderState.EXPECTED.value
-                if schema.value in expected_column_set
-                else ObservedValueRenderState.UNEXPECTED.value
+                ObservedValueRenderState.UNEXPECTED.value
+                if schema.value in mismatched_columns["unexpected"]
+                else ObservedValueRenderState.EXPECTED.value
             )
             renderer_configuration.params.__dict__[name].render_state = render_state
             template_str_list.append(f"${name}")
 
         for name, schema in expected_columns:
-            if schema.value not in observed_column_set:
+            if schema.value in mismatched_columns["missing"]:
                 renderer_configuration.params.__dict__[
                     name
                 ].render_state = ObservedValueRenderState.MISSING.value
@@ -540,15 +542,15 @@ def _validate_result(
     exact_match: bool,
 ) -> Dict[str, Any]:
     empty_set = set()
-    observed_value = sorted(list(actual_column_set))
+    observed_value = sorted([str(col) for col in actual_column_set])
 
     if ((expected_column_set is None) and (exact_match is not True)) or (
         unmatched_expected_column_set == empty_set and unmatched_actual_column_set == empty_set
     ):
         return {"success": True, "result": {"observed_value": observed_value}}
     else:
-        unexpected_list = sorted(list(unmatched_actual_column_set))
-        missing_list = sorted(list(unmatched_expected_column_set))
+        unexpected_list = sorted([str(col) for col in unmatched_actual_column_set])
+        missing_list = sorted([str(col) for col in unmatched_expected_column_set])
 
         mismatched = {}
         if len(unexpected_list) > 0:


Test patch:
diff --git a/tests/expectations/test_expectation_atomic_renderers.py b/tests/expectations/test_expectation_atomic_renderers.py
index 6744bf462..03177dcf4 100644
--- a/tests/expectations/test_expectation_atomic_renderers.py
+++ b/tests/expectations/test_expectation_atomic_renderers.py
@@ -1,7 +1,7 @@
 import re
 from datetime import datetime
 from pprint import pprint
-from typing import Callable, Dict, Union
+from typing import Any, Callable, Dict, Optional, Tuple, Union
 
 import pytest
 
@@ -2750,6 +2750,26 @@ def test_expect_column_distinct_values_to_contain_set_atomic_diagnostic_observed
         assert res["value"]["params"][name]["render_state"] == status
 
 
+def _create_result_details_from_expected_result(
+    expected_result: Tuple[str, str, str],
+) -> Optional[Dict[str, Any]]:
+    unexpected = []
+    missing = []
+    for _, col, state in expected_result:
+        if state == "unexpected":
+            unexpected.append(col)
+        elif state == "missing":
+            missing.append(col)
+    if not unexpected and not missing:
+        return None
+    details = {"mismatched": {}}
+    if unexpected:
+        details["mismatched"]["unexpected"] = unexpected
+    if missing:
+        details["mismatched"]["missing"] = missing
+    return details
+
+
 @pytest.mark.unit
 @pytest.mark.parametrize(
     "description, value_set, observed_value, expected_result",
@@ -2943,6 +2963,9 @@ def test_expect_table_columns_to_match_set_atomic_diagnostic_observed_value(
         ),
         "result": {"observed_value": observed_value},
     }
+    details = _create_result_details_from_expected_result(expected_result)
+    if details:
+        x["result"]["details"] = details
 
     expected_template_string = " ".join([f"${name}" for name, _, _ in expected_result])
 
diff --git a/tests/integration/data_sources_and_expectations/expectations/test_expect_table_columns_to_match_set.py b/tests/integration/data_sources_and_expectations/expectations/test_expect_table_columns_to_match_set.py
index cadcc365d..a114d3416 100644
--- a/tests/integration/data_sources_and_expectations/expectations/test_expect_table_columns_to_match_set.py
+++ b/tests/integration/data_sources_and_expectations/expectations/test_expect_table_columns_to_match_set.py
@@ -1,9 +1,11 @@
-from typing import Sequence
+from enum import Enum
+from typing import Dict, List, Optional, Sequence
 
 import pandas as pd
 import pytest
 
 import great_expectations.expectations as gxe
+from great_expectations.core.expectation_validation_result import ExpectationValidationResult
 from great_expectations.core.result_format import ResultFormat
 from great_expectations.datasource.fluent.interfaces import Batch
 from tests.integration.conftest import parameterize_batch_for_data_sources
@@ -124,37 +126,8 @@ def test_success_with_suite_param_exact_match_(
 
 
 # Case insenstivity tests
-CASE_INSENSITIVE_DATA = pd.DataFrame(
-    {
-        "column_a": [1],
-        "COLUMN_B": [2],
-        "CoLuMn_C": [3],
-    }
-)
-
-
-@parameterize_batch_for_data_sources(
-    data_source_configs=SQL_DATA_SOURCES,
-    data=CASE_INSENSITIVE_DATA,
-)
-def test_case_insensitive_success(batch_for_datasource: Batch) -> None:
-    expectation = gxe.ExpectTableColumnsToMatchSet(column_set=["COLUMN_A", "column_b", "COLumN_c"])
-    result = batch_for_datasource.validate(expectation)
-    assert result.success
-
-
-@parameterize_batch_for_data_sources(
-    data_source_configs=SQL_DATA_SOURCES,
-    data=CASE_INSENSITIVE_DATA,
-)
-def test_case_insensitive_failure(batch_for_datasource: Batch) -> None:
-    expectation = gxe.ExpectTableColumnsToMatchSet(column_set=["COLUMN_Az", "column_b", "COLumN_c"])
-    result = batch_for_datasource.validate(expectation)
-    assert not result.success
-
-
-# For most of our tests we use all sql datasources. However, for some of them we exclude
-# snowflake and redshift for the following reasons:
+# For some of our case insensitive tests we break out Snowflake and Redshift into separate
+# tests for the following reasons:
 ##### Snowflake #####
 # In test setup, sqlalchemy's CREATE TABLE will not quote lowercase column names
 # but will quote uppercase. Since snowflake stores case insensitive strings
@@ -169,6 +142,43 @@ def test_case_insensitive_failure(batch_for_datasource: Batch) -> None:
 # looks like it would handle this successfully but I haven't verified since I need to
 # change our redshift CI cluster. There is tracked in GX-1197.
 
+CASE_INSENSITIVE_DATA = pd.DataFrame(
+    {
+        "column_a": [1],
+        "COLUMN_B": [2],
+        "CoLuMn_C": [3],
+    }
+)
+
+
+def observed_column_names(datasource_type: str) -> List[str]:
+    """Returns observed column name base on type in A, B, C order."""
+    if datasource_type == "snowflake":
+        # Since SQLAlchemy doesn't quote lowercase names in CREATE TABLE and since uppercase is
+        # case insenstive in Snowflake, both column_a and column_b will be case insensitive.
+        # SQLAlchemy will return case insensitive names in lowercase when inspecting the table.
+        return [
+            "column_a",
+            "column_b",
+            "CoLuMn_C",
+        ]
+    elif datasource_type == "redshift":
+        # Redshift is case insensitive by default
+        # SQLAlchemy will return case insensitive names in lowercase when inspecting the table.
+        return [
+            "column_a",
+            "column_b",
+            "column_c",
+        ]
+    else:
+        # For most datasources we expected the observed column names to match CASE_INSENSITIVE_DATA.
+        return [
+            "column_a",
+            "COLUMN_B",
+            "CoLuMn_C",
+        ]
+
+
 SQL_DATA_SOURCES_WITHOUT_SNOWFLAKE_REDSHIFT: Sequence[DataSourceTestConfig] = [
     BigQueryDatasourceTestConfig(),
     DatabricksDatasourceTestConfig(),
@@ -189,6 +199,106 @@ def test_sql_data_sources_without_snowflake_redshift() -> None:
         assert datasource in SQL_DATA_SOURCES
 
 
+@parameterize_batch_for_data_sources(
+    data_source_configs=SQL_DATA_SOURCES,
+    data=CASE_INSENSITIVE_DATA,
+)
+def test_case_insensitive_success(batch_for_datasource: Batch) -> None:
+    # Arrange
+    expectation = gxe.ExpectTableColumnsToMatchSet(column_set=["COLUMN_A", "column_b", "COLumN_c"])
+
+    # Act
+    result = batch_for_datasource.validate(expectation)
+    result.render()  # creates rendered content
+
+    # Assert
+    assert result.success
+
+    # Assert rendered content is as expected
+    observed_values = _extract_observed_state(result)
+    assert observed_values == dict(
+        zip(
+            observed_column_names(batch_for_datasource.datasource.type),
+            ["expected", "expected", "expected"],
+        )
+    )
+    expected_values = _extract_expected_state(result)
+    assert expected_values == {"COLUMN_A": None, "column_b": None, "COLumN_c": None}
+
+
+@parameterize_batch_for_data_sources(
+    data_source_configs=SQL_DATA_SOURCES,
+    data=CASE_INSENSITIVE_DATA,
+)
+def test_case_insensitive_failure(batch_for_datasource: Batch) -> None:
+    # Arrange
+    expectation = gxe.ExpectTableColumnsToMatchSet(column_set=["COLUMN_Az", "column_b", "COLumN_c"])
+
+    # Act
+    result = batch_for_datasource.validate(expectation)
+    result.render()  # creates rendered content
+
+    # Assert
+    assert not result.success
+
+    # Assert rendered content is as expected
+    observed_values = _extract_observed_state(result)
+    assert observed_values == dict(
+        zip(
+            observed_column_names(batch_for_datasource.datasource.type),
+            ["unexpected", "expected", "expected"],
+        )
+    )
+    expected_values = _extract_expected_state(result)
+    assert expected_values == {"COLUMN_Az": "missing", "column_b": None, "COLumN_c": None}
+
+
+def _extract_observed_state(result: ExpectationValidationResult) -> Dict[str, str]:
+    """Extracts observed column name to rendered state from validation result"""
+    # ExpectationValidationResult is not narrowly typed so we need to a lot of
+    # isinstance assertions for our expectation.
+    assert isinstance(result.rendered_content, list)
+    assert len(result.rendered_content) == 1
+    value = result.rendered_content[0].to_json_dict()["value"]
+    assert isinstance(value, dict)
+    rendered_params = value["params"]
+    assert isinstance(rendered_params, dict)
+    # We don't use a comprehension because we need to do type assertions with
+    # isinstance calls.
+    observed_state: Dict[str, str] = {}
+    for k, v in rendered_params.items():
+        assert isinstance(v, dict)
+        if k.startswith("ov__"):
+            assert isinstance(v["value"], str)
+            assert isinstance(v["render_state"], Enum)
+            observed_state[v["value"]] = v["render_state"].value
+    return observed_state
+
+
+def _extract_expected_state(result: ExpectationValidationResult) -> Dict[str, Optional[str]]:
+    """Extracts expected column name to rendered state from validation result"""
+    # ExpectationValidationResult is not narrowly typed so we need to a lot of
+    # isinstance assertions for our expectation.
+    assert isinstance(result.rendered_content, list)
+    assert len(result.rendered_content) == 1
+    value = result.rendered_content[0].to_json_dict()["value"]
+    assert isinstance(value, dict)
+    rendered_params = value["params"]
+    assert isinstance(rendered_params, dict)
+    # We don't use a comprehension because we need to do type assertions with
+    # isinstance calls.
+    expected_state: Dict[str, Optional[str]] = {}
+    for k, v in rendered_params.items():
+        assert isinstance(v, dict)
+        if k.startswith("exp__"):
+            assert isinstance(v["value"], str)
+            if "render_state" in v and isinstance(v["render_state"], Enum):
+                expected_state[v["value"]] = v["render_state"].value
+            else:
+                expected_state[v["value"]] = None
+    return expected_state
+
+
 @parameterize_batch_for_data_sources(
     data_source_configs=SQL_DATA_SOURCES_WITHOUT_SNOWFLAKE_REDSHIFT,
     data=CASE_INSENSITIVE_DATA,