diff --git a/src/pages/gen2/build-a-backend/add-aws-services/rest-api/index.mdx b/src/pages/gen2/build-a-backend/add-aws-services/rest-api/index.mdx
index e467660ab29..f83834482e2 100644
--- a/src/pages/gen2/build-a-backend/add-aws-services/rest-api/index.mdx
+++ b/src/pages/gen2/build-a-backend/add-aws-services/rest-api/index.mdx
@@ -40,8 +40,8 @@ export const handler: APIGatewayProxyHandlerV2 = async (event) => {
 Lets create API Gateway REST API with AWS Lambda proxy integration using AWS CDK and add the function.
 
 ```ts title="amplify/backend.ts"
-import { myFunction } from "./functions/my-function/resource";
 import { LambdaRestApi } from "aws-cdk-lib/aws-apigateway";
+import { myFunction } from "./functions/my-function/resource";
 
 const backend = defineBackend({
   auth, 
@@ -73,8 +73,8 @@ To initialize the REST API you need to configure Amplify with `Amplify.configure
 
 ```tsx title="pages/index.tsx"
 import { Amplify } from 'aws-amplify';
-import amplifyconfig from './src/amplifyconfiguration.json';
-Amplify.configure(amplifyconfig):
+import outputs from '../amplify_outputs.json';
+Amplify.configure(outputs):
 
 const existingConfig = Amplify.getConfig();
 
diff --git a/src/pages/gen2/build-a-backend/auth/set-up-auth/index.mdx b/src/pages/gen2/build-a-backend/auth/set-up-auth/index.mdx
index 11cacf6e8fc..2e06b723957 100644
--- a/src/pages/gen2/build-a-backend/auth/set-up-auth/index.mdx
+++ b/src/pages/gen2/build-a-backend/auth/set-up-auth/index.mdx
@@ -118,7 +118,7 @@ After you have chosen and set up your authentication resource, run the following
 npx amplify sandbox
 ```
 
-After a successful deployment, this command also generates a configuration file (`amplifyconfiguration.json`) to enable your frontend app to connect to your backend resources. The values you configure in your backend authentication resource are set in the generated configuration file to automatically configure the frontend [`Authenticator connected component`](https://ui.docs.amplify.aws/react/connected-components/authenticator).
+After a successful deployment, this command also generates an outputs file (`amplify_outputs.json`) to enable your frontend app to connect to your backend resources. The values you configure in your backend authentication resource are set in the generated outputs file to automatically configure the frontend [`Authenticator connected component`](https://ui.docs.amplify.aws/react/connected-components/authenticator).
 
 ## Connect your application code to the auth backend
 
@@ -151,11 +151,11 @@ A higher-order component (HOC) is a function that takes a component and returns
 import type { AppProps } from "next/app";
 import { withAuthenticator } from '@aws-amplify/ui-react';
 import { Amplify } from 'aws-amplify';
-import config from '@/amplifyconfiguration.json';
+import outputs from '@/amplify_outputs.json';
 import '@aws-amplify/ui-react/styles.css';
 import type { WithAuthenticatorProps } from '@aws-amplify/ui-react';
 
-Amplify.configure(config);
+Amplify.configure(outputs);
 
 function App({ signOut, user, Component, pageProps }: WithAuthenticatorProps & AppProps) {
   return (
@@ -177,10 +177,10 @@ export default withAuthenticator(App);
 // pages/_app.js
 import { withAuthenticator } from '@aws-amplify/ui-react';
 import { Amplify } from 'aws-amplify';
-import config from '@/amplifyconfiguration.json';
+import outputs from '@/amplify_outputs.json';
 import '@aws-amplify/ui-react/styles.css';
 
-Amplify.configure(config);
+Amplify.configure(outputs);
 
 function App({ signOut, user }) {
   return (
@@ -218,9 +218,9 @@ The `Authenticator` component offers a simple way to add authentication flows in
   import "@aws-amplify/ui-vue/styles.css";
 
   import { Amplify } from 'aws-amplify';
-  import config from '../amplifyconfiguration.json';
+  import outputs from '../amplify_outputs.json';
 
-  Amplify.configure(config);
+  Amplify.configure(outputs);
 </script>
 
 <template>
@@ -293,9 +293,9 @@ import { BrowserModule } from '@angular/platform-browser';
 import { AmplifyAuthenticatorModule } from '@aws-amplify/ui-angular';
 
 import { AppComponent } from './app.component';
-import config from './amplifyconfiguration.json';
+import outputs from './amplify_outputs.json';
 
-Amplify.configure(config);
+Amplify.configure(outputs);
 
 @NgModule({
   declarations: [AppComponent],
diff --git a/src/pages/gen2/build-a-backend/data/connect-from-server-runtime/index.mdx b/src/pages/gen2/build-a-backend/data/connect-from-server-runtime/index.mdx
index 58fd3b54006..2e26c7b3f55 100644
--- a/src/pages/gen2/build-a-backend/data/connect-from-server-runtime/index.mdx
+++ b/src/pages/gen2/build-a-backend/data/connect-from-server-runtime/index.mdx
@@ -71,11 +71,11 @@ To generate a Data client for the Next.js server runtime using cookies, you need
 ```ts
 import { type Schema } from '@/amplify/data/resource';
 import { generateServerClientUsingCookies } from '@aws-amplify/adapter-nextjs/data';
-import amplifyConfig from '@/amplifyconfiguration.json';
+import outputs from '@/amplify_outputs.json';
 import { cookies } from 'next/headers';
 
 export const cookieBasedClient = generateServerClientUsingCookies<Schema>({
-  config: amplifyConfig,
+  config: outputs,
   cookies,
 });
 ```
@@ -96,14 +96,14 @@ To generate a Data client for the Next.js server runtime using `NextRequest` and
 import { type Schema } from '@/amplify/data/resource';
 import { createServerRunner } from '@aws-amplify/adapter-nextjs';
 import { generateServerClientUsingReqRes } from '@aws-amplify/adapter-nextjs/data';
-import amplifyConfig from '@/amplifyconfiguration.json';
+import outputs from '@/amplify_outputs.json';
 
 export const { runWithAmplifyServerContext } = createServerRunner({
-  config: amplifyConfig,
+  config: outputs,
 });
 
 export const reqResBasedClient = generateServerClientUsingReqRes<Schema>({
-  config: amplifyConfig,
+  config: outputs,
 });
 ```
 
@@ -130,11 +130,11 @@ Import the cookie-based server Data client in your Next.js React Server Componen
 ```ts
 import { type Schema } from '@/amplify/data/resource';
 import { generateServerClientUsingCookies } from '@aws-amplify/adapter-nextjs/data';
-import amplifyConfig from '@/amplifyconfiguration.json';
+import outputs from '@/amplify_outputs.json';
 import { cookies } from 'next/headers';
 
 export const cookieBasedClient = generateServerClientUsingCookies<Schema>({
-  config: amplifyConfig,
+  config: outputs,
   cookies,
 });
 
diff --git a/src/pages/gen2/build-a-backend/data/connect-to-API/index.mdx b/src/pages/gen2/build-a-backend/data/connect-to-API/index.mdx
index 2f3ff476064..954cd098d84 100644
--- a/src/pages/gen2/build-a-backend/data/connect-to-API/index.mdx
+++ b/src/pages/gen2/build-a-backend/data/connect-to-API/index.mdx
@@ -32,13 +32,13 @@ npm add aws-amplify
 
 You will then configure the library to connect with your Amplify Data's backend API:
 
-When you deploy you're iterating on your backend (`npx amplify sandbox`), an `amplifyconfiguration.json` file is generated for you. This file contains your API's endpoint information and auth configurations. Add the following code to your app's entrypoint to initialize and configure the Amplify client library:
+When you deploy you're iterating on your backend (`npx amplify sandbox`), an `amplify_outputs.json` file is generated for you. This file contains your API's endpoint information and auth configurations. Add the following code to your app's entrypoint to initialize and configure the Amplify client library:
 
 ```ts
 import { Amplify } from 'aws-amplify';
-import config from '../amplifyconfiguration.json';
+import outputs from '../amplify_outputs.json';
 
-Amplify.configure(config);
+Amplify.configure(outputs);
 ```
 
 ## Generate the Amplify Data client
@@ -60,7 +60,7 @@ const fetchTodos = async () => {
 
 ## Configure authorization mode
 
-The **Authorization Mode** is determines how a request should be authorized with the backend. By default, Amplify Data uses the "userPool" authorization which uses the signed-in user credentials to sign an API request. If you use public authorization rules for you data models, you need to use "apiKey" an an authorization mode. Review [Customize your auth rules](/gen2/build-a-backend/data/customize-authz) to learn more about which authorization modes to choose for which type of request. A **Default Authorization Mode** is provided as part of the **amplifyconfiguration.json** that is generated upon a successful deployment.
+The **Authorization Mode** is determines how a request should be authorized with the backend. By default, Amplify Data uses the "userPool" authorization which uses the signed-in user credentials to sign an API request. If you use public authorization rules for you data models, you need to use "apiKey" an an authorization mode. Review [Customize your auth rules](/gen2/build-a-backend/data/customize-authz) to learn more about which authorization modes to choose for which type of request. A **Default Authorization Mode** is provided as part of the **amplify_outputs.json** that is generated upon a successful deployment.
 
 You can generate different Data clients with different authorization modes or pass in the authorization mode at the request time.
 
diff --git a/src/pages/gen2/build-a-backend/data/customize-authz/grant-lambda-function-access-to-api/index.mdx b/src/pages/gen2/build-a-backend/data/customize-authz/grant-lambda-function-access-to-api/index.mdx
index fe27464ab15..53b55cdefe0 100644
--- a/src/pages/gen2/build-a-backend/data/customize-authz/grant-lambda-function-access-to-api/index.mdx
+++ b/src/pages/gen2/build-a-backend/data/customize-authz/grant-lambda-function-access-to-api/index.mdx
@@ -85,7 +85,7 @@ import { Schema } from '../data/resource';
 import { env } from '@env/<data-access>'; // replace with your function name
 // highlight-start
 // see instructions below on copying this file
-import { modelIntrospection } from './amplifyconfiguration.json';
+import { modelIntrospection } from './amplify_outputs.json';
 // highlight-end
 
 Amplify.configure(
@@ -124,11 +124,11 @@ export const handler = async (event) => {
 }
 ```
 
-The `amplifyconfiguration.json` file is not automatically accessible to your function. To include it with your function, you must first do a deployment of your backend using either `npx amplify sandbox` or Amplify hosting. Then copy the `amplifyconfiguration.json` file that is placed in your project root into your function directory. Now you can import the file into your function as shown above.
+The `amplify_outputs.json` file is not automatically accessible to your function. To include it with your function, you must first do a deployment of your backend using either `npx amplify sandbox` or Amplify hosting. Then copy the `amplify_outputs.json` file that is placed in your project root into your function directory. Now you can import the file into your function as shown above.
 
 <Callout warning>
 
-**Note:** Whenever you update your data model, you will need to copy the `amplifyconfiguration.json` file again.
+**Note:** Whenever you update your data model, you will need to copy the `amplify_outputs.json` file again.
 
 </Callout>
 
diff --git a/src/pages/gen2/build-a-backend/data/customize-authz/public-data-access/index.mdx b/src/pages/gen2/build-a-backend/data/customize-authz/public-data-access/index.mdx
index aa1f6aa4a1e..a084d7c2a9d 100644
--- a/src/pages/gen2/build-a-backend/data/customize-authz/public-data-access/index.mdx
+++ b/src/pages/gen2/build-a-backend/data/customize-authz/public-data-access/index.mdx
@@ -64,16 +64,16 @@ const schema = a.schema({
 In your application, you can perform CRUD operations against the model using `client.models.<model-name>` with the `iam` auth mode.
 
 <Callout info>
-If you're not using the auto-generated **amplifyconfiguration.json** file, then you must set the Amplify Library resource configuration's `allowGuestAccess` flag to `true`. This lets the Amplify Library use the unauthenticated role from your Cognito identity pool when your user isn't logged in.
+If you're not using the auto-generated **amplify_outputs.json** file, then you must set the Amplify Library resource configuration's `allowGuestAccess` flag to `true`. This lets the Amplify Library use the unauthenticated role from your Cognito identity pool when your user isn't logged in.
 
 <Accordion title="Amplify configuration">
 ```ts title="src/App.tsx"
 import { Amplify } from "aws-amplify";
-import config from "../amplifyconfiguration.json";
+import outputs from "../amplify_outputs.json";
 
 Amplify.configure(
   {
-    ...config,
+    ...outputs,
     Auth: {
       Cognito: {
         identityPoolId: config.aws_cognito_identity_pool_id,
diff --git a/src/pages/gen2/build-a-backend/data/set-up-data/index.mdx b/src/pages/gen2/build-a-backend/data/set-up-data/index.mdx
index 16bda122d13..49baa001cc3 100644
--- a/src/pages/gen2/build-a-backend/data/set-up-data/index.mdx
+++ b/src/pages/gen2/build-a-backend/data/set-up-data/index.mdx
@@ -70,11 +70,11 @@ npx amplify sandbox
 
 ## Connect your application code to the data backend
 
-Once the cloud sandbox is up and running, it will also create an `amplifyconfiguration.json` file, which includes the relevant connection information to your data backend, like your API endpoint URL and API key.
+Once the cloud sandbox is up and running, it will also create an `amplify_outputs.json` file, which includes the relevant connection information to your data backend, like your API endpoint URL and API key.
 
 To connect your frontend code to your backend, you need to:
 
-1. configure the Amplify library with the Amplify client configuration file
+1. configure the Amplify library with the Amplify client configuration file (`amplify_outputs.json`)
 2. generate a new API client from the Amplify library
 3. make an API request with end-to-end type-safety
 
@@ -84,9 +84,9 @@ In your app's entry point, typically **main.tsx** for React apps created using V
 // main.tsx
 
 import { Amplify } from 'aws-amplify';
-import config from '../amplifyconfiguration.json';
+import outputs from '../amplify_outputs.json';
 
-Amplify.configure(config);
+Amplify.configure(outputs);
 ```
 
 ## Write data to your backend
diff --git a/src/pages/gen2/build-a-backend/server-side-rendering/index.mdx b/src/pages/gen2/build-a-backend/server-side-rendering/index.mdx
index 38959356969..b262e512c4c 100644
--- a/src/pages/gen2/build-a-backend/server-side-rendering/index.mdx
+++ b/src/pages/gen2/build-a-backend/server-side-rendering/index.mdx
@@ -29,16 +29,16 @@ npm add aws-amplify @aws-amplify/adapter-nextjs
 
 You will need to create a `runWithAmplifyServerContextRunner` function to use Amplify APIs on the server-side of your Next.js app.
 
-You can create an `amplifyServerUtils.ts` file under a `utils` folder in your codebase. In this file, you will import the Amplify configuration object from the `amplifyconfiguration.json` file that is generated by the Amplify CLI, and use the `createServerRunner` function to create the `runWithAmplifyServerContextRunner` function.
+You can create an `amplifyServerUtils.ts` file under a `utils` folder in your codebase. In this file, you will import the Amplify backend outputs from the `amplify_outputs.json` file that is generated by the Amplify CLI, and use the `createServerRunner` function to create the `runWithAmplifyServerContextRunner` function.
 
 For example, the `utils/amplifyServerUtils.ts` file may contain the following content:
 
 ```typescript
 import { createServerRunner } from '@aws-amplify/adapter-nextjs';
-import config from '@/amplifyconfiguration.json';
+import outputs from '@/amplify_outputs.json';
 
 export const { runWithAmplifyServerContext } = createServerRunner({
-  config
+  outputs
 });
 ```
 
@@ -61,10 +61,10 @@ When you use the Amplify library on the client-side of your Next.js app, you wil
 ```typescript
 'use client';
 
-import config from '@/amplifyconfiguration.json';
+import outputs from '@/amplify_outputs.json';
 import { Amplify } from 'aws-amplify';
 
-Amplify.configure(config, {
+Amplify.configure(outputs, {
   ssr: true // required when using Amplify with Next.js
 });
 
@@ -93,9 +93,9 @@ If you're using the Next.js App Router, you can create a client component to con
 'use client';
 
 import { Amplify } from 'aws-amplify';
-import config from '../amplifyconfiguration.json';
+import outputs from '../amplify_outputs.json';
 
-Amplify.configure(config, { ssr: true });
+Amplify.configure(outputs, { ssr: true });
 
 export default function ConfigureAmplifyClientSide() {
   return null;
diff --git a/src/pages/gen2/deploy-and-host/fullstack-branching/cross-account-deployments/index.mdx b/src/pages/gen2/deploy-and-host/fullstack-branching/cross-account-deployments/index.mdx
index f76d0e9df1b..9f400553274 100644
--- a/src/pages/gen2/deploy-and-host/fullstack-branching/cross-account-deployments/index.mdx
+++ b/src/pages/gen2/deploy-and-host/fullstack-branching/cross-account-deployments/index.mdx
@@ -36,7 +36,7 @@ Please refer to this Amazon CodeCatalyst [guide](https://docs.aws.amazon.com/cod
 
 ### Step 3: Update build specification
 
-Add the `npx amplify generate config --branch $AWS_BRANCH --app-id $AWS_APP_ID` command to the build spec and comment out the `npx amplify pipeline-deploy --branch $AWS_BRANCH --app-id $AWS_APP_ID` command. `amplify pipeline-deploy` runs a script to deploy backend updates, while `amplify generate config` fetches the latest `amplifyconfiguration.json` for the specified environment.
+Add the `npx amplify generate config --branch $AWS_BRANCH --app-id $AWS_APP_ID` command to the build spec and comment out the `npx amplify pipeline-deploy --branch $AWS_BRANCH --app-id $AWS_APP_ID` command. `amplify pipeline-deploy` runs a script to deploy backend updates, while `amplify generate config` fetches the latest `amplify_outputs.json` for the specified environment.
 
 ![Screenshot of Build image settings section in AWS Amplify Gen 2 console, with details about the app build specification](images/gen2/cross-account-deployments/pipeline10.png)
 
@@ -166,4 +166,4 @@ Next, you can review the result of the workflow run from the **Runs** tab:
 
 ![Screenshot of CodeCatalyst console showing the Workflows section, focusing on the Runs tab](images/gen2/cross-account-deployments/pipeline11.png)
 
-Done! You have successfully set up a custom cross-account pipeline to deploy your frontend and backend for apps built using Amplify Gen 2. To summarize, this custom pipeline will enable you to deploy your backend initially with your `staging` environment using `amplify pipeline-deploy` in the CodeCatalyst workflow and `amplify generate config` will generate the `amplifyconfiguration.json` file for the `main` branch. Amplify Hosting will not deploy backend resources as part of the build and instead will use the deployed backend resources from the `main` branch. Once the staging environment deploys successfully, a similar process will be followed to deploy your `production` environment in a different AWS account.
+Done! You have successfully set up a custom cross-account pipeline to deploy your frontend and backend for apps built using Amplify Gen 2. To summarize, this custom pipeline will enable you to deploy your backend initially with your `staging` environment using `amplify pipeline-deploy` in the CodeCatalyst workflow and `amplify generate config` will generate the `amplify_outputs.json` file for the `main` branch. Amplify Hosting will not deploy backend resources as part of the build and instead will use the deployed backend resources from the `main` branch. Once the staging environment deploys successfully, a similar process will be followed to deploy your `production` environment in a different AWS account.
diff --git a/src/pages/gen2/deploy-and-host/fullstack-branching/custom-pipelines/index.mdx b/src/pages/gen2/deploy-and-host/fullstack-branching/custom-pipelines/index.mdx
index 71174c3b7b4..325eb886272 100644
--- a/src/pages/gen2/deploy-and-host/fullstack-branching/custom-pipelines/index.mdx
+++ b/src/pages/gen2/deploy-and-host/fullstack-branching/custom-pipelines/index.mdx
@@ -26,7 +26,7 @@ You can set up your backend deployments using the following steps:
   <source src="/images/gen2/fullstack-branching/auto-build.mp4" />
 </video>
 
-3. Update the Amplify build-spec to add `npx amplify generate config --branch $AWS_BRANCH --app-id $AWS_APP_ID` and comment out the `pipeline-deploy` script. `amplify pipeline-deploy` runs a script to deploy backend updates, while `amplify generate config` fetches the latest `amplifyconfiguration.json` for the specified environment.
+3. Update the Amplify build-spec to add `npx amplify generate config --branch $AWS_BRANCH --app-id $AWS_APP_ID` and comment out the `pipeline-deploy` script. `amplify pipeline-deploy` runs a script to deploy backend updates, while `amplify generate config` fetches the latest `amplify_outputs.json` for the specified environment.
 
 ![custom-ci](/images/gen2/fullstack-branching/custom-ci.png)
 
@@ -97,4 +97,4 @@ aws amplify create-webhook --app-id AMPLIFY-APPID --branch-name main  --region R
             -H "Content-Type:application/json"; fi
 ```
 
-4. This should trigger a build in your Amplify app. Amplify CI will build and first generate the `amplifyconfiguration.json` for the branch and then build, deploy, and host the frontend.
+4. This should trigger a build in your Amplify app. Amplify CI will build and first generate the `amplify_outputs.json` for the branch and then build, deploy, and host the frontend.
diff --git a/src/pages/gen2/deploy-and-host/fullstack-branching/mono-and-multi-repos/index.mdx b/src/pages/gen2/deploy-and-host/fullstack-branching/mono-and-multi-repos/index.mdx
index 34813262676..227f2afb654 100644
--- a/src/pages/gen2/deploy-and-host/fullstack-branching/mono-and-multi-repos/index.mdx
+++ b/src/pages/gen2/deploy-and-host/fullstack-branching/mono-and-multi-repos/index.mdx
@@ -49,11 +49,11 @@ npm add @aws-amplify/backend-cli aws-amplify @aws-amplify/ui-react
 npx amplify generate config --branch main --app-id BACKEND-APPID
 ```
 
-This will generate the `amplifyconfiguration.json` file that contains all the information about your backend at the root of your project.
+This will generate the `amplify_outputs.json` file that contains all the information about your backend at the root of your project.
 
 <img
   src="/images/gen2/fullstack-branching/multirepo3.png"
-  alt="Screenshot of project folder contents with amplifyconfiguration.json file highlighted"
+  alt="Screenshot of project folder contents with amplify_outputs.json file highlighted"
   width="300"
 />
 
@@ -63,13 +63,13 @@ This will generate the `amplifyconfiguration.json` file that contains all the in
 // pages/_app.tsx
 import { withAuthenticator } from '@aws-amplify/ui-react';
 import { Amplify } from 'aws-amplify';
-import config from '@/amplifyconfiguration.json';
+import outputs from '@/amplify_outputs.json';
 import '@aws-amplify/ui-react/styles.css';
 import '@/styles/globals.css';
 import type { AppProps } from 'next/app';
 
 // configure the Amplify client library with the configuration generated by `amplify sandbox`
-Amplify.configure(config);
+Amplify.configure(outputs);
 
 function App({ Component, pageProps }: AppProps) {
   return <Component {...pageProps} />;
diff --git a/src/pages/gen2/deploy-and-host/fullstack-branching/share-resources/index.mdx b/src/pages/gen2/deploy-and-host/fullstack-branching/share-resources/index.mdx
index a51e5773db4..3b4365ffda3 100644
--- a/src/pages/gen2/deploy-and-host/fullstack-branching/share-resources/index.mdx
+++ b/src/pages/gen2/deploy-and-host/fullstack-branching/share-resources/index.mdx
@@ -20,7 +20,7 @@ You can update your app build settings to share resources across branches. In th
 
 ![The build specification YML file on the Build settings page in Amplify console.](/images/gen2/fullstack-branching/build-settings.png)
 
-Update the build settings for the `backend` phase to run `npx amplify generate config --branch dev app-id $AWS_APP_ID` to generate the `amplifyconfiguration.json` file for all branches other than `main` or `dev`. After this update, any new deployed branches will not deploy backend resources as part of the build and instead will use the deployed backend resources from the `dev` branch.
+Update the build settings for the `backend` phase to run `npx amplify generate config --branch dev app-id $AWS_APP_ID` to generate the `amplify_outputs.json` file for all branches other than `main` or `dev`. After this update, any new deployed branches will not deploy backend resources as part of the build and instead will use the deployed backend resources from the `dev` branch.
 
 ```yaml title="amplify.yml"
 version: 1
diff --git a/src/pages/gen2/deploy-and-host/sandbox-environments/features/index.mdx b/src/pages/gen2/deploy-and-host/sandbox-environments/features/index.mdx
index 8d57ec06dce..d85d07d98e4 100644
--- a/src/pages/gen2/deploy-and-host/sandbox-environments/features/index.mdx
+++ b/src/pages/gen2/deploy-and-host/sandbox-environments/features/index.mdx
@@ -109,7 +109,7 @@ After successful deployment, sandboxes `s1` and `s2` will be ready. Pick sandbox
 
 ## Generate client config
 
-The client config, or `amplifyconfiguration.json` file, contains the configuration strings for interacting with AWS resources specific to an environment. The Amplify client libraries need the client config in order to use the library APIs to connect to backend resources. By default, the cloud sandbox generates the client configuration file at the root of the project (such as `@/amplifyconfiguration.json`). If you want to place the file at a different path (such as for a monorepo or Android app), run the following command in the terminal:
+The client config, or `amplify_outputs.json` file, contains the configuration strings for interacting with AWS resources specific to an environment. The Amplify client libraries need the client config in order to use the library APIs to connect to backend resources. By default, the cloud sandbox generates the client configuration file at the root of the project (such as `@/amplify_outputs.json`). If you want to place the file at a different path (such as for a monorepo or Android app), run the following command in the terminal:
 
 ```bash
 npx amplify sandbox --config-out-dir ./path/to/config --format ["mjs", "json", "json-mobile", "ts", "dart"]
diff --git a/src/pages/gen2/reference/amplifyconfiguration/index.mdx b/src/pages/gen2/reference/amplifyconfiguration/index.mdx
index 66118ceaae3..c67abd4dbe1 100644
--- a/src/pages/gen2/reference/amplifyconfiguration/index.mdx
+++ b/src/pages/gen2/reference/amplifyconfiguration/index.mdx
@@ -11,7 +11,7 @@ export function getStaticProps(context) {
   };
 }
 
-In Amplify Gen 2, the CLI will generate an `amplifyconfiguration.json` file with a similar structure to the configuration files generated by Amplify Gen 1. Locally, this file is created while using `amplify sandbox`. In Amplify's CI/CD, this is created automatically for you based on the current Amplify app ID and git branch.
+In Amplify Gen 2, the CLI will generate an `amplify_outputs.json` file with a similar structure to the configuration files generated by Amplify Gen 1. Locally, this file is created while using `amplify sandbox`. In Amplify's CI/CD, this is created automatically for you based on the current Amplify app ID and git branch.
 
 You can also manually create this file for a specified Amplify app ID and branch, or an AWS CloudFormation stack name with [`amplify generate config`](/gen2/reference/cli-commands#amplify-generate-config).
 
@@ -19,17 +19,17 @@ You can also manually create this file for a specified Amplify app ID and branch
 
 ## Extending Amplify configuration file
 
-The `amplifyconfiguration.json` file is not just a static artifact; it's designed to be extendable to suit the evolving needs of your application. By leveraging the `addOutput` method from your `backend`, you can programmatically add configurations. This is particularly useful for customizing outputs that are not directly exposed through the Amplify constructs or for dynamically adjusting your app's configuration in response to changes in your backend strategy.
+The `amplify_outputs.json` file is not just a static artifact; it's designed to be extendable to suit the evolving needs of your application. By leveraging the `addOutput` method from your `backend`, you can programmatically add configurations. This is particularly useful for customizing outputs that are not directly exposed through the Amplify constructs or for dynamically adjusting your app's configuration in response to changes in your backend strategy.
 
 <Callout warning>
 
-Overriding Amplify-managed configurations on `amplifyconfiguration.json` is not supported.
+Overriding Amplify-managed configurations on `amplify_outputs.json` is not supported.
 
 </Callout>
 
 One common scenario where extending the configuration becomes handy is when you need to add custom outputs or extend existing configurations without manual file edits.
 
-Consider a scenario where you want to add output parameters in your `amplifyconfiguration.json` that specify an S3 bucket and its region that your application will use for storing files.
+Consider a scenario where you want to add output parameters in your `amplify_outputs.json` that specify an S3 bucket and its region that your application will use for storing files.
 
 ```ts title="amplify/backend.ts"
 import { defineBackend } from "@aws-amplify/backend";
@@ -51,14 +51,14 @@ In your frontend end application, you can configure Amplify as follows:
 
 ```ts title="src/index.ts"
 import { Amplify } from "aws-amplify";
-import config from "@/amplifyconfiguration.json";
+import outputs from "@/amplify_outputs.json";
 
-Amplify.configure(config);
+Amplify.configure(outputs);
 ```
 
 ### Custom configuration
 
-In addition to extending existing configurations, you can also add custom output parameters to your `amplifyconfiguration.json`. This is useful for surfacing arbitrary outputs, values from custom CDK resources, or any other information that might be necessary for your application's logic or configuration.
+In addition to extending existing configurations, you can also add custom output parameters to your `amplify_outputs.json`. This is useful for surfacing arbitrary outputs, values from custom CDK resources, or any other information that might be necessary for your application's logic or configuration.
 
 ```ts title="amplify/backend.ts"
 import { defineBackend } from "@aws-amplify/backend";
@@ -84,9 +84,9 @@ In your frontend end application, you can access these custom configurations as
 
 ```ts title="src/index.ts"
 import { Amplify } from "aws-amplify";
-import config from "@/amplifyconfiguration.json";
+import outputs from "@/amplify_outputs.json";
 
-Amplify.configure(config);
+Amplify.configure(outputs);
 const currentConfig = Amplify.getConfig(); 
 Amplify.configure({
   ...currentConfig,
diff --git a/src/pages/gen2/reference/cli-commands/index.mdx b/src/pages/gen2/reference/cli-commands/index.mdx
index 69e646fad12..a52ca104881 100644
--- a/src/pages/gen2/reference/cli-commands/index.mdx
+++ b/src/pages/gen2/reference/cli-commands/index.mdx
@@ -70,7 +70,7 @@ AWS_REGION=us-west-2 amplify sandbox
 
 #### Use with mobile applications
 
-For mobile applications, you will need to set the output directory and format of the generated configuration file, specifically `amplifyconfiguration.json`:
+For mobile applications, you will need to set the output directory and format of the generated outputs file, specifically `amplify_outputs.json`:
 
 ```bash
 # for Android
@@ -187,7 +187,7 @@ npx amplify generate <subcommand> --app-id <app-id> --branch <git-branch-name>
 
 ## npx amplify generate outputs
 
-Generate the client configuration file (such as `amplifyconfiguration.json`) for your frontend application to consume. This is intended to be used to manually generate a configuration file for an environment other than your personal cloud sandbox. For example, you might use it if you would like to verify something your coworker is seeing in their cloud sandbox, or to demonstrate frontend changes locally using a pre-existing "staging" branch.
+Generate the client configuration file (such as `amplify_outputs.json`) for your frontend application to consume. This is intended to be used to manually generate a client configuration file for an environment other than your personal cloud sandbox. For example, you might use it if you would like to verify something your coworker is seeing in their cloud sandbox, or to demonstrate frontend changes locally using a pre-existing "staging" branch.
 
 <SubCommandHeading parentCommand="amplify-generate-config">Options</SubCommandHeading>
 
@@ -207,7 +207,7 @@ npx amplify generate outputs --stack amplify-nextamplifygen2-josef-sandbox-ca85e
 
 #### Use with mobile applications
 
-Similar to `sandbox`, you can specify an alternate configuration file format by using `--format`:
+Similar to `sandbox`, you can specify an alternate outputs file format by using `--format`:
 
 ```bash
 npx amplify generate outputs --stack amplify-nextamplifygen2-josef-sandbox-ca85e1081b --format json-mobile
diff --git a/src/pages/gen2/start/quickstart/nextjs-app-router-client-components/index.mdx b/src/pages/gen2/start/quickstart/nextjs-app-router-client-components/index.mdx
index 1c1c59cb5a7..05ecd37ed11 100644
--- a/src/pages/gen2/start/quickstart/nextjs-app-router-client-components/index.mdx
+++ b/src/pages/gen2/start/quickstart/nextjs-app-router-client-components/index.mdx
@@ -48,10 +48,10 @@ Next, create a `components` folder in the root of your project and the contents
 // components/ConfigureAmplify.tsx
 "use client";
 
-import config from "@/amplifyconfiguration.json";
+import outputs from "@/amplify_outputs.json";
 import { Amplify } from "aws-amplify";
 
-Amplify.configure(config, { ssr: true });
+Amplify.configure(outputs, { ssr: true });
 
 export default function ConfigureAmplifyClientSide() {
   return null;
diff --git a/src/pages/gen2/start/quickstart/nextjs-app-router-server-components/index.mdx b/src/pages/gen2/start/quickstart/nextjs-app-router-server-components/index.mdx
index 5e41c496df1..7401e378a06 100644
--- a/src/pages/gen2/start/quickstart/nextjs-app-router-server-components/index.mdx
+++ b/src/pages/gen2/start/quickstart/nextjs-app-router-server-components/index.mdx
@@ -51,9 +51,9 @@ Next, create a `components` folder in the root of your project and copy the cont
 
 import { Amplify } from "aws-amplify";
 
-import config from "@/amplifyconfiguration.json";
+import outputs from "@/amplify_outputs.json";
 
-Amplify.configure(config, { ssr: true });
+Amplify.configure(outputs, { ssr: true });
 
 export default function ConfigureAmplifyClientSide() {
   return null;
@@ -113,10 +113,10 @@ import { generateServerClientUsingCookies } from "@aws-amplify/adapter-nextjs/ap
 import { getCurrentUser } from "aws-amplify/auth/server";
 
 import { type Schema } from "@/amplify/data/resource";
-import config from "@/amplifyconfiguration.json";
+import outputs from "@/amplify_outputs.json";
 
 export const { runWithAmplifyServerContext } = createServerRunner({
-  config,
+  outputs,
 });
 
 export const cookiesClient = generateServerClientUsingCookies<Schema>({
diff --git a/src/pages/gen2/start/quickstart/nextjs-pages-router/index.mdx b/src/pages/gen2/start/quickstart/nextjs-pages-router/index.mdx
index 5cf56bf130f..d237e333b6d 100644
--- a/src/pages/gen2/start/quickstart/nextjs-pages-router/index.mdx
+++ b/src/pages/gen2/start/quickstart/nextjs-pages-router/index.mdx
@@ -49,12 +49,12 @@ Next, in your app's `pages/_app.tsx`, add the following imports and wrap your Ap
 // pages/_app.tsx
 import { withAuthenticator } from '@aws-amplify/ui-react';
 import { Amplify } from 'aws-amplify';
-import config from '@/amplifyconfiguration.json';
+import outputs from '@/amplify_outputs.json';
 import '@aws-amplify/ui-react/styles.css';
 import type { AppProps } from 'next/app';
 
 // configure the Amplify client library with the configuration generated by `amplify sandbox`
-Amplify.configure(config);
+Amplify.configure(outputs);
 
 function App({ Component, pageProps }: AppProps) {
   return <Component {...pageProps} />;
diff --git a/src/pages/gen2/start/quickstart/vite-react-app/index.mdx b/src/pages/gen2/start/quickstart/vite-react-app/index.mdx
index 1db9dc736d2..a660262afd7 100644
--- a/src/pages/gen2/start/quickstart/vite-react-app/index.mdx
+++ b/src/pages/gen2/start/quickstart/vite-react-app/index.mdx
@@ -109,9 +109,9 @@ Open `src/main.tsx` and add the following code below the last import:
 
 ```tsx title="src/main.tsx"
 import { Amplify } from 'aws-amplify';
-import amplifyconfig from '../amplifyconfiguration.json';
+import outputs from '../amplify_outputs.json';
 
-Amplify.configure(amplifyconfig);
+Amplify.configure(outputs);
 ```
 
 Update the `src/App.tsx` file with the following code to import Amplify UI and wrap your app in the `withAuthenticator` function: