diff --git a/src/content/docs/accounts/accounts-billing/account-structure/multi-tenancy/delegated-administration.mdx b/src/content/docs/accounts/accounts-billing/account-structure/multi-tenancy/delegated-administration.mdx
new file mode 100644
index 00000000000..73bc4484911
--- /dev/null
+++ b/src/content/docs/accounts/accounts-billing/account-structure/multi-tenancy/delegated-administration.mdx
@@ -0,0 +1,257 @@
+---
+title: "Step 2: Manage users and access"
+metaDescription: "Use the delegated administration options in multi-tenancy to manage user access in other organizations"
+freshnessValidatedDate: 2024-09-05
+---
+
+When setting up multi-tenancy, you can use delegated administration to make user or access management changes within other managed organizations. In the case of managed service providers, delegated administration allows you to manage users and access on behalf of your end customers.
+
+## Requirements [#requirements]
+
+As a reminder, to use the multi-tenancy feature, make sure you've completed the following for your organization:
+
+1. Get Approval: Contact your account representative to confirm your organization has been added to multi-tenancy. Once approved, you receive the multi-tenant entitlement.
+2. Make sure you have correct user types: Users within the managing org that will leverage the above feature set need to be provisioned as either a core or full platform users.
+3. Add users to appropriate group: Users with the core or full platform user type need to be added to a group with `tenant_settings` applied.
+
+
+
+## What can you call in NerdGraph? [#user-calls]
+
+Once you confirm that you meet the requirements for multi-tenancy, you can call our NerdGraph queries and mutations for managing users in managed organizations.
+
+You'll be able to query all `customerAdministration` fields and execute a variety of mutations:
+
+
+
+
+Use this mutation to grant access to a group. To find the `roleID`, see [List roles](#list-roles).
+
+```graphql
+mutation {
+ authorizationManagementGrantAccess(
+ grantAccessOptions: {
+ groupId: "11111111-1111-1111-1111-111111111111"
+ accountAccessGrants: {
+ accountId: YOUR_ACCOUNT_ID
+ roleId: "YOUR_ROLE_ID"
+ }
+ }
+ ) {
+ roles {
+ displayName
+ accountId
+ }
+ }
+}
+```
+
+
+```graphql
+mutation {
+ authorizationManagementRevokeAccess(
+ revokeAccessOptions: {
+ accountAccessGrants: {
+ accountId: YOUR_ACCOUNT_ID
+ roleId: "YOUR_ROLE_ID"
+ }
+ groupId: "YOUR_GROUP_ID"
+ }
+ ) {
+ roles {
+ accountId
+ displayName
+ }
+ }
+}
+```
+
+
+
+```graphql
+mutation {
+ userManagementCreateGroup(
+ createGroupOptions: {
+ authenticationDomainId: "YOUR_AUTH_DOMAIN_ID"
+ displayName: "GROUP_DISPLAY_NAME"
+ }
+ ) {
+ group {
+ displayName
+ id
+ }
+ }
+}
+
+
+ ```
+
+
+```graphql
+mutation {
+ userManagementDeleteGroup(groupOptions: {id: "GROUP_ID_HERE"}) {
+ group {
+ displayName
+ id
+ }
+ }
+}
+```
+
+
+ ```graphql
+mutation {
+ userManagementAddUsersToGroups(addUsersToGroupsOptions: {groupIds: ["II"], userIds: ["3"]}) {
+ groups {
+ id
+ displayName
+ users {
+ totalCount
+ }
+ }
+ }
+}
+```
+
+
+
+
+```graphql
+mutation {
+ userManagementRemoveUsersFromGroups(
+ removeUsersFromGroupsOptions: {
+ groupIds: [YOUR_GROUP_IDS]
+ userIds: [YOUR_USER_IDS]
+ }
+ ) {
+ groups {
+ displayName
+ id
+ }
+ }
+}
+
+```
+
+
+```graphql
+mutation {
+ userManagementUpdateGroup(
+ updateGroupOptions: {
+ id: "YOUR_GROUP_ID"
+ displayName: "NEW_GROUP_DISPLAY_NAME"
+ }
+ ) {
+ group {
+ displayName
+ id
+ }
+ }
+}
+```
+
+
+Use this mutation to create a new user. To find the `authenticationDomainId`, see
+[Query authentication domains](#query-domains).
+
+```graphql
+mutation {
+ userManagementCreateUser(
+ createUserOptions: {
+ authenticationDomainId: "B"
+ email: "a@b.c"
+ name: "A B C"
+ }
+ ) {
+ createdUser {
+ id
+ email
+ name
+ }
+ }
+}
+```
+
+
+```graphql
+mutation {
+ userManagementDeleteUser(deleteUserOptions: {id: "ID_OF_YOUR_USER"}) {
+ deletedUser {
+ id
+ }
+ }
+}
+
+```
+
+
+```graphql
+{
+ customerAdministration {
+ authenticationDomains(filter: {organizationId: {eq: "Y"}}) {
+ items {
+ id
+ name
+ provisioningType
+ authenticationType
+ }
+ }
+ }
+}
+```
+
+
+```graphql
+{
+ customerAdministration {
+ roles(filter: {organizationId: {eq: "ANY_ORG_ID"}}) {
+ items {
+ id
+ name
+ scope
+ type
+ }
+ }
+ }
+}
+```
+
+
+
+
diff --git a/src/content/docs/accounts/accounts-billing/account-structure/multi-tenancy/intro-to-multi-tenancy.mdx b/src/content/docs/accounts/accounts-billing/account-structure/multi-tenancy/intro-to-multi-tenancy.mdx
new file mode 100644
index 00000000000..cea6f3afd60
--- /dev/null
+++ b/src/content/docs/accounts/accounts-billing/account-structure/multi-tenancy/intro-to-multi-tenancy.mdx
@@ -0,0 +1,112 @@
+---
+title: "Introduction to multi-tenancy"
+metaDescription: "The multi-tenancy feature helps you manage multiple organizations and accounts"
+freshnessValidatedDate: 2024-09-05
+---
+
+If your company is composed of more than one business unit, you can use multi-tenancy to model your company structure in New Relic. This feature allows you to set up multiple tenants (organizations) related to a primary, managing organization.
+
+This structure prevents the leakage of personally identifiable information (PII) and sets secure data boundaries between business units or end customers. You'll benefit from these boundaries whether you have a large enterprise company with multiple, independent business units or a managed service provider (MSP) overseeing customer environments.
+
+
+
+ This diagram is a simplified example of an enterprise company with two subsidiaries.
+
+
+When you set up your company in a multi-tenant environment, your managing organization can take advantage of these benefits:
+
+* Consolidated billing: View aggregate billing details across your managed organizations.
+* Managed organization creation: Allows select users within the managing organization to create additional managed organizations. This is useful for MSPs who are onboarding customers or enterprise customers who are acquiring/developing new business units.
+* Account sharing: Allows select users within the managing organization to share an account to a managed organization. This is used mostly for collaborative use cases, such as managed services providers (MSPs) providing direct end customer access to the accounts they're monitoring.
+* Delegated administration: Allows select users within the managing organization to conduct user and access management administration within managed organizations. This feature is commonly used by MSPs who want to do all the administrative work for their managed customers.
+
+
+## Requirements [#requirements]
+
+To use multi-tenancy, you need to complete the following for your organization:
+
+1. Get approval: Contact your account representative to confirm your organization has been added to multi-tenancy. Once approved, you receive the multi-tenant entitlement.
+2. Make sure you have correct user types: Users within the managing org that will leverage the above feature set need to be provisioned as either a core or full platform users.
+3. Add users to a designated group: Users with the core or full platform user type need to be added to a group with `tenant_settings` applied.
+
+
+## Overview of multi-tenancy approaches [#approaches]
+
+You can set up multi-tenancy in a couple of ways: high touch and low-touch. The approach you choose depends on how much control you want your managing organization to have over the managed organizations. You are not limited to a single approach—you can combine the high-touch and low-touch options.
+
+### High touch [#high-touch]
+
+Use this approach if you are a managed services provider (MSP) or an enterprise customer who wants a high degree of control over the managed organizations. This approach is mostly used by MSPs who monitor customer data as it flows through customer accounts. MSPs can offer different degrees of high-touch experiences, depending on what their customers need.
+
+**Example**: Let's say you are an administrator in Betty's MSP that's set as a managing organization. You have two customers, Wayne Enterprises and Acme Widgets, who want you to monitor their data for them. They don't want to handle any administrative tasks and don't need direct access to New Relic. To set this up, you create accounts in Betty's MSP that correspond to Wayne Enterprises and Acme Widgets, and you monitor their telemetry in these accounts for them:
+
+
+
+Later, users at Wayne Enterprises and Acme Widgets decide they want a more hands-on understanding of what's happening in the accounts you're monitoring for them. To solve this, you create organizations for Wayne Enterprises and Acme Widgets. You then share the accounts from Betty's MSP to their new corresponding organizations. Finally, you provision users in their respective organizations so they can see their data:
+
+
+
+To create a structure like the one in the diagram above where Wayne Enterprises and Acme want to see their data, you'll make a series of NerdGraph API calls. You can use the steps below as a recipe for modeling your high-touch organization structure:
+
+1. [Create accounts and organizations](/docs/accounts/accounts-billing/account-structure/multi-tenancy/org-creation): As an administrator in Betty's MSP, execute a few mutations to create accounts and organizations.
+ * Create accounts for Wayne Enterprises and Acme Widgets in Betty's MSP organization by running the `accountManagementCreateAccount` mutation (you'll eventually share these accounts with their corresponding organizations).
+ * Create the organizations Wayne Enterprises and Acme Widgets by running the `createOrganization` mutation, making sure to pass in the accounts you wanted to share from Betty's MSP:
+ * As a byproduct of the organization creation calls, Wayne Enterprises and Acme Widgets will have their own default groups and roles created. (If you need more details about groups and roles, see our public docs site.)
+ * Since you specified the accounts to share, the Wayne Enterprises account is shared with the new Wayne Enterprises organization. Also, the Acme Widgets account is shared with the new Acme Widgets organization.
+ * We automatically set up access grants from the default groups against the shared accounts as part of the organization creation process.
+2. [Manage users and access](/docs/accounts/accounts-billing/account-structure/multi-tenancy/delegated-administration): Execute the `userManagementAddUsersToGroups` mutation to provision users into the default groups of Wayne Enterprises and Acme Widgets.
+3. [Account sharing](/docs/accounts/accounts-billing/account-structure/multi-tenancy/share-accounts): Later, if you decide to make account sharing changes, use these mutations to revoke or add new shared accounts.
+
+
+ Once this structure is complete and the managed organizations start using the New Relic platform, aggregate usage is visible to you in Betty's MSP for consolidated billing.
+
+
+When you're ready to create your first high-touch organizations, go to [Step 1: Create accounts and organizations](/docs/accounts/accounts-billing/account-structure/multi-tenancy/org-creation).
+
+## Low touch [#low-touch]
+
+If you're in an enterprise organization that has subsidiaries that run independently with little oversight, this is a good approach to model your organization in New Relic. With this structure, administrators in each organization handle their managed organizations' user and access management. Note that you will still have consolidated billing as part of your multi-tenant environment.
+
+**Example**: Let's say you are an administrator in Clothing Holding Company that is set as the managing organization and want to set up two subsidiaries (Martha's Shoes and Rick's Outerwear). You create the two managed organizations which then allows the administrators of Martha's Shoes and Rick's Outerwear to independently manage their own accounts, groups, and users:
+
+
+
+To create a structure like the one in the diagram above, you'll make a series of NerdGraph API calls. You can use the example below as a recipe for modeling your low-touch organization structure.
+
+1. [Create accounts and organizations](/docs/accounts/accounts-billing/account-structure/multi-tenancy/org-creation): As an administrator of Clothing Holding Company, create the organizations and accounts for Martha's Shoes and Rick's Outerwear by running the `createOrganization` mutation.
+ * As a byproduct of the organization creation calls, Martha's Shoes and Rick's Outerwear will have their own default groups and roles created.
+ * As part of the organization creation process, Clothing Holding Company sets up the initial account for both managed organizations.
+2. [Manage users and access](/docs/accounts/accounts-billing/account-structure/multi-tenancy/delegated-administration): Execute some mutations to provision the first admin users.
+ * This provisions users into the managed organization's `admin` group.
+ * Since this group has organization management settings enabled, users in this group can conduct user and account management themselves.
+
+When you're ready to create your first low-touch organizations, go to [Step 1: Create accounts and organizations](/docs/accounts/accounts-billing/account-structure/multi-tenancy/org-creation).
+
+## What's next? [#what-next]
+
+If you haven't yet followed the links to the other docs listed in the recipes above, here's a bird's eye view of what you'll be doing to set up your organizations. Use these links to move sequentially between the steps.
+
+ Create accounts and organizations
+ Manage users and access
+ Share accounts (optional)
+
diff --git a/src/content/docs/accounts/accounts-billing/account-structure/multi-tenancy/org-creation.mdx b/src/content/docs/accounts/accounts-billing/account-structure/multi-tenancy/org-creation.mdx
new file mode 100644
index 00000000000..33dd6caefb3
--- /dev/null
+++ b/src/content/docs/accounts/accounts-billing/account-structure/multi-tenancy/org-creation.mdx
@@ -0,0 +1,152 @@
+---
+title: "Step 1: Create accounts and organizations"
+metaDescription: "Create organizations and accounts in the multi-tenency structure"
+freshnessValidatedDate: 2024-09-05
+---
+
+
+Multi-tenancy allows you to set up any number of managed organizations in New Relic that are related to a primary, managing organization. The first step in setting up multi-tenancy is to create accounts and organizations. To do this, you'll use various NerdGraph mutations, depending on the organization structure you're creating:
+
+* [High touch](#high-touch): Managed service providers typically use this approach to onboard customers who want to access New Relic directly.
+
+* [Low touch](#low-touch): Enterprise businesses use this approach to create new organizations and accounts for business units or subsidiaries in New Relic.
+
+Not sure which approach to take? See [Overview of multi-tenancy approaches](/docs/accounts/accounts-billing/account-structure/multi-tenancy/intro-to-multi-tenancy#approaches).
+
+
+ If you are a multi-tenant customer on consumption pricing, ingest and user counts will be aggregated across your managed organizations. This aggregate data is visible only to the managing organization.
+
+
+## Requirements [#requirements]
+
+As a reminder, to use the multi-tenancy feature, make sure you've completed the following for your organization:
+
+1. Get approval: Contact your account representative to confirm your organization has been added to multi-tenancy. Once approved, you receive the multi-tenant entitlement.
+2. Make sure you have correct user types: Users within the managing org that will leverage the above feature set need to be provisioned as either a core or full platform users.
+3. Add users to appropriate group: Users with the core or full platform user type need to be added to a group with `tenant_settings` applied.
+
+## What can you call in NerdGraph? [#org-calls]
+
+Find the mutations below that apply to the approach you want to take: low touch or high touch.
+
+### High touch structure [#high-touch]
+
+If you're an administrator in a managed service provider or an enterprise who wants a lot of control over subsidiaries, complete the following:
+
+
+
+
+A key benefit in the high-touch approach is that you can create customer accounts right in your own managing organization. These accounts in your managing organiztion allow you to monitor the telemetry of your customers.
+
+Then, if your customers decide they want to see the data in the account you're monitoring for them, you can share the account when you create an organization for them. Users in your managed organizations can only see the data in the accounts you specify.
+
+To create accounts that you plan to share with managed organizations, execute the following mutation:
+
+```graphql
+mutation {
+ accountManagementCreateAccount(
+ managedAccount: { name: "NEW_ACCOUNT_NAME", regionCode: "eu01" }
+ ) {
+ managedAccount {
+ id
+ name
+ regionCode
+ }
+ }
+}
+```
+
+If you make a mistake and need to rename your account, see our [NerdGraph tutorial](/docs/apis/nerdgraph/examples/manage-accounts-nerdgraph/#rename-accounts).
+
+Once you create the accounts you want to share, you're ready to create organizations.
+
+
+
+When you create an organization in a high-touch structure, you will often want to share an account you're managing in your own organization with the users of a managed organization. To create an organization and share an account at the same time, run a mutation similar to this:
+
+
+```graphql
+mutation {
+ createOrganization(
+ customerId: "CC-1234567890",
+ organization!: {name!: "New Customer Organization Name"},
+ sharedAccount: {accountId!: 1234567, limitingRoleId: 325}
+ ) {
+ jobId
+ }
+}
+```
+If you don't initially want to share an account with a managed organization, you can always use the `organizationCreateSharedAccount` mutation later. For details about how to use that mutation, see [Step 3: Share accounts](/docs/accounts/accounts-billing/account-structure/multi-tenancy/share-accounts).
+
+
+
+### Low-touch structure [#low-touch]
+
+ If you're an administrator in an enterprise organization who doesn't need much control over subsidiaries, you can create a managed organization and managed account in a single call:
+
+
+
+This mutation creates an organization and a new managed account:
+
+```graphql
+mutation {
+ createOrganization(
+ customerId: "CC-1234567890",
+ organization!: {name!: "New Customer Organization Name"},
+ newManagedAccount: {name: "New Managed Account Name", regionCode: "eu01"},
+ ) {
+ jobId
+ }
+}
+```
+
+
+
+
+### Query your organizations [#org-queries]
+
+Use the following query to keep track of your managed organizations:
+
+
+
+```graphql
+{
+ customerAdministration {
+ organizations {
+ items {
+ id
+ name
+ }
+ nextCursor
+ }
+ }
+}
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/content/docs/accounts/accounts-billing/account-structure/multi-tenancy/share-accounts.mdx b/src/content/docs/accounts/accounts-billing/account-structure/multi-tenancy/share-accounts.mdx
new file mode 100644
index 00000000000..60d9e3c51ab
--- /dev/null
+++ b/src/content/docs/accounts/accounts-billing/account-structure/multi-tenancy/share-accounts.mdx
@@ -0,0 +1,213 @@
+---
+title: "Step 3: Share accounts (optional)"
+metaDescription: "Share accounts with managed organizations using multi-tenency"
+freshnessValidatedDate: 2024-09-05
+---
+
+
+ If you've set up a low-touch organization structure, this step doesn't apply to you. See the low-touch details in [Step 1: Create accounts and organizations](/docs/accounts/accounts-billing/account-structure/multi-tenancy/org-creation).
+
+
+Account sharing makes it possible for administrators in a managing organization to make the data they are monitoring visible to their managed organizations. After you've set up the initial account sharing in your high-touch organization structure (see [Create accounts and organizations](/docs/accounts/accounts-billing/account-structure/multi-tenancy/org-creation)), you may find it necessary to make some follow-up changes.
+
+Let's say you're an administrator in Betty's MSP (a managed service provider) who's monitoring a managed account for your customer Wayne Enterprises. You've also shared that account with the Wayne Enterprises organization. Here are some follow-up tasks you could perform:
+
+
+
+ If your customer Wayne Enterprises decides they want another account, here's what you'd do:
+ 1. Create another Wayne Enterprises account in your managing organization using the NerdGraph mutation `accountManagementCreateAccount`.
+ 2. If Wayne Enterprises also wants to see the data in the new account directly, you'd share that account with their organization using `organizationCreateSharedAccount`.
+
+
+ If you decide there is no longer a need to share an account with your customer Wayne Enterprises, you can revoke the share with the mutation `organizationRevokeSharedAccount`.
+
+
+ If you need to change the user roles for any of the Wayne Enterprises shared accounts, you can use the mutation `organizationUpdateSharedAccount`.
+
+
+
+## Requirements [#requirements]
+
+To use this feature, make sure you've completed the following for your organization:
+
+1. Get Approval: Contact your account representative to confirm your organization has been added to multi-tenancy. Once approved, you receive the multi-tenant entitlement.
+2. Make sure you have correct user types: Users within the managing org that will leverage the above feature set need to be provisioned as either a core or full platform users.
+3. Add users to appropriate group: Users with the core or full platform user type need to be added to a group with `tenant_settings` applied.
+
+## What can you call in Nerdgraph? [#share-calls]
+
+To help you get acquainted with account sharing, we have some basic examples below. First, take a look at the general routine:
+
+1. The source organization obtains the organization ID from the target organization. You can get the target organization ID from target organization users when they view their **Access Management** tab.
+2. The source organization calls the API and passes the target organization ID, account ID, and limiting role. The source organization can declare a limiting role which defines the maximum capabilities users from the target organization will be restricted to.
+
+Here are the types of calls you can make for account sharing:
+
+
+
+To use this mutation, you should have already created the target organization. If that isn't in place yet, check out [Step 1: Create accounts and organizations](/docs/accounts/accounts-billing/account-structure/multi-tenancy/org-creation).
+
+```graphql
+mutation {
+ organizationCreateSharedAccount(
+ sharedAccount: {
+ accountId: ACCOUNT_ID_TO_SHARE
+ limitingRoleId: 0
+ targetOrganizationId: "CUSTOMER_ORGANIZATION_ID_HERE"
+ }
+ ) {
+ sharedAccount {
+ accountId
+ id
+ limitingRoleId
+ name
+ }
+ }
+}
+```
+
+
+```graphql
+mutation {
+ organizationRevokeSharedAccount(
+ sharedAccount: { id: "SHARED_ACCOUNT_ID_HERE" }
+ ) {
+ sharedAccount {
+ accountId
+ id
+ limitingRoleId
+ name
+ sourceOrganizationId
+ sourceOrganizationName
+ targetOrganizationId
+ targetOrganizationName
+ }
+ }
+}
+```
+
+
+```graphql
+{
+ customerAdministration {
+ accountShares(
+ cursor: ""
+ filter: { accountId: { eq: 1234 } }
+ sort: { direction: ASCENDING, key: ACCOUNT_ID }
+ ) {
+ items {
+ accountId
+ id
+ limitingRole {
+ id
+ }
+ name
+ source {
+ id
+ name
+ }
+ target {
+ id
+ }
+ }
+ }
+ }
+}
+```
+
+
+```graphql
+{
+ customerAdministration {
+ accounts(
+ cursor: "",
+ filter: {
+ id: {eq: 1234},
+ name: {contains: "text"},
+ organizationId: {eq: "org-id"},
+ sharingMode: {eq: SHARED_WITH_THIS_ORGANIZATION},
+ status: {eq: ACTIVE}
+ },
+ sort: {direction: ASCENDING, key: ID}
+ ) {
+ nextCursor
+ }
+ }
+}
+```
+
+
+```graphql
+{
+ customerAdministration {
+ roles(filter: {organizationId: {eq: "ANY_ORG_ID"}}) {
+ items {
+ id
+ name
+ scope
+ type
+ }
+ }
+ }
+}
+```
+
+
+
+Use this mutation to change shared account roles. To find the roles of existing accounts, use the query in [List roles](#list-roles).
+
+```graphql
+mutation {
+ organizationUpdateSharedAccount(
+ sharedAccount: {
+ id: "SHARE_ACCOUNT_ID"
+ limitingRoleId: NEW_LIMTING_ROLE_ID
+ }
+ ) {
+ sharedAccount {
+ accountId
+ id
+ limitingRoleId
+ name
+ sourceOrganizationId
+ sourceOrganizationName
+ targetOrganizationId
+ targetOrganizationName
+ }
+ }
+}
+```
+
+
+
+
+
diff --git a/src/nav/accounts.yml b/src/nav/accounts.yml
index a8beb4fb97f..682346c7d36 100644
--- a/src/nav/accounts.yml
+++ b/src/nav/accounts.yml
@@ -36,6 +36,16 @@ pages:
path: /docs/accounts/accounts-billing/account-structure/add-accounts
- title: Account ID
path: /docs/accounts/accounts-billing/account-structure/account-id
+ - title: Multi-tenancy
+ pages:
+ - title: Introduction
+ path: /docs/accounts/accounts-billing/account-structure/multi-tenancy/intro-to-multi-tenancy
+ - title: Create accounts and organizations
+ path: /docs/accounts/accounts-billing/account-structure/multi-tenancy/org-creation
+ - title: Manage users and access
+ path: /docs/accounts/accounts-billing/account-structure/multi-tenancy/delegated-administration
+ - title: Share accounts
+ path: /docs/accounts/accounts-billing/account-structure/multi-tenancy/share-accounts
- title: Billing and usage
path: /docs/accounts/accounts-billing/new-relic-one-pricing-billing
pages:
diff --git a/static/images/accounts_diagram_high-touch-no-view.webp b/static/images/accounts_diagram_high-touch-no-view.webp
new file mode 100644
index 00000000000..e501c43dc55
Binary files /dev/null and b/static/images/accounts_diagram_high-touch-no-view.webp differ
diff --git a/static/images/accounts_diagram_high-touch-overview.webp b/static/images/accounts_diagram_high-touch-overview.webp
new file mode 100644
index 00000000000..25df432d63e
Binary files /dev/null and b/static/images/accounts_diagram_high-touch-overview.webp differ
diff --git a/static/images/accounts_diagram_low-touch-overview.webp b/static/images/accounts_diagram_low-touch-overview.webp
new file mode 100644
index 00000000000..550e2192487
Binary files /dev/null and b/static/images/accounts_diagram_low-touch-overview.webp differ
diff --git a/static/images/accounts_diagram_multi-tenancy-overview.webp b/static/images/accounts_diagram_multi-tenancy-overview.webp
new file mode 100644
index 00000000000..ee600fd0a02
Binary files /dev/null and b/static/images/accounts_diagram_multi-tenancy-overview.webp differ