diff --git a/packages/aws-cdk/lib/api/cloudformation-deployments.ts b/packages/aws-cdk/lib/api/cloudformation-deployments.ts
index a4438ff0ca8f7..7ec70ac4414a2 100644
--- a/packages/aws-cdk/lib/api/cloudformation-deployments.ts
+++ b/packages/aws-cdk/lib/api/cloudformation-deployments.ts
@@ -1,10 +1,13 @@
+import * as path from 'path';
 import * as cxapi from '@aws-cdk/cx-api';
 import { AssetManifest } from 'cdk-assets';
+import * as fs from 'fs-extra';
 import { Tag } from '../cdk-toolkit';
 import { debug, warning } from '../logging';
 import { publishAssets } from '../util/asset-publishing';
 import { Mode, SdkProvider, ISDK } from './aws-auth';
 import { deployStack, DeployStackResult, destroyStack } from './deploy-stack';
+import { LazyListStackResources, ListStackResources } from './evaluate-cloudformation-template';
 import { ToolkitInfo } from './toolkit-info';
 import { CloudFormationStack, Template } from './util/cloudformation';
 import { StackActivityProgress } from './util/cloudformation/stack-activity-monitor';
@@ -293,25 +296,23 @@ export class CloudFormationDeployments {
     this.sdkProvider = props.sdkProvider;
   }
 
-  public async readCurrentTemplate(stackArtifact: cxapi.CloudFormationStackArtifact): Promise<Template> {
-    debug(`Reading existing template for stack ${stackArtifact.displayName}.`);
-    let stackSdk: ISDK | undefined = undefined;
-    // try to assume the lookup role and fallback to the deploy role
-    try {
-      const result = await prepareSdkWithLookupRoleFor(this.sdkProvider, stackArtifact);
-      if (result.didAssumeRole) {
-        stackSdk = result.sdk;
-      }
-    } catch { }
+  public async readCurrentTemplateWithNestedStacks(rootStackArtifact: cxapi.CloudFormationStackArtifact): Promise<Template> {
+    const sdk = await this.prepareSdkWithLookupOrDeployRole(rootStackArtifact);
+    const deployedTemplate = await this.readCurrentTemplate(rootStackArtifact, sdk);
+    await this.addNestedTemplatesToGeneratedAndDeployedStacks(rootStackArtifact, sdk, {
+      generatedTemplate: rootStackArtifact.template,
+      deployedTemplate: deployedTemplate,
+      deployedStackName: rootStackArtifact.stackName,
+    });
+    return deployedTemplate;
+  }
 
-    if (!stackSdk) {
-      stackSdk = (await this.prepareSdkFor(stackArtifact, undefined, Mode.ForReading)).stackSdk;
+  public async readCurrentTemplate(stackArtifact: cxapi.CloudFormationStackArtifact, sdk?: ISDK): Promise<Template> {
+    debug(`Reading existing template for stack ${stackArtifact.displayName}.`);
+    if (!sdk) {
+      sdk = await this.prepareSdkWithLookupOrDeployRole(stackArtifact);
     }
-
-    const cfn = stackSdk.cloudFormation();
-
-    const stack = await CloudFormationStack.lookup(cfn, stackArtifact.stackName);
-    return stack.template();
+    return this.readCurrentStackTemplate(stackArtifact.stackName, sdk);
   }
 
   public async deployStack(options: DeployStackOptions): Promise<DeployStackResult> {
@@ -372,6 +373,95 @@ export class CloudFormationDeployments {
     return stack.exists;
   }
 
+  private async prepareSdkWithLookupOrDeployRole(stackArtifact: cxapi.CloudFormationStackArtifact): Promise<ISDK> {
+    // try to assume the lookup role
+    try {
+      const result = await prepareSdkWithLookupRoleFor(this.sdkProvider, stackArtifact);
+      if (result.didAssumeRole) {
+        return result.sdk;
+      }
+    } catch { }
+    // fall back to the deploy role
+    return (await this.prepareSdkFor(stackArtifact, undefined, Mode.ForReading)).stackSdk;
+  }
+
+  private async readCurrentStackTemplate(stackName: string, stackSdk: ISDK) : Promise<Template> {
+    const cfn = stackSdk.cloudFormation();
+    const stack = await CloudFormationStack.lookup(cfn, stackName);
+    return stack.template();
+  }
+
+  private async addNestedTemplatesToGeneratedAndDeployedStacks(
+    rootStackArtifact: cxapi.CloudFormationStackArtifact,
+    sdk: ISDK,
+    parentTemplates: StackTemplates,
+  ): Promise<void> {
+    const listStackResources = parentTemplates.deployedStackName ? new LazyListStackResources(sdk, parentTemplates.deployedStackName) : undefined;
+    for (const [nestedStackLogicalId, generatedNestedStackResource] of Object.entries(parentTemplates.generatedTemplate.Resources ?? {})) {
+      if (!this.isCdkManagedNestedStack(generatedNestedStackResource)) {
+        continue;
+      }
+
+      const assetPath = generatedNestedStackResource.Metadata['aws:asset:path'];
+      const nestedStackTemplates = await this.getNestedStackTemplates(rootStackArtifact, assetPath, nestedStackLogicalId, listStackResources, sdk);
+
+      generatedNestedStackResource.Properties.NestedTemplate = nestedStackTemplates.generatedTemplate;
+
+      const deployedParentTemplate = parentTemplates.deployedTemplate;
+      deployedParentTemplate.Resources = deployedParentTemplate.Resources ?? {};
+      const deployedNestedStackResource = deployedParentTemplate.Resources[nestedStackLogicalId] ?? {};
+      deployedParentTemplate.Resources[nestedStackLogicalId] = deployedNestedStackResource;
+      deployedNestedStackResource.Type = deployedNestedStackResource.Type ?? 'AWS::CloudFormation::Stack';
+      deployedNestedStackResource.Properties = deployedNestedStackResource.Properties ?? {};
+      deployedNestedStackResource.Properties.NestedTemplate = nestedStackTemplates.deployedTemplate;
+
+      await this.addNestedTemplatesToGeneratedAndDeployedStacks(
+        rootStackArtifact,
+        sdk,
+        nestedStackTemplates,
+      );
+    }
+  }
+
+  private async getNestedStackTemplates(
+    rootStackArtifact: cxapi.CloudFormationStackArtifact, nestedTemplateAssetPath: string, nestedStackLogicalId: string,
+    listStackResources: ListStackResources | undefined, sdk: ISDK,
+  ): Promise<StackTemplates> {
+    const nestedTemplatePath = path.join(rootStackArtifact.assembly.directory, nestedTemplateAssetPath);
+
+    // CFN generates the nested stack name in the form `ParentStackName-NestedStackLogicalID-SomeHashWeCan'tCompute,
+    // the arn is of the form: arn:aws:cloudformation:region:123456789012:stack/NestedStackName/AnotherHashWeDon'tNeed
+    // so we get the ARN and manually extract the name.
+    const nestedStackArn = await this.getNestedStackArn(nestedStackLogicalId, listStackResources);
+    const deployedStackName = nestedStackArn?.slice(nestedStackArn.indexOf('/') + 1, nestedStackArn.lastIndexOf('/'));
+
+    return {
+      generatedTemplate: JSON.parse(fs.readFileSync(nestedTemplatePath, 'utf-8')),
+      deployedTemplate: deployedStackName
+        ? await this.readCurrentStackTemplate(deployedStackName, sdk)
+        : {},
+      deployedStackName,
+    };
+  }
+
+  private async getNestedStackArn(
+    nestedStackLogicalId: string, listStackResources?: ListStackResources,
+  ): Promise<string | undefined> {
+    try {
+      const stackResources = await listStackResources?.listStackResources();
+      return stackResources?.find(sr => sr.LogicalResourceId === nestedStackLogicalId)?.PhysicalResourceId;
+    } catch (e) {
+      if (e.message.startsWith('Stack with id ') && e.message.endsWith(' does not exist')) {
+        return;
+      }
+      throw e;
+    }
+  }
+
+  private isCdkManagedNestedStack(stackResource: any): stackResource is NestedStackResource {
+    return stackResource.Type === 'AWS::CloudFormation::Stack' && stackResource.Metadata && stackResource.Metadata['aws:asset:path'];
+  }
+
   /**
    * Get the environment necessary for touching the given stack
    *
@@ -453,3 +543,14 @@ export class CloudFormationDeployments {
 function isAssetManifestArtifact(art: cxapi.CloudArtifact): art is cxapi.AssetManifestArtifact {
   return art instanceof cxapi.AssetManifestArtifact;
 }
+
+interface StackTemplates {
+  readonly generatedTemplate: any;
+  readonly deployedTemplate: any;
+  readonly deployedStackName: string | undefined;
+}
+
+interface NestedStackResource {
+  readonly Metadata: { 'aws:asset:path': string };
+  readonly Properties: any;
+}
diff --git a/packages/aws-cdk/lib/api/hotswap-deployments.ts b/packages/aws-cdk/lib/api/hotswap-deployments.ts
index da46369aa79c9..aebeae1058b34 100644
--- a/packages/aws-cdk/lib/api/hotswap-deployments.ts
+++ b/packages/aws-cdk/lib/api/hotswap-deployments.ts
@@ -234,4 +234,3 @@ async function applyHotswappableChange(sdk: ISDK, hotswapOperation: HotswapOpera
     sdk.removeCustomUserAgent(customUserAgent);
   }
 }
-
diff --git a/packages/aws-cdk/lib/cdk-toolkit.ts b/packages/aws-cdk/lib/cdk-toolkit.ts
index 141dbb2f7c3f4..56c5302544a84 100644
--- a/packages/aws-cdk/lib/cdk-toolkit.ts
+++ b/packages/aws-cdk/lib/cdk-toolkit.ts
@@ -1,8 +1,8 @@
 import * as path from 'path';
 import { format } from 'util';
 import * as cxapi from '@aws-cdk/cx-api';
-import * as chokidar from 'chokidar';
 import * as chalk from 'chalk';
+import * as chokidar from 'chokidar';
 import * as fs from 'fs-extra';
 import * as promptly from 'promptly';
 import { environmentsFromDescriptors, globEnvironmentsFromStacks, looksLikeGlob } from '../lib/api/cxapp/environments';
@@ -104,7 +104,7 @@ export class CdkToolkit {
       // Compare N stacks against deployed templates
       for (const stack of stacks.stackArtifacts) {
         stream.write(format('Stack %s\n', chalk.bold(stack.displayName)));
-        const currentTemplate = await this.props.cloudFormation.readCurrentTemplate(stack);
+        const currentTemplate = await this.props.cloudFormation.readCurrentTemplateWithNestedStacks(stack);
         diffs += options.securityOnly
           ? numberFromBool(printSecurityDiff(currentTemplate, stack, RequireApproval.Broadening))
           : printStackDiff(currentTemplate, stack, strict, contextLines, stream);
diff --git a/packages/aws-cdk/test/api/cloudformation-deployments.test.ts b/packages/aws-cdk/test/api/cloudformation-deployments.test.ts
index f89518e8858e0..d34563d1e0970 100644
--- a/packages/aws-cdk/test/api/cloudformation-deployments.test.ts
+++ b/packages/aws-cdk/test/api/cloudformation-deployments.test.ts
@@ -1,18 +1,39 @@
 jest.mock('../../lib/api/deploy-stack');
 
+import { CloudFormation } from 'aws-sdk';
 import { CloudFormationDeployments } from '../../lib/api/cloudformation-deployments';
 import { deployStack } from '../../lib/api/deploy-stack';
 import { ToolkitInfo } from '../../lib/api/toolkit-info';
+import { CloudFormationStack } from '../../lib/api/util/cloudformation';
 import { testStack } from '../util';
 import { mockBootstrapStack, MockSdkProvider } from '../util/mock-sdk';
+import { FakeCloudformationStack } from './fake-cloudformation-stack';
 
 let sdkProvider: MockSdkProvider;
 let deployments: CloudFormationDeployments;
 let mockToolkitInfoLookup: jest.Mock;
+let currentCfnStackResources: { [key: string]: CloudFormation.StackResourceSummary[] };
+let numberOfTimesListStackResourcesWasCalled: number;
 beforeEach(() => {
   jest.resetAllMocks();
   sdkProvider = new MockSdkProvider();
   deployments = new CloudFormationDeployments({ sdkProvider });
+
+  numberOfTimesListStackResourcesWasCalled = 0;
+  currentCfnStackResources = {};
+  sdkProvider.stubCloudFormation({
+    listStackResources: ({ StackName: stackName }) => {
+      numberOfTimesListStackResourcesWasCalled++;
+      const stackResources = currentCfnStackResources[stackName];
+      if (!stackResources) {
+        throw new Error(`Stack with id ${stackName} does not exist`);
+      }
+      return {
+        StackResourceSummaries: stackResources,
+      };
+    },
+  });
+
   ToolkitInfo.lookup = mockToolkitInfoLookup = jest.fn().mockResolvedValue(ToolkitInfo.bootstrapStackNotFoundInfo(sdkProvider.sdk));
 });
 
@@ -142,3 +163,700 @@ test('if toolkit stack cannot be found but SSM parameter name is present deploym
 
   expect(requestedParameterName!).toEqual('/some/parameter');
 });
+
+test('readCurrentTemplateWithNestedStacks() can handle non-Resources in the template', async () => {
+  const cfnStack = new FakeCloudformationStack({
+    stackName: 'ParentOfStackWithOutputAndParameter',
+    stackId: 'StackId',
+  });
+  CloudFormationStack.lookup = (async (_, stackName: string) => {
+    switch (stackName) {
+      case 'ParentOfStackWithOutputAndParameter':
+        cfnStack.template = async () => ({
+          Resources: {
+            NestedStack: {
+              Type: 'AWS::CloudFormation::Stack',
+              Properties: {
+                TemplateURL: 'https://www.magic-url.com',
+              },
+              Metadata: {
+                'aws:asset:path': 'one-output-one-param-stack.nested.template.json',
+              },
+            },
+          },
+        });
+        break;
+
+      case 'NestedStack':
+        cfnStack.template = async () => ({
+          Resources: {
+            NestedResource: {
+              Type: 'AWS::Something',
+              Properties: {
+                Property: 'old-value',
+              },
+            },
+          },
+          Parameters: {
+            NestedParam: {
+              Type: 'String',
+            },
+          },
+          Outputs: {
+            NestedOutput: {
+              Value: {
+                Ref: 'NestedResource',
+              },
+            },
+          },
+        });
+        break;
+
+      default:
+        throw new Error('unknown stack name ' + stackName + ' found');
+    }
+
+    return cfnStack;
+  });
+
+  const rootStack = testStack({
+    stackName: 'ParentOfStackWithOutputAndParameter',
+    template: {
+      Resources: {
+        NestedStack: {
+          Type: 'AWS::CloudFormation::Stack',
+          Properties: {
+            TemplateURL: 'https://www.magic-url.com',
+          },
+          Metadata: {
+            'aws:asset:path': 'one-output-one-param-stack.nested.template.json',
+          },
+        },
+      },
+    },
+  });
+
+  pushStackResourceSummaries('ParentOfStackWithOutputAndParameter',
+    stackSummaryOf('NestedStack', 'AWS::CloudFormation::Stack',
+      'arn:aws:cloudformation:bermuda-triangle-1337:123456789012:stack/NestedStack/abcd',
+    ),
+  );
+
+  // WHEN
+  const deployedTemplate = await deployments.readCurrentTemplateWithNestedStacks(rootStack);
+
+  // THEN
+  expect(deployedTemplate).toEqual({
+    Resources: {
+      NestedStack: {
+        Type: 'AWS::CloudFormation::Stack',
+        Properties: {
+          TemplateURL: 'https://www.magic-url.com',
+          NestedTemplate: {
+            Resources: {
+              NestedResource: {
+                Type: 'AWS::Something',
+                Properties: {
+                  Property: 'old-value',
+                },
+              },
+            },
+            Outputs: {
+              NestedOutput: {
+                Value: {
+                  Ref: 'NestedResource',
+                },
+              },
+            },
+            Parameters: {
+              NestedParam: {
+                Type: 'String',
+              },
+            },
+          },
+        },
+        Metadata: {
+          'aws:asset:path': 'one-output-one-param-stack.nested.template.json',
+        },
+      },
+    },
+  });
+
+  expect(rootStack.template).toEqual({
+    Resources: {
+      NestedStack: {
+        Type: 'AWS::CloudFormation::Stack',
+        Properties: {
+          TemplateURL: 'https://www.magic-url.com',
+          NestedTemplate: {
+            Resources: {
+              NestedResource: {
+                Type: 'AWS::Something',
+                Properties: {
+                  Property: 'new-value',
+                },
+              },
+            },
+            Outputs: {
+              NestedOutput: {
+                Value: {
+                  Ref: 'NestedResource',
+                },
+              },
+            },
+            Parameters: {
+              NestedParam: {
+                Type: 'Number',
+              },
+            },
+          },
+        },
+        Metadata: {
+          'aws:asset:path': 'one-output-one-param-stack.nested.template.json',
+        },
+      },
+    },
+  });
+});
+
+test('readCurrentTemplateWithNestedStacks() with a 3-level nested + sibling structure works', async () => {
+  const cfnStack = new FakeCloudformationStack({
+    stackName: 'MultiLevelRoot',
+    stackId: 'StackId',
+  });
+  CloudFormationStack.lookup = (async (_, stackName: string) => {
+    switch (stackName) {
+      case 'MultiLevelRoot':
+        cfnStack.template = async () => ({
+          Resources: {
+            NestedStack: {
+              Type: 'AWS::CloudFormation::Stack',
+              Properties: {
+                TemplateURL: 'https://www.magic-url.com',
+              },
+              Metadata: {
+                'aws:asset:path': 'one-resource-two-stacks-stack.nested.template.json',
+              },
+            },
+          },
+        });
+        break;
+
+      case 'NestedStack':
+        cfnStack.template = async () => ({
+          Resources: {
+            SomeResource: {
+              Type: 'AWS::Something',
+              Properties: {
+                Property: 'old-value',
+              },
+            },
+            GrandChildStackA: {
+              Type: 'AWS::CloudFormation::Stack',
+              Properties: {
+                TemplateURL: 'https://www.magic-url.com',
+              },
+              Metadata: {
+                'aws:asset:path': 'one-resource-stack.nested.template.json',
+              },
+            },
+            GrandChildStackB: {
+              Type: 'AWS::CloudFormation::Stack',
+              Properties: {
+                TemplateURL: 'https://www.magic-url.com',
+              },
+              Metadata: {
+                'aws:asset:path': 'one-resource-stack.nested.template.json',
+              },
+            },
+          },
+        });
+        break;
+
+      case 'GrandChildStackA':
+        cfnStack.template = async () => ({
+          Resources: {
+            SomeResource: {
+              Type: 'AWS::Something',
+              Properties: {
+                Property: 'old-value',
+              },
+            },
+          },
+        });
+        break;
+
+      case 'GrandChildStackB':
+        cfnStack.template = async () => ({
+          Resources: {
+            SomeResource: {
+              Type: 'AWS::Something',
+              Properties: {
+                Property: 'old-value',
+              },
+            },
+          },
+        });
+        break;
+
+      default:
+        throw new Error('unknown stack name ' + stackName + ' found in cloudformation-deployments.test.ts');
+    }
+
+    return cfnStack;
+  });
+
+  const rootStack = testStack({
+    stackName: 'MultiLevelRoot',
+    template: {
+      Resources: {
+        NestedStack: {
+          Type: 'AWS::CloudFormation::Stack',
+          Properties: {
+            TemplateURL: 'https://www.magic-url.com',
+          },
+          Metadata: {
+            'aws:asset:path': 'one-resource-two-stacks-stack.nested.template.json',
+          },
+        },
+      },
+    },
+  });
+
+  pushStackResourceSummaries('MultiLevelRoot',
+    stackSummaryOf('NestedStack', 'AWS::CloudFormation::Stack',
+      'arn:aws:cloudformation:bermuda-triangle-1337:123456789012:stack/NestedStack/abcd',
+    ),
+  );
+  pushStackResourceSummaries('NestedStack',
+    stackSummaryOf('GrandChildStackA', 'AWS::CloudFormation::Stack',
+      'arn:aws:cloudformation:bermuda-triangle-1337:123456789012:stack/GrandChildStackA/abcd',
+    ),
+    stackSummaryOf('GrandChildStackB', 'AWS::CloudFormation::Stack',
+      'arn:aws:cloudformation:bermuda-triangle-1337:123456789012:stack/GrandChildStackB/abcd',
+    ),
+  );
+  pushStackResourceSummaries('GrandChildStackA',
+    stackSummaryOf('NestedStack', 'AWS::CloudFormation::Stack',
+      'arn:aws:cloudformation:bermuda-triangle-1337:123456789012:stack/GrandChildA/abcd',
+    ),
+  );
+  pushStackResourceSummaries('GrandChildStackB',
+    stackSummaryOf('NestedStack', 'AWS::CloudFormation::Stack',
+      'arn:aws:cloudformation:bermuda-triangle-1337:123456789012:stack/GrandChildB/abcd',
+    ),
+  );
+
+  // WHEN
+  const deployedTemplate = await deployments.readCurrentTemplateWithNestedStacks(rootStack);
+
+  // THEN
+  expect(deployedTemplate).toEqual({
+    Resources: {
+      NestedStack: {
+        Type: 'AWS::CloudFormation::Stack',
+        Properties: {
+          TemplateURL: 'https://www.magic-url.com',
+          NestedTemplate: {
+            Resources: {
+              GrandChildStackA: {
+                Type: 'AWS::CloudFormation::Stack',
+                Properties: {
+                  TemplateURL: 'https://www.magic-url.com',
+                  NestedTemplate: {
+                    Resources: {
+                      SomeResource: {
+                        Type: 'AWS::Something',
+                        Properties: {
+                          Property: 'old-value',
+                        },
+                      },
+                    },
+                  },
+                },
+                Metadata: {
+                  'aws:asset:path': 'one-resource-stack.nested.template.json',
+                },
+              },
+              GrandChildStackB: {
+                Type: 'AWS::CloudFormation::Stack',
+                Properties: {
+                  TemplateURL: 'https://www.magic-url.com',
+                  NestedTemplate: {
+                    Resources: {
+                      SomeResource: {
+                        Type: 'AWS::Something',
+                        Properties: {
+                          Property: 'old-value',
+                        },
+                      },
+                    },
+                  },
+                },
+                Metadata: {
+                  'aws:asset:path': 'one-resource-stack.nested.template.json',
+                },
+              },
+              SomeResource: {
+                Type: 'AWS::Something',
+                Properties: {
+                  Property: 'old-value',
+                },
+              },
+            },
+          },
+        },
+        Metadata: {
+          'aws:asset:path': 'one-resource-two-stacks-stack.nested.template.json',
+        },
+      },
+    },
+  });
+
+  expect(rootStack.template).toEqual({
+    Resources: {
+      NestedStack: {
+        Type: 'AWS::CloudFormation::Stack',
+        Properties: {
+          TemplateURL: 'https://www.magic-url.com',
+          NestedTemplate: {
+            Resources: {
+              GrandChildStackA: {
+                Type: 'AWS::CloudFormation::Stack',
+                Properties: {
+                  TemplateURL: 'https://www.magic-url.com',
+                  NestedTemplate: {
+                    Resources: {
+                      SomeResource: {
+                        Type: 'AWS::Something',
+                        Properties: {
+                          Property: 'new-value',
+                        },
+                      },
+                    },
+                  },
+                },
+                Metadata: {
+                  'aws:asset:path': 'one-resource-stack.nested.template.json',
+                },
+              },
+              GrandChildStackB: {
+                Type: 'AWS::CloudFormation::Stack',
+                Properties: {
+                  TemplateURL: 'https://www.magic-url.com',
+                  NestedTemplate: {
+                    Resources: {
+                      SomeResource: {
+                        Type: 'AWS::Something',
+                        Properties: {
+                          Property: 'new-value',
+                        },
+                      },
+                    },
+                  },
+                },
+                Metadata: {
+                  'aws:asset:path': 'one-resource-stack.nested.template.json',
+                },
+              },
+              SomeResource: {
+                Type: 'AWS::Something',
+                Properties: {
+                  Property: 'new-value',
+                },
+              },
+            },
+          },
+        },
+        Metadata: {
+          'aws:asset:path': 'one-resource-two-stacks-stack.nested.template.json',
+        },
+      },
+    },
+  });
+});
+
+test('readCurrentTemplateWithNestedStacks() on an undeployed parent stack with an (also undeployed) nested stack works', async () => {
+  // GIVEN
+  const cfnStack = new FakeCloudformationStack({
+    stackName: 'UndeployedParent',
+    stackId: 'StackId',
+  });
+  CloudFormationStack.lookup = (async (_cfn, _stackName: string) => {
+    cfnStack.template = async () => ({});
+
+    return cfnStack;
+  });
+  const rootStack = testStack({
+    stackName: 'UndeployedParent',
+    template: {
+      Resources: {
+        NestedStack: {
+          Type: 'AWS::CloudFormation::Stack',
+          Properties: {
+            TemplateURL: 'https://www.magic-url.com',
+          },
+          Metadata: {
+            'aws:asset:path': 'one-resource-one-stack-stack.nested.template.json',
+          },
+        },
+      },
+    },
+  });
+
+  // WHEN
+  const deployedTemplate = await deployments.readCurrentTemplateWithNestedStacks(rootStack);
+
+  // THEN
+  expect(deployedTemplate).toEqual({
+    Resources: {
+      NestedStack: {
+        Type: 'AWS::CloudFormation::Stack',
+        Properties: {
+          NestedTemplate: {
+            Resources: {
+              NestedStack: {
+                Type: 'AWS::CloudFormation::Stack',
+                Properties: {
+                  NestedTemplate: {},
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  });
+});
+
+test('readCurrentTemplateWithNestedStacks() caches calls to listStackResources()', async () => {
+  // GIVEN
+  const cfnStack = new FakeCloudformationStack({
+    stackName: 'CachingRoot',
+    stackId: 'StackId',
+  });
+  CloudFormationStack.lookup = (async (_cfn, _stackName: string) => {
+    cfnStack.template = async () => ({
+      Resources:
+      {
+        NestedStackA: {
+          Type: 'AWS::CloudFormation::Stack',
+          Properties: {
+            TemplateURL: 'https://www.magic-url.com',
+          },
+          Metadata: {
+            'aws:asset:path': 'one-resource-stack.nested.template.json',
+          },
+        },
+        NestedStackB: {
+          Type: 'AWS::CloudFormation::Stack',
+          Properties: {
+            TemplateURL: 'https://www.magic-url.com',
+          },
+          Metadata: {
+            'aws:asset:path': 'one-resource-stack.nested.template.json',
+          },
+        },
+      },
+    });
+
+    return cfnStack;
+  });
+
+  const rootStack = testStack({
+    stackName: 'CachingRoot',
+    template: {
+      Resources: {
+        NestedStackA: {
+          Type: 'AWS::CloudFormation::Stack',
+          Properties: {
+            TemplateURL: 'https://www.magic-url.com',
+          },
+          Metadata: {
+            'aws:asset:path': 'one-resource-stack.nested.template.json',
+          },
+        },
+        NestedStackB: {
+          Type: 'AWS::CloudFormation::Stack',
+          Properties: {
+            TemplateURL: 'https://www.magic-url.com',
+          },
+          Metadata: {
+            'aws:asset:path': 'one-resource-stack.nested.template.json',
+          },
+        },
+      },
+    },
+  });
+
+  pushStackResourceSummaries('CachingRoot',
+    stackSummaryOf('NestedStackA', 'AWS::CloudFormation::Stack',
+      'arn:aws:cloudformation:bermuda-triangle-1337:123456789012:stack/one-resource-stack/abcd',
+    ),
+    stackSummaryOf('NestedStackB', 'AWS::CloudFormation::Stack',
+      'arn:aws:cloudformation:bermuda-triangle-1337:123456789012:stack/one-resource-stack/abcd',
+    ),
+  );
+
+  // WHEN
+  await deployments.readCurrentTemplateWithNestedStacks(rootStack);
+
+  // THEN
+  expect(numberOfTimesListStackResourcesWasCalled).toEqual(1);
+});
+
+test('readCurrentTemplateWithNestedStacks() succesfully ignores stacks without metadata', async () => {
+  // GIVEN
+  const cfnStack = new FakeCloudformationStack({
+    stackName: 'MetadataRoot',
+    stackId: 'StackId',
+  });
+  CloudFormationStack.lookup = (async (_, stackName: string) => {
+    if (stackName === 'MetadataRoot') {
+      cfnStack.template = async () => ({
+        Resources: {
+          WithMetadata: {
+            Type: 'AWS::CloudFormation::Stack',
+            Properties: {
+              TemplateURL: 'https://www.magic-url.com',
+            },
+            Metadata: {
+              'aws:asset:path': 'one-resource-stack.nested.template.json',
+            },
+          },
+        },
+      });
+
+    } else {
+      cfnStack.template = async () => ({
+        Resources: {
+          SomeResource: {
+            Type: 'AWS::Something',
+            Properties: {
+              Property: 'old-value',
+            },
+          },
+        },
+      });
+    }
+
+    return cfnStack;
+  });
+
+  const rootStack = testStack({
+    stackName: 'MetadataRoot',
+    template: {
+      Resources: {
+        WithoutMetadata: {
+          Properties: {
+            TemplateURL: 'https://www.magic-url.com',
+          },
+          Type: 'AWS::CloudFormation::Stack',
+        },
+        WithEmptyMetadata: {
+          Type: 'AWS::CloudFormation::Stack',
+          Properties: {
+            TemplateURL: 'https://www.magic-url.com',
+          },
+          Metadata: {},
+        },
+        WithMetadata: {
+          Type: 'AWS::CloudFormation::Stack',
+          Properties: {
+            TemplateURL: 'https://www.magic-url.com',
+          },
+          Metadata: {
+            'aws:asset:path': 'one-resource-stack.nested.template.json',
+          },
+        },
+      },
+    },
+  });
+
+  pushStackResourceSummaries('MetadataRoot', stackSummaryOf('WithMetadata', 'AWS::CloudFormation::Stack',
+    'arn:aws:cloudformation:bermuda-triangle-1337:123456789012:stack/one-resource-stack/abcd',
+  ));
+
+  // WHEN
+  const deployedTemplate = await deployments.readCurrentTemplateWithNestedStacks(rootStack);
+
+  // THEN
+  expect(deployedTemplate).toEqual({
+    Resources: {
+      WithMetadata: {
+        Type: 'AWS::CloudFormation::Stack',
+        Properties: {
+          TemplateURL: 'https://www.magic-url.com',
+          NestedTemplate: {
+            Resources: {
+              SomeResource: {
+                Type: 'AWS::Something',
+                Properties: {
+                  Property: 'old-value',
+                },
+              },
+            },
+          },
+        },
+        Metadata: {
+          'aws:asset:path': 'one-resource-stack.nested.template.json',
+        },
+      },
+    },
+  });
+
+  expect(rootStack.template).toEqual({
+    Resources: {
+      WithoutMetadata: { // Unchanged
+        Type: 'AWS::CloudFormation::Stack',
+        Properties: {
+          TemplateURL: 'https://www.magic-url.com',
+        },
+      },
+      WithEmptyMetadata: { // Unchanged
+        Type: 'AWS::CloudFormation::Stack',
+        Properties: {
+          TemplateURL: 'https://www.magic-url.com',
+        },
+        Metadata: {},
+      },
+      WithMetadata: { // Changed
+        Type: 'AWS::CloudFormation::Stack',
+        Properties: {
+          TemplateURL: 'https://www.magic-url.com',
+          NestedTemplate: {
+            Resources: {
+              SomeResource: {
+                Type: 'AWS::Something',
+                Properties: {
+                  Property: 'new-value',
+                },
+              },
+            },
+          },
+        },
+        Metadata: {
+          'aws:asset:path': 'one-resource-stack.nested.template.json',
+        },
+      },
+    },
+  });
+});
+
+function pushStackResourceSummaries(stackName: string, ...items: CloudFormation.StackResourceSummary[]) {
+  if (!currentCfnStackResources[stackName]) {
+    currentCfnStackResources[stackName] = [];
+  }
+
+  currentCfnStackResources[stackName].push(...items);
+}
+
+function stackSummaryOf(logicalId: string, resourceType: string, physicalResourceId: string): CloudFormation.StackResourceSummary {
+  return {
+    LogicalResourceId: logicalId,
+    PhysicalResourceId: physicalResourceId,
+    ResourceType: resourceType,
+    ResourceStatus: 'CREATE_COMPLETE',
+    LastUpdatedTimestamp: new Date(),
+  };
+}
diff --git a/packages/aws-cdk/test/diff-nested-stacks-templates/one-output-one-param-stack.nested.template.json b/packages/aws-cdk/test/diff-nested-stacks-templates/one-output-one-param-stack.nested.template.json
new file mode 100644
index 0000000000000..a86df6dfe5f29
--- /dev/null
+++ b/packages/aws-cdk/test/diff-nested-stacks-templates/one-output-one-param-stack.nested.template.json
@@ -0,0 +1,20 @@
+{
+  "Resources": {
+    "NestedResource": {
+      "Type": "AWS::Something",
+      "Properties": {
+        "Property": "new-value"
+      }
+    }
+  },
+  "Parameters": {
+    "NestedParam": {
+      "Type": "Number"
+    }
+  },
+  "Outputs": {
+    "NestedOutput": {
+      "Value": { "Ref": "NestedResource" }
+    }
+  }
+}
diff --git a/packages/aws-cdk/test/diff-nested-stacks-templates/one-resource-one-stack-stack.nested.template.json b/packages/aws-cdk/test/diff-nested-stacks-templates/one-resource-one-stack-stack.nested.template.json
new file mode 100644
index 0000000000000..34317afa74d5c
--- /dev/null
+++ b/packages/aws-cdk/test/diff-nested-stacks-templates/one-resource-one-stack-stack.nested.template.json
@@ -0,0 +1,19 @@
+{
+  "Resources": {
+    "SomeResource": {
+      "Type": "AWS::Something",
+      "Properties": {
+        "Property": "new-value"
+      }
+    },
+    "NestedStack": {
+      "Type": "AWS::CloudFormation::Stack",
+      "Properties": {
+        "TemplateURL": "https://www.magic-url.com"
+      },
+      "Metadata": {
+        "aws:asset:path": "one-resource-stack.nested.template.json"
+      }
+    }
+  }
+}
diff --git a/packages/aws-cdk/test/diff-nested-stacks-templates/one-resource-stack.nested.template.json b/packages/aws-cdk/test/diff-nested-stacks-templates/one-resource-stack.nested.template.json
new file mode 100644
index 0000000000000..f288b015bbf83
--- /dev/null
+++ b/packages/aws-cdk/test/diff-nested-stacks-templates/one-resource-stack.nested.template.json
@@ -0,0 +1,10 @@
+{
+  "Resources": {
+    "SomeResource": {
+      "Type": "AWS::Something",
+      "Properties": {
+        "Property": "new-value"
+      }
+    }
+  }
+}
diff --git a/packages/aws-cdk/test/diff-nested-stacks-templates/one-resource-two-stacks-stack.nested.template.json b/packages/aws-cdk/test/diff-nested-stacks-templates/one-resource-two-stacks-stack.nested.template.json
new file mode 100644
index 0000000000000..8fc77b09f6e85
--- /dev/null
+++ b/packages/aws-cdk/test/diff-nested-stacks-templates/one-resource-two-stacks-stack.nested.template.json
@@ -0,0 +1,28 @@
+{
+  "Resources": {
+    "SomeResource": {
+      "Type": "AWS::Something",
+      "Properties": {
+        "Property": "new-value"
+      }
+    },
+    "GrandChildStackA": {
+      "Type": "AWS::CloudFormation::Stack",
+      "Properties": {
+        "TemplateURL": "https://www.magic-url.com"
+      },
+      "Metadata": {
+        "aws:asset:path": "one-resource-stack.nested.template.json"
+      }
+    },
+    "GrandChildStackB": {
+      "Type": "AWS::CloudFormation::Stack",
+      "Properties": {
+        "TemplateURL": "https://www.magic-url.com"
+      },
+      "Metadata": {
+        "aws:asset:path": "one-resource-stack.nested.template.json"
+      }
+    }
+  }
+}
diff --git a/packages/aws-cdk/test/diff.test.ts b/packages/aws-cdk/test/diff.test.ts
index 829c24d637ca9..efcf5d09d05ab 100644
--- a/packages/aws-cdk/test/diff.test.ts
+++ b/packages/aws-cdk/test/diff.test.ts
@@ -9,126 +9,254 @@ import { instanceMockFrom, MockCloudExecutable } from './util';
 let cloudExecutable: MockCloudExecutable;
 let cloudFormation: jest.Mocked<CloudFormationDeployments>;
 let toolkit: CdkToolkit;
-beforeEach(() => {
-  cloudExecutable = new MockCloudExecutable({
-    stacks: [{
-      stackName: 'A',
-      template: { resource: 'A' },
-    },
-    {
-      stackName: 'B',
-      depends: ['A'],
-      template: { resource: 'B' },
-    },
-    {
-      stackName: 'C',
-      depends: ['A'],
-      template: { resource: 'C' },
-      metadata: {
-        '/resource': [
-          {
-            type: cxschema.ArtifactMetadataEntryType.ERROR,
-            data: 'this is an error',
-          },
-        ],
+
+describe('non-nested stacks', () => {
+  beforeEach(() => {
+    cloudExecutable = new MockCloudExecutable({
+      stacks: [{
+        stackName: 'A',
+        template: { resource: 'A' },
       },
-    },
-    {
-      stackName: 'D',
-      template: { resource: 'D' },
-    }],
-  });
+      {
+        stackName: 'B',
+        depends: ['A'],
+        template: { resource: 'B' },
+      },
+      {
+        stackName: 'C',
+        depends: ['A'],
+        template: { resource: 'C' },
+        metadata: {
+          '/resource': [
+            {
+              type: cxschema.ArtifactMetadataEntryType.ERROR,
+              data: 'this is an error',
+            },
+          ],
+        },
+      },
+      {
+        stackName: 'D',
+        template: { resource: 'D' },
+      }],
+    });
+
+    cloudFormation = instanceMockFrom(CloudFormationDeployments);
 
-  cloudFormation = instanceMockFrom(CloudFormationDeployments);
+    toolkit = new CdkToolkit({
+      cloudExecutable,
+      cloudFormation,
+      configuration: cloudExecutable.configuration,
+      sdkProvider: cloudExecutable.sdkProvider,
+    });
 
-  toolkit = new CdkToolkit({
-    cloudExecutable,
-    cloudFormation,
-    configuration: cloudExecutable.configuration,
-    sdkProvider: cloudExecutable.sdkProvider,
+    // Default implementations
+    cloudFormation.readCurrentTemplateWithNestedStacks.mockImplementation((stackArtifact: CloudFormationStackArtifact) => {
+      if (stackArtifact.stackName === 'D') {
+        return Promise.resolve({ resource: 'D' });
+      }
+      return Promise.resolve({});
+    });
+    cloudFormation.deployStack.mockImplementation((options) => Promise.resolve({
+      noOp: true,
+      outputs: {},
+      stackArn: '',
+      stackArtifact: options.stack,
+    }));
   });
 
-  // Default implementations
-  cloudFormation.readCurrentTemplate.mockImplementation((stackArtifact: CloudFormationStackArtifact) => {
-    if (stackArtifact.stackName === 'D') {
-      return Promise.resolve({ resource: 'D' });
-    }
-    return Promise.resolve({});
+  test('diff can diff multiple stacks', async () => {
+    // GIVEN
+    const buffer = new StringWritable();
+
+    // WHEN
+    const exitCode = await toolkit.diff({
+      stackNames: ['B'],
+      stream: buffer,
+    });
+
+    // THEN
+    const plainTextOutput = buffer.data.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, '');
+    expect(plainTextOutput).toContain('Stack A');
+    expect(plainTextOutput).toContain('Stack B');
+
+    expect(exitCode).toBe(0);
   });
-  cloudFormation.deployStack.mockImplementation((options) => Promise.resolve({
-    noOp: true,
-    outputs: {},
-    stackArn: '',
-    stackArtifact: options.stack,
-  }));
-});
 
-test('diff can diff multiple stacks', async () => {
-  // GIVEN
-  const buffer = new StringWritable();
+  test('exits with 1 with diffs and fail set to true', async () => {
+    // GIVEN
+    const buffer = new StringWritable();
+
+    // WHEN
+    const exitCode = await toolkit.diff({
+      stackNames: ['A'],
+      stream: buffer,
+      fail: true,
+    });
 
-  // WHEN
-  const exitCode = await toolkit.diff({
-    stackNames: ['B'],
-    stream: buffer,
+    // THEN
+    expect(exitCode).toBe(1);
   });
 
-  // THEN
-  const plainTextOutput = buffer.data.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, '');
-  expect(plainTextOutput).toContain('Stack A');
-  expect(plainTextOutput).toContain('Stack B');
+  test('throws an error if no valid stack names given', async () => {
+    const buffer = new StringWritable();
 
-  expect(exitCode).toBe(0);
-});
+    // WHEN
+    await expect(() => toolkit.diff({
+      stackNames: ['X', 'Y', 'Z'],
+      stream: buffer,
+    })).rejects.toThrow('No stacks match the name(s) X,Y,Z');
+  });
+
+  test('exits with 1 with diff in first stack, but not in second stack and fail set to true', async () => {
+    // GIVEN
+    const buffer = new StringWritable();
 
-test('exits with 1 with diffs and fail set to true', async () => {
-  // GIVEN
-  const buffer = new StringWritable();
+    // WHEN
+    const exitCode = await toolkit.diff({
+      stackNames: ['A', 'D'],
+      stream: buffer,
+      fail: true,
+    });
 
-  // WHEN
-  const exitCode = await toolkit.diff({
-    stackNames: ['A'],
-    stream: buffer,
-    fail: true,
+    // THEN
+    expect(exitCode).toBe(1);
   });
 
-  // THEN
-  expect(exitCode).toBe(1);
+  test('throws an error during diffs on stack with error metadata', async () => {
+    const buffer = new StringWritable();
+
+    // WHEN
+    await expect(() => toolkit.diff({
+      stackNames: ['C'],
+      stream: buffer,
+    })).rejects.toThrow(/Found errors/);
+  });
 });
 
-test('throws an error if no valid stack names given', async () => {
-  const buffer = new StringWritable();
+describe('nested stacks', () => {
+  beforeEach(() => {
+    cloudExecutable = new MockCloudExecutable({
+      stacks: [{
+        stackName: 'Parent',
+        template: { },
+      }],
+    });
 
-  // WHEN
-  await expect(() => toolkit.diff({
-    stackNames: ['X', 'Y', 'Z'],
-    stream: buffer,
-  })).rejects.toThrow('No stacks match the name(s) X,Y,Z');
-});
+    cloudFormation = instanceMockFrom(CloudFormationDeployments);
 
-test('exits with 1 with diff in first stack, but not in second stack and fail set to true', async () => {
-  // GIVEN
-  const buffer = new StringWritable();
+    toolkit = new CdkToolkit({
+      cloudExecutable,
+      cloudFormation,
+      configuration: cloudExecutable.configuration,
+      sdkProvider: cloudExecutable.sdkProvider,
+    });
 
-  // WHEN
-  const exitCode = await toolkit.diff({
-    stackNames: ['A', 'D'],
-    stream: buffer,
-    fail: true,
+    cloudFormation.readCurrentTemplateWithNestedStacks.mockImplementation((stackArtifact: CloudFormationStackArtifact) => {
+      if (stackArtifact.stackName === 'Parent') {
+        stackArtifact.template.Resources = {
+          AdditionChild: {
+            Type: 'AWS::CloudFormation::Stack',
+            Resources: {
+              SomeResource: {
+                Type: 'AWS::Something',
+                Properties: {
+                  Prop: 'added-value',
+                },
+              },
+            },
+          },
+          DeletionChild: {
+            Type: 'AWS::CloudFormation::Stack',
+            Resources: {
+              SomeResource: {
+                Type: 'AWS::Something',
+              },
+            },
+          },
+          ChangedChild: {
+            Type: 'AWS::CloudFormation::Stack',
+            Resources: {
+              SomeResource: {
+                Type: 'AWS::Something',
+                Properties: {
+                  Prop: 'new-value',
+                },
+              },
+            },
+          },
+        };
+        return Promise.resolve({
+          Resources: {
+            AdditionChild: {
+              Type: 'AWS::CloudFormation::Stack',
+              Resources: {
+                SomeResource: {
+                  Type: 'AWS::Something',
+                },
+              },
+            },
+            DeletionChild: {
+              Type: 'AWS::CloudFormation::Stack',
+              Resources: {
+                SomeResource: {
+                  Type: 'AWS::Something',
+                  Properties: {
+                    Prop: 'value-to-be-removed',
+                  },
+                },
+              },
+            },
+            ChangedChild: {
+              Type: 'AWS::CloudFormation::Stack',
+              Resources: {
+                SomeResource: {
+                  Type: 'AWS::Something',
+                  Properties: {
+                    Prop: 'old-value',
+                  },
+                },
+              },
+            },
+          },
+        });
+      }
+      return Promise.resolve({});
+    });
   });
 
-  // THEN
-  expect(exitCode).toBe(1);
-});
+  test('diff can diff nested stacks', async () => {
+    // GIVEN
+    const buffer = new StringWritable();
+
+    // WHEN
+    const exitCode = await toolkit.diff({
+      stackNames: ['Parent'],
+      stream: buffer,
+    });
 
-test('throws an error during diffs on stack with error metadata', async () => {
-  const buffer = new StringWritable();
+    // THEN
+    const plainTextOutput = buffer.data.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, '');
+    expect(plainTextOutput.trim()).toEqual(`Stack Parent
+Resources
+[~] AWS::CloudFormation::Stack AdditionChild 
+ └─ [~] Resources
+     └─ [~] .SomeResource:
+         └─ [+] Added: .Properties
+[~] AWS::CloudFormation::Stack DeletionChild 
+ └─ [~] Resources
+     └─ [~] .SomeResource:
+         └─ [-] Removed: .Properties
+[~] AWS::CloudFormation::Stack ChangedChild 
+ └─ [~] Resources
+     └─ [~] .SomeResource:
+         └─ [~] .Properties:
+             └─ [~] .Prop:
+                 ├─ [-] old-value
+                 └─ [+] new-value`);
 
-  // WHEN
-  await expect(() => toolkit.diff({
-    stackNames: ['C'],
-    stream: buffer,
-  })).rejects.toThrow(/Found errors/);
+    expect(exitCode).toBe(0);
+  });
 });
 
 class StringWritable extends Writable {
diff --git a/packages/aws-cdk/test/util.ts b/packages/aws-cdk/test/util.ts
index 494efcff1982e..fb714bc8427d7 100644
--- a/packages/aws-cdk/test/util.ts
+++ b/packages/aws-cdk/test/util.ts
@@ -54,6 +54,7 @@ function addAttributes(assembly: TestAssembly, builder: cxapi.CloudAssemblyBuild
     const templateFile = `${stack.stackName}.template.json`;
     const template = stack.template ?? DEFAULT_FAKE_TEMPLATE;
     fs.writeFileSync(path.join(builder.outdir, templateFile), JSON.stringify(template, undefined, 2));
+    addNestedStacks(templateFile, builder.outdir, template);
 
     // we call patchStackTags here to simulate the tags formatter
     // that is used when building real manifest files.
@@ -84,6 +85,25 @@ function addAttributes(assembly: TestAssembly, builder: cxapi.CloudAssemblyBuild
   }
 }
 
+function addNestedStacks(templatePath: string, outdir: string, rootStackTemplate?: any) {
+  let template = rootStackTemplate;
+
+  if (!template) {
+    const templatePathWithDir = path.join('diff-nested-stacks-templates', templatePath);
+    template = JSON.parse(fs.readFileSync(path.join(__dirname, templatePathWithDir)).toString());
+    fs.writeFileSync(path.join(outdir, templatePath), JSON.stringify(template, undefined, 2));
+  }
+
+  for (const logicalId in template.Resources) {
+    if (template.Resources[logicalId].Type === 'AWS::CloudFormation::Stack') {
+      if (template.Resources[logicalId].Metadata && template.Resources[logicalId].Metadata['aws:asset:path']) {
+        const nestedTemplatePath = template.Resources[logicalId].Metadata['aws:asset:path'];
+        addNestedStacks(nestedTemplatePath, outdir);
+      }
+    }
+  }
+}
+
 export function testAssembly(assembly: TestAssembly): cxapi.CloudAssembly {
   const builder = new cxapi.CloudAssemblyBuilder();
   addAttributes(assembly, builder);