diff --git a/src/components/DecisionModal.tsx b/src/components/DecisionModal.tsx
index 77a291c1c2ef..8cf23cb6d2b2 100644
--- a/src/components/DecisionModal.tsx
+++ b/src/components/DecisionModal.tsx
@@ -5,7 +5,8 @@ import CONST from '@src/CONST';
 import Button from './Button';
 import Header from './Header';
 import Modal from './Modal';
-import Text from './Text';
+import RenderHTML from './RenderHTML';
+import ScrollView from './ScrollView';
 
 type DecisionModalProps = {
     /** Title describing purpose of modal */
@@ -20,6 +21,18 @@ type DecisionModalProps = {
     /** Text content used in second button */
     secondOptionText: string;
 
+    /** Whether the first option uses a success-themed button */
+    isFirstOptionSuccess?: boolean;
+
+    /** Whether the second option uses a success-themed button */
+    isSecondOptionSuccess?: boolean;
+
+    /** Whether the first option uses a danger-themed button */
+    isFirstOptionDanger?: boolean;
+
+    /** Whether the second option uses a danger-themed button */
+    isSecondOptionDanger?: boolean;
+
     /** onSubmit callback fired after clicking on first button */
     onFirstOptionSubmit?: () => void;
 
@@ -32,11 +45,29 @@ type DecisionModalProps = {
     /** Callback for closing modal */
     onClose: () => void;
 
+    /** Callback when modal has fully disappeared */
+    onModalHide?: () => void;
+
     /** Whether modal is visible */
     isVisible: boolean;
 };
 
-function DecisionModal({title, prompt = '', firstOptionText, secondOptionText, onFirstOptionSubmit, onSecondOptionSubmit, isSmallScreenWidth, onClose, isVisible}: DecisionModalProps) {
+function DecisionModal({
+    title,
+    prompt = '',
+    firstOptionText,
+    secondOptionText,
+    onFirstOptionSubmit,
+    onSecondOptionSubmit,
+    isSmallScreenWidth,
+    onClose,
+    onModalHide,
+    isVisible,
+    isFirstOptionDanger = false,
+    isFirstOptionSuccess = true,
+    isSecondOptionSuccess = false,
+    isSecondOptionDanger = false,
+}: DecisionModalProps) {
     const styles = useThemeStyles();
 
     return (
@@ -45,21 +76,23 @@ function DecisionModal({title, prompt = '', firstOptionText, secondOptionText, o
             isVisible={isVisible}
             type={isSmallScreenWidth ? CONST.MODAL.MODAL_TYPE.BOTTOM_DOCKED : CONST.MODAL.MODAL_TYPE.CONFIRM}
             innerContainerStyle={styles.pv0}
+            onModalHide={onModalHide}
         >
-            <View style={[styles.m5]}>
+            <ScrollView contentContainerStyle={styles.m5}>
                 <View>
                     <View style={[styles.flexRow, styles.mb5]}>
                         <Header
                             title={title}
-                            containerStyles={[styles.alignItemsCenter]}
+                            containerStyles={styles.alignItemsCenter}
                         />
                     </View>
-                    <Text>{prompt}</Text>
+                    <RenderHTML html={prompt} />
                 </View>
                 {!!firstOptionText && (
                     <Button
-                        success
-                        style={[styles.mt5]}
+                        success={isFirstOptionSuccess}
+                        danger={isFirstOptionDanger}
+                        style={styles.mt5}
                         onPress={onFirstOptionSubmit}
                         pressOnEnter
                         text={firstOptionText}
@@ -70,9 +103,11 @@ function DecisionModal({title, prompt = '', firstOptionText, secondOptionText, o
                     style={[firstOptionText ? styles.mt3 : styles.mt5, styles.noSelect]}
                     onPress={onSecondOptionSubmit}
                     text={secondOptionText}
+                    success={isSecondOptionSuccess}
+                    danger={isSecondOptionDanger}
                     large
                 />
-            </View>
+            </ScrollView>
         </Modal>
     );
 }
diff --git a/src/languages/de.ts b/src/languages/de.ts
index ceba91803195..80d03a82eb5b 100644
--- a/src/languages/de.ts
+++ b/src/languages/de.ts
@@ -8306,7 +8306,14 @@ Hier ist ein *Testbeleg*, um dir zu zeigen, wie es funktioniert:`,
             findMember: 'Mitglied finden',
             addMember: 'Mitglied hinzufügen',
             email: 'E-Mail-Adresse',
-            errors: {
+            closeAccount: 'Konto schließen',
+            closeAccountPrompt: 'Bist du sicher? Diese Aktion ist dauerhaft.',
+            forceCloseAccount: 'Konto zwangsweise schließen',
+            safeCloseAccount: 'Konto sicher schließen',
+            closeAccountInfo:
+                'Wir empfehlen, das Konto sicher zu schließen, um das Schließen zu überspringen, falls Folgendes vorliegt: <ul><li>Ausstehende Genehmigungen</li><li>Aktive Erstattungen</li><li>Keine alternativen Anmeldemethoden</li></ul>Andernfalls können Sie die oben genannten Sicherheitsvorkehrungen ignorieren und das ausgewählte Konto zwangsweise schließen.',
+            error: {
+                removeMember: 'Dieser Benutzer kann nicht entfernt werden. Bitte versuche es erneut.',
                 addMember: 'Dieses Mitglied kann nicht hinzugefügt werden. Bitte versuche es erneut.',
             },
         },
diff --git a/src/languages/en.ts b/src/languages/en.ts
index c5c091039372..f055552c341d 100644
--- a/src/languages/en.ts
+++ b/src/languages/en.ts
@@ -8221,8 +8221,15 @@ const translations = {
             findMember: 'Find member',
             addMember: 'Add member',
             email: 'Email address',
-            errors: {
+            closeAccount: 'Close account',
+            closeAccountPrompt: 'Are you sure? This action is permanent.',
+            forceCloseAccount: 'Force close account',
+            safeCloseAccount: 'Close account safely',
+            closeAccountInfo:
+                'We recommend closing the account safely to skip closing it in case there are: <ul><li>Pending approvals</li><li>Active reimbursements</li><li>No alternative login methods</li></ul>Otherwise, you can ignore the safety precautions above and force close the selected account.',
+            error: {
                 addMember: 'Unable to add this member. Please try again.',
+                removeMember: 'Unable to remove this user. Please try again.',
             },
         },
     },
diff --git a/src/languages/es.ts b/src/languages/es.ts
index 790dcfd88ee1..90f4cad05696 100644
--- a/src/languages/es.ts
+++ b/src/languages/es.ts
@@ -8376,7 +8376,14 @@ ${amount} para ${merchant} - ${date}`,
             findMember: 'Buscar miembro',
             addMember: 'Añadir miembro',
             email: 'Dirección de correo electrónico',
-            errors: {
+            closeAccount: 'Cerrar cuenta',
+            closeAccountPrompt: '¿Estás seguro? Esta acción es permanente.',
+            forceCloseAccount: 'Forzar cierre de cuenta',
+            safeCloseAccount: 'Cierre seguro de cuenta',
+            closeAccountInfo:
+                'Recomendamos cerrar la cuenta de forma segura para omitir el cierre si hay: <ul><li>Aprobaciones pendientes</li><li>Reembolsos en curso</li><li>No hay otro método de inicio de sesión</li></ul>De lo contrario, puedes ignorar las precauciones de seguridad anteriores y forzar el cierre de las cuentas seleccionadas.',
+            error: {
+                removeMember: 'No se pudo eliminar a este usuario. Por favor, inténtalo de nuevo.',
                 addMember: 'No se pudo añadir este miembro. Por favor, inténtalo de nuevo.',
             },
         },
diff --git a/src/languages/fr.ts b/src/languages/fr.ts
index 4c6e483d58d4..96d7ca4b7ba0 100644
--- a/src/languages/fr.ts
+++ b/src/languages/fr.ts
@@ -8320,7 +8320,14 @@ Voici un *reçu test* pour vous montrer comment ça fonctionne :`,
             findMember: 'Trouver un membre',
             addMember: 'Ajouter un membre',
             email: 'Adresse e-mail',
-            errors: {
+            closeAccount: 'Fermer le compte',
+            closeAccountPrompt: 'Êtes-vous sûr(e) ? Cette action est définitive.',
+            forceCloseAccount: 'Forcer la fermeture du compte',
+            safeCloseAccount: 'Fermer le compte en toute sécurité',
+            closeAccountInfo:
+                'Nous recommandons de fermer le compte en toute sécurité afin d’éviter de le fermer dans le cas où il y aurait : <ul><li>Des validations en attente</li><li>Des remboursements actifs</li><li>Aucune autre méthode de connexion</li></ul>Sinon, vous pouvez ignorer les précautions de sécurité ci-dessus et forcer la fermeture du compte sélectionné.',
+            error: {
+                removeMember: 'Impossible de supprimer cet utilisateur. Veuillez réessayer.',
                 addMember: 'Impossible d’ajouter ce membre. Veuillez réessayer.',
             },
         },
diff --git a/src/languages/it.ts b/src/languages/it.ts
index 40016d0dcdee..208a171f1f49 100644
--- a/src/languages/it.ts
+++ b/src/languages/it.ts
@@ -8287,7 +8287,14 @@ Ecco una *ricevuta di prova* per mostrarti come funziona:`,
             findMember: 'Trova membro',
             addMember: 'Aggiungi membro',
             email: 'Indirizzo email',
-            errors: {
+            closeAccount: 'Chiudi account',
+            closeAccountPrompt: 'Sei sicuro? Questa azione è permanente.',
+            forceCloseAccount: 'Forza chiusura account',
+            safeCloseAccount: 'Chiudi il conto in sicurezza',
+            closeAccountInfo:
+                'Consigliamo di chiudere l’account in modo sicuro per evitare problemi in caso di: <ul><li>Approvazioni in sospeso</li><li>Rimborsi attivi</li><li>Nessun metodo di accesso alternativo</li></ul>In caso contrario, puoi ignorare le precauzioni di sicurezza sopra indicate e forzare la chiusura dell’account selezionato.',
+            error: {
+                removeMember: 'Impossibile rimuovere questo utente. Riprova.',
                 addMember: 'Impossibile aggiungere questo membro. Riprova.',
             },
         },
diff --git a/src/languages/ja.ts b/src/languages/ja.ts
index 6c534f1014af..d2ee55bc81f9 100644
--- a/src/languages/ja.ts
+++ b/src/languages/ja.ts
@@ -8218,8 +8218,15 @@ ${reportName}
             findMember: 'メンバーを検索',
             addMember: 'メンバーを追加',
             email: 'メールアドレス',
-            errors: {
-                addMember: 'このメンバーを追加できません。もう一度お試しください。',
+            closeAccount: 'アカウントを閉じる',
+            closeAccountPrompt: '本当によろしいですか？この操作は元に戻せません。',
+            forceCloseAccount: 'アカウントを強制的に閉鎖',
+            safeCloseAccount: 'アカウントを安全に閉じる',
+            closeAccountInfo:
+                '保留中の承認、処理中の精算、代替ログイン方法がない場合などでもアカウントを閉鎖できるように、安全にアカウントを閉鎖することを推奨します: <ul><li>保留中の承認</li><li>進行中の払い戻し</li><li>代替ログイン方法なし</li></ul>それ以外の場合は、上記の安全上の注意を無視して、選択したアカウントを強制的に閉鎖できます。',
+            error: {
+                removeMember: 'このユーザーを削除できません。もう一度お試しください。',
+                addMember: 'このメンバーを追加できませんでした。もう一度お試しください。',
             },
         },
     },
diff --git a/src/languages/nl.ts b/src/languages/nl.ts
index 689dd98a2bde..d920fa997a4f 100644
--- a/src/languages/nl.ts
+++ b/src/languages/nl.ts
@@ -8274,7 +8274,14 @@ Hier is een *proefbon* om je te laten zien hoe het werkt:`,
             findMember: 'Lid zoeken',
             addMember: 'Lid toevoegen',
             email: 'E-mailadres',
-            errors: {
+            closeAccount: 'Account sluiten',
+            closeAccountPrompt: 'Weet je het zeker? Deze actie is permanent.',
+            forceCloseAccount: 'Account geforceerd sluiten',
+            safeCloseAccount: 'Account veilig sluiten',
+            closeAccountInfo:
+                'We raden aan om de account veilig te sluiten om te vermijden dat je deze moet sluiten als er zijn: <ul><li>Openstaande goedkeuringen</li><li>Actieve terugbetalingen</li><li>Geen alternatieve inlogmethoden</li></ul>Anders kun je de bovenstaande veiligheidsmaatregelen negeren en de geselecteerde account geforceerd sluiten.',
+            error: {
+                removeMember: 'Kan deze gebruiker niet verwijderen. Probeer het opnieuw.',
                 addMember: 'Kan dit lid niet toevoegen. Probeer het opnieuw.',
             },
         },
diff --git a/src/languages/pl.ts b/src/languages/pl.ts
index edc0984c2f0f..1880a1a0bf39 100644
--- a/src/languages/pl.ts
+++ b/src/languages/pl.ts
@@ -8254,7 +8254,14 @@ Oto *paragon testowy*, żeby pokazać Ci, jak to działa:`,
             findMember: 'Znajdź członka',
             addMember: 'Dodaj członka',
             email: 'Adres e-mail',
-            errors: {
+            closeAccount: 'Zamknij konto',
+            closeAccountPrompt: 'Czy na pewno? Ta czynność jest nieodwracalna.',
+            forceCloseAccount: 'Wymuś zamknięcie konta',
+            safeCloseAccount: 'Zamknij konto bezpiecznie',
+            closeAccountInfo:
+                'Zalecamy bezpieczne zamknięcie konta, aby pominąć jego zamykanie w przypadku, gdy występują: <ul><li>Oczekujące zatwierdzenia</li><li>Aktywne zwroty kosztów</li><li>Brak alternatywnych metod logowania</li></ul>W przeciwnym razie możesz zignorować powyższe środki ostrożności i wymusić zamknięcie wybranego konta.',
+            error: {
+                removeMember: 'Nie można usunąć tego użytkownika. Spróbuj ponownie.',
                 addMember: 'Nie można dodać tego członka. Spróbuj ponownie.',
             },
         },
diff --git a/src/languages/pt-BR.ts b/src/languages/pt-BR.ts
index 62a696d2c3d8..a184302c7acb 100644
--- a/src/languages/pt-BR.ts
+++ b/src/languages/pt-BR.ts
@@ -8255,7 +8255,14 @@ Aqui está um *comprovante de teste* para mostrar como funciona:`,
             findMember: 'Encontrar membro',
             addMember: 'Adicionar membro',
             email: 'Endereço de e-mail',
-            errors: {
+            closeAccount: 'Encerrar conta',
+            closeAccountPrompt: 'Tem certeza? Esta ação é permanente.',
+            forceCloseAccount: 'Forçar encerramento da conta',
+            safeCloseAccount: 'Fechar conta com segurança',
+            closeAccountInfo:
+                'Recomendamos fechar a conta com segurança para evitar o fechamento caso haja: <ul><li>aprovações pendentes</li><li>reembolsos ativos</li><li>nenhum método de login alternativo</li></ul>Caso contrário, você pode ignorar as precauções de segurança acima e forçar o fechamento da conta selecionada.',
+            error: {
+                removeMember: 'Não foi possível remover este usuário. Tente novamente.',
                 addMember: 'Não foi possível adicionar este membro. Tente novamente.',
             },
         },
diff --git a/src/languages/zh-hans.ts b/src/languages/zh-hans.ts
index 549d32417799..02807e82b42e 100644
--- a/src/languages/zh-hans.ts
+++ b/src/languages/zh-hans.ts
@@ -8096,8 +8096,15 @@ ${reportName}
             title: '成员',
             findMember: '查找成员',
             addMember: '添加成员',
-            email: '邮箱地址',
-            errors: {
+            email: '电子邮箱地址',
+            closeAccount: '关闭账户',
+            closeAccountPrompt: '您确定吗？此操作是永久性的。',
+            forceCloseAccount: '强制关闭账户',
+            safeCloseAccount: '安全关闭账户',
+            closeAccountInfo:
+                '我们建议安全地关闭该账户，以便在存在以下情况时跳过关闭操作：<ul><li>待处理的审批</li><li>正在进行的报销</li><li>没有其他登录方式</li></ul>否则，您可以忽略上述安全预防措施并强制关闭所选账户。',
+            error: {
+                removeMember: '无法移除此用户。请重试。',
                 addMember: '无法添加此成员。请重试。',
             },
         },
diff --git a/src/libs/API/parameters/DeleteDomainMemberParams.ts b/src/libs/API/parameters/DeleteDomainMemberParams.ts
new file mode 100644
index 000000000000..d33c94769bd7
--- /dev/null
+++ b/src/libs/API/parameters/DeleteDomainMemberParams.ts
@@ -0,0 +1,7 @@
+type DeleteDomainMemberParams = {
+    targetEmail: string;
+    domain: string;
+    overrideProcessingReports: boolean;
+};
+
+export default DeleteDomainMemberParams;
diff --git a/src/libs/API/parameters/index.ts b/src/libs/API/parameters/index.ts
index 5cdbc9202dc4..b177eafa1ef9 100644
--- a/src/libs/API/parameters/index.ts
+++ b/src/libs/API/parameters/index.ts
@@ -469,6 +469,7 @@ export type {default as SetPolicyRequireCompanyCardsEnabledParams} from './SetPo
 export type {default as SetTechnicalContactEmailParams} from './SetTechnicalContactEmailParams';
 export type {default as ToggleConsolidatedDomainBillingParams} from './ToggleConsolidatedDomainBillingParams';
 export type {default as RemoveDomainAdminParams} from './RemoveDomainAdminParams';
+export type {default as DeleteDomainMemberParams} from './DeleteDomainMemberParams';
 export type {default as DeleteDomainParams} from './DeleteDomainParams';
 export type {default as GetDuplicateTransactionDetailsParams} from './GetDuplicateTransactionDetailsParams';
 export type {default as SetPolicyCodingRuleParams} from './SetPolicyCodingRuleParams';
diff --git a/src/libs/API/types.ts b/src/libs/API/types.ts
index 4bc6c6027aae..063c11fb04ed 100644
--- a/src/libs/API/types.ts
+++ b/src/libs/API/types.ts
@@ -547,6 +547,7 @@ const WRITE_COMMANDS = {
     ADD_DOMAIN_ADMIN: 'AddDomainAdmin',
     REMOVE_DOMAIN_ADMIN: 'RemoveDomainAdmin',
     DELETE_DOMAIN: 'DeleteDomain',
+    DELETE_DOMAIN_MEMBER: 'DeleteDomainMember',
 } as const;
 
 type WriteCommand = ValueOf<typeof WRITE_COMMANDS>;
@@ -1113,6 +1114,7 @@ type WriteCommandParameters = {
     [WRITE_COMMANDS.SET_TECHNICAL_CONTACT_EMAIL]: Parameters.SetTechnicalContactEmailParams;
     [WRITE_COMMANDS.TOGGLE_CONSOLIDATED_DOMAIN_BILLING]: Parameters.ToggleConsolidatedDomainBillingParams;
     [WRITE_COMMANDS.REMOVE_DOMAIN_ADMIN]: Parameters.RemoveDomainAdminParams;
+    [WRITE_COMMANDS.DELETE_DOMAIN_MEMBER]: Parameters.DeleteDomainMemberParams;
     [WRITE_COMMANDS.DELETE_DOMAIN]: Parameters.DeleteDomainParams;
     [WRITE_COMMANDS.ADD_DOMAIN_ADMIN]: Parameters.AddAdminToDomainParams;
     [WRITE_COMMANDS.ADD_DOMAIN_MEMBER]: Parameters.AddMemberToDomainParams;
diff --git a/src/libs/actions/Domain.ts b/src/libs/actions/Domain.ts
index 016f7474e5b9..c9254533e8b2 100644
--- a/src/libs/actions/Domain.ts
+++ b/src/libs/actions/Domain.ts
@@ -4,6 +4,7 @@ import * as API from '@libs/API';
 import type {
     AddAdminToDomainParams,
     AddMemberToDomainParams,
+    DeleteDomainMemberParams,
     DeleteDomainParams,
     RemoveDomainAdminParams,
     SetTechnicalContactEmailParams,
@@ -14,8 +15,8 @@ import {getMicroSecondOnyxErrorWithTranslationKey} from '@libs/ErrorUtils';
 import {generateAccountID} from '@libs/UserUtils';
 import CONST from '@src/CONST';
 import ONYXKEYS from '@src/ONYXKEYS';
-import type {Domain} from '@src/types/onyx';
-import type {DomainSecurityGroup} from '@src/types/onyx/Domain';
+import type {Domain, DomainSecurityGroup, UserSecurityGroupData} from '@src/types/onyx';
+import type {PendingAction} from '@src/types/onyx/OnyxCommon';
 import type PrefixedRecord from '@src/types/utils/PrefixedRecord';
 import type {ScimTokenWithState} from './ScimToken/ScimTokenUtils';
 import {ScimTokenState} from './ScimToken/ScimTokenUtils';
@@ -780,7 +781,7 @@ function resetDomain(domainAccountID: number, domainName: string, domain: Domain
 }
 
 /**
- * Clears errors after trying to reset domain
+ * Clears domain related errors and pending actions.
  */
 function clearDomainErrors(domainAccountID: number) {
     Onyx.merge(`${ONYXKEYS.COLLECTION.DOMAIN_ERRORS}${domainAccountID}`, {
@@ -791,6 +792,12 @@ function clearDomainErrors(domainAccountID: number) {
     });
 }
 
+/**
+ * Adds a member to a domain
+ * @param domainAccountID Account ID of a domain
+ * @param email Email of a user to be added
+ * @param defaultSecurityGroupID Security group ID to be used for optimistic updates
+ */
 function addMemberToDomain(domainAccountID: number, email: string, defaultSecurityGroupID: string) {
     const DOMAIN_SECURITY_GROUP = `${CONST.DOMAIN.DOMAIN_SECURITY_GROUP_PREFIX}${defaultSecurityGroupID}`;
     const optimisticAccountID = generateAccountID(email);
@@ -892,7 +899,7 @@ function addMemberToDomain(domainAccountID: number, email: string, defaultSecuri
             value: {
                 memberErrors: {
                     [email]: {
-                        errors: getMicroSecondOnyxErrorWithTranslationKey('domain.members.errors.addMember'),
+                        errors: getMicroSecondOnyxErrorWithTranslationKey('domain.members.error.addMember'),
                     },
                 },
             },
@@ -921,9 +928,19 @@ function addMemberToDomain(domainAccountID: number, email: string, defaultSecuri
 /**
  * Removes an error and pending actions after trying to add member. It clears errors for both email and accountID
  */
-function clearAddMemberError(domainAccountID: number, accountID: number, email: string, defaultSecurityGroupID: string) {
+function clearDomainMemberError(domainAccountID: number, accountID: number, email: string, defaultSecurityGroupID: string, pendingAction?: PendingAction) {
     const DOMAIN_SECURITY_GROUP = `${CONST.DOMAIN.DOMAIN_SECURITY_GROUP_PREFIX}${defaultSecurityGroupID}`;
 
+    if (pendingAction === CONST.RED_BRICK_ROAD_PENDING_ACTION.ADD) {
+        Onyx.merge(`${ONYXKEYS.COLLECTION.DOMAIN}${domainAccountID}`, {
+            [DOMAIN_SECURITY_GROUP]: {
+                shared: {
+                    [accountID]: null,
+                },
+            },
+        } as PrefixedRecord<typeof CONST.DOMAIN.DOMAIN_SECURITY_GROUP_PREFIX, Partial<DomainSecurityGroup>>);
+    }
+
     Onyx.merge(`${ONYXKEYS.COLLECTION.DOMAIN_ERRORS}${domainAccountID}`, {
         memberErrors: {
             [email]: null,
@@ -931,13 +948,96 @@ function clearAddMemberError(domainAccountID: number, accountID: number, email:
         },
     });
 
-    Onyx.merge(`${ONYXKEYS.COLLECTION.DOMAIN}${domainAccountID}`, {
-        [DOMAIN_SECURITY_GROUP]: {
-            shared: {
-                [accountID]: null,
+    Onyx.merge(`${ONYXKEYS.COLLECTION.DOMAIN_PENDING_ACTIONS}${domainAccountID}`, {
+        member: {
+            [email]: null,
+            [accountID]: null,
+        },
+    });
+}
+
+/**
+ * Sends a request to remove a user from a domain and close their account
+ * @param domainAccountID Account ID of a domain
+ * @param domain Domain name
+ * @param targetEmail Email of a user to be removed
+ * @param securityGroupsData Data of a security group user is in
+ * @param overrideProcessingReports "Force" flag. If true user will be removed regardless of if they have outstanding reports
+ */
+function closeUserAccount(domainAccountID: number, domain: string, targetEmail: string, securityGroupsData: UserSecurityGroupData, overrideProcessingReports = false) {
+    const optimisticData: OnyxUpdate[] = [
+        {
+            onyxMethod: Onyx.METHOD.MERGE,
+            key: `${ONYXKEYS.COLLECTION.DOMAIN_PENDING_ACTIONS}${domainAccountID}`,
+            value: {
+                member: {[targetEmail]: {pendingAction: CONST.RED_BRICK_ROAD_PENDING_ACTION.DELETE}},
+            },
+        },
+        {
+            onyxMethod: Onyx.METHOD.MERGE,
+            key: `${ONYXKEYS.COLLECTION.DOMAIN_ERRORS}${domainAccountID}`,
+            value: {
+                memberErrors: {
+                    [targetEmail]: null,
+                },
             },
         },
-    } as PrefixedRecord<typeof CONST.DOMAIN.DOMAIN_SECURITY_GROUP_PREFIX, Partial<DomainSecurityGroup>>);
+    ];
+
+    const successData: OnyxUpdate[] = [
+        {
+            onyxMethod: Onyx.METHOD.MERGE,
+            key: `${ONYXKEYS.COLLECTION.DOMAIN_PENDING_ACTIONS}${domainAccountID}`,
+            value: {
+                member: {[targetEmail]: null},
+            },
+        },
+        {
+            onyxMethod: Onyx.METHOD.MERGE,
+            key: `${ONYXKEYS.COLLECTION.DOMAIN_ERRORS}${domainAccountID}`,
+            value: {
+                memberErrors: {
+                    [targetEmail]: null,
+                },
+            },
+        },
+    ];
+
+    const failureData: OnyxUpdate[] = [
+        {
+            onyxMethod: Onyx.METHOD.MERGE,
+            key: `${ONYXKEYS.COLLECTION.DOMAIN_ERRORS}${domainAccountID}`,
+            value: {
+                memberErrors: {
+                    [targetEmail]: {errors: getMicroSecondOnyxErrorWithTranslationKey('domain.members.error.removeMember')},
+                },
+            },
+        },
+        {
+            onyxMethod: Onyx.METHOD.MERGE,
+            key: `${ONYXKEYS.COLLECTION.DOMAIN_PENDING_ACTIONS}${domainAccountID}`,
+            value: {
+                member: {[targetEmail]: null},
+            },
+        },
+        {
+            onyxMethod: Onyx.METHOD.MERGE,
+            key: `${ONYXKEYS.COLLECTION.DOMAIN}${domainAccountID}`,
+            value: (securityGroupsData?.key
+                ? {
+                      [securityGroupsData.key]: securityGroupsData.securityGroup,
+                  }
+                : {}) as PrefixedRecord<typeof CONST.DOMAIN.DOMAIN_SECURITY_GROUP_PREFIX, Partial<DomainSecurityGroup>>,
+        },
+    ];
+
+    const parameters: DeleteDomainMemberParams = {
+        domain,
+        targetEmail,
+        overrideProcessingReports,
+    };
+
+    API.write(WRITE_COMMANDS.DELETE_DOMAIN_MEMBER, parameters, {optimisticData, successData, failureData});
 }
 
 export {
@@ -964,5 +1064,6 @@ export {
     resetDomain,
     clearDomainErrors,
     addMemberToDomain,
-    clearAddMemberError,
+    clearDomainMemberError,
+    closeUserAccount,
 };
diff --git a/src/pages/domain/Admins/DomainAdminDetailsPage.tsx b/src/pages/domain/Admins/DomainAdminDetailsPage.tsx
index 76656a6f6d80..a43d86560efd 100644
--- a/src/pages/domain/Admins/DomainAdminDetailsPage.tsx
+++ b/src/pages/domain/Admins/DomainAdminDetailsPage.tsx
@@ -91,6 +91,4 @@ function DomainAdminDetailsPage({route}: DomainAdminDetailsPageProps) {
     );
 }
 
-DomainAdminDetailsPage.displayName = 'DomainAdminDetailsPage';
-
 export default DomainAdminDetailsPage;
diff --git a/src/pages/domain/BaseDomainMemberDetailsComponent.tsx b/src/pages/domain/BaseDomainMemberDetailsComponent.tsx
index de64be477c5a..fa08d102c6d1 100644
--- a/src/pages/domain/BaseDomainMemberDetailsComponent.tsx
+++ b/src/pages/domain/BaseDomainMemberDetailsComponent.tsx
@@ -31,9 +31,12 @@ type BaseDomainMemberDetailsComponentProps = {
 
     /** List of additional fields (e.g., force 2FA) */
     children?: React.ReactNode;
+
+    /** Button to display below avatar picture */
+    avatarButton?: React.ReactNode;
 };
 
-function BaseDomainMemberDetailsComponent({domainAccountID, accountID, children}: BaseDomainMemberDetailsComponentProps) {
+function BaseDomainMemberDetailsComponent({domainAccountID, accountID, children, avatarButton}: BaseDomainMemberDetailsComponentProps) {
     const styles = useThemeStyles();
     const {translate, formatPhoneNumber} = useLocalize();
     const icons = useMemoizedLazyExpensifyIcons(['Info']);
@@ -83,6 +86,7 @@ function BaseDomainMemberDetailsComponent({domainAccountID, accountID, children}
                                     {displayName}
                                 </Text>
                             )}
+                            {avatarButton}
                         </View>
                         <View style={styles.w100}>
                             <MenuItemWithTopDescription
diff --git a/src/pages/domain/BaseDomainMembersPage.tsx b/src/pages/domain/BaseDomainMembersPage.tsx
index 88a4aa1cdeb6..68ece3cb86bb 100644
--- a/src/pages/domain/BaseDomainMembersPage.tsx
+++ b/src/pages/domain/BaseDomainMembersPage.tsx
@@ -58,7 +58,7 @@ type BaseDomainMembersPageProps = {
     getCustomRightElement?: (accountID: number) => React.ReactNode;
 
     /** Function to return additional row-specific properties like errors or pending actions */
-    getCustomRowProps?: (accountID: number, email?: string) => {errors?: Errors; pendingAction?: PendingAction};
+    getCustomRowProps?: (accountID: number, accountEmail?: string) => {errors?: Errors; pendingAction?: PendingAction};
 
     /** Callback fired when the user dismisses an error message for a specific row */
     onDismissError?: (item: MemberOption) => void;
diff --git a/src/pages/domain/Members/DomainMemberDetailsPage.tsx b/src/pages/domain/Members/DomainMemberDetailsPage.tsx
index d57f13edbc69..549f422ee463 100644
--- a/src/pages/domain/Members/DomainMemberDetailsPage.tsx
+++ b/src/pages/domain/Members/DomainMemberDetailsPage.tsx
@@ -1,22 +1,118 @@
-import React from 'react';
+import {domainNameSelector, selectSecurityGroupForAccount} from '@selectors/Domain';
+import {personalDetailsSelector} from '@selectors/PersonalDetails';
+import React, {useState} from 'react';
+import Button from '@components/Button';
+import DecisionModal from '@components/DecisionModal';
+import {ModalActions} from '@components/Modal/Global/ModalContext';
+import useConfirmModal from '@hooks/useConfirmModal';
+import {useMemoizedLazyExpensifyIcons} from '@hooks/useLazyAsset';
+import useLocalize from '@hooks/useLocalize';
+import useOnyx from '@hooks/useOnyx';
+import useResponsiveLayout from '@hooks/useResponsiveLayout';
+import useThemeStyles from '@hooks/useThemeStyles';
+import {closeUserAccount} from '@libs/actions/Domain';
+import Navigation from '@navigation/Navigation';
 import type {PlatformStackScreenProps} from '@navigation/PlatformStackNavigation/types';
 import type {SettingsNavigatorParamList} from '@navigation/types';
 import BaseDomainMemberDetailsComponent from '@pages/domain/BaseDomainMemberDetailsComponent';
+import ONYXKEYS from '@src/ONYXKEYS';
 import type SCREENS from '@src/SCREENS';
 
 type DomainMemberDetailsPageProps = PlatformStackScreenProps<SettingsNavigatorParamList, typeof SCREENS.DOMAIN.MEMBER_DETAILS>;
 
 function DomainMemberDetailsPage({route}: DomainMemberDetailsPageProps) {
     const {domainAccountID, accountID} = route.params;
+    const styles = useThemeStyles();
+    const {translate} = useLocalize();
+    const icons = useMemoizedLazyExpensifyIcons(['RemoveMembers']);
+    const [isModalVisible, setIsModalVisible] = useState(false);
+    const [shouldForceCloseAccount, setShouldForceCloseAccount] = useState<boolean>();
+    // We need to use isSmallScreenWidth here because the DecisionModal is opening from RHP and ShouldUseNarrowLayout layout will not work in this place
+    // eslint-disable-next-line rulesdir/prefer-shouldUseNarrowLayout-instead-of-isSmallScreenWidth
+    const {isSmallScreenWidth} = useResponsiveLayout();
+    const {showConfirmModal} = useConfirmModal();
 
-    return (
-        <BaseDomainMemberDetailsComponent
-            domainAccountID={domainAccountID}
-            accountID={accountID}
+    const [userSecurityGroup] = useOnyx(`${ONYXKEYS.COLLECTION.DOMAIN}${domainAccountID}`, {
+        canBeMissing: true,
+        selector: selectSecurityGroupForAccount(accountID),
+    });
+
+    const [personalDetails] = useOnyx(ONYXKEYS.PERSONAL_DETAILS_LIST, {
+        canBeMissing: true,
+        selector: personalDetailsSelector(accountID),
+    });
+
+    const [domainName] = useOnyx(`${ONYXKEYS.COLLECTION.DOMAIN}${domainAccountID}`, {canBeMissing: false, selector: domainNameSelector});
+
+    const memberLogin = personalDetails?.login ?? '';
+
+    const handleCloseAccount = async () => {
+        if (!userSecurityGroup || shouldForceCloseAccount === undefined) {
+            return;
+        }
+
+        const result = await showConfirmModal({
+            title: translate('domain.members.closeAccount'),
+            prompt: translate('domain.members.closeAccountPrompt'),
+            confirmText: translate('domain.members.closeAccount'),
+            cancelText: translate('common.cancel'),
+            danger: true,
+            shouldShowCancelButton: true,
+        });
+        if (result.action !== ModalActions.CONFIRM) {
+            setIsModalVisible(true);
+            setShouldForceCloseAccount(undefined);
+            return;
+        }
+        closeUserAccount(domainAccountID, domainName ?? '', memberLogin, userSecurityGroup, shouldForceCloseAccount);
+        setShouldForceCloseAccount(undefined);
+        Navigation.dismissModal();
+    };
+
+    const handleForceCloseAccount = () => {
+        setShouldForceCloseAccount(true);
+        setIsModalVisible(false);
+    };
+
+    const handleSafeCloseAccount = () => {
+        setShouldForceCloseAccount(false);
+        setIsModalVisible(false);
+    };
+
+    const avatarButton = (
+        <Button
+            text={translate('domain.members.closeAccount')}
+            onPress={() => setIsModalVisible(true)}
+            icon={icons.RemoveMembers}
+            style={styles.mb5}
         />
     );
-}
 
-DomainMemberDetailsPage.displayName = 'DomainMemberDetailsPage';
+    return (
+        <>
+            <BaseDomainMemberDetailsComponent
+                domainAccountID={domainAccountID}
+                accountID={accountID}
+                avatarButton={avatarButton}
+            />
+            <DecisionModal
+                title={translate('domain.members.closeAccount')}
+                prompt={translate('domain.members.closeAccountInfo')}
+                isSmallScreenWidth={isSmallScreenWidth}
+                onFirstOptionSubmit={handleForceCloseAccount}
+                onSecondOptionSubmit={handleSafeCloseAccount}
+                secondOptionText={translate('domain.members.safeCloseAccount')}
+                firstOptionText={translate('domain.members.forceCloseAccount')}
+                isVisible={isModalVisible}
+                onClose={() => setIsModalVisible(false)}
+                onModalHide={() => {
+                    handleCloseAccount();
+                }}
+                isFirstOptionDanger
+                isSecondOptionSuccess
+            />
+        </>
+    );
+}
 
 export default DomainMemberDetailsPage;
diff --git a/src/pages/domain/Members/DomainMembersPage.tsx b/src/pages/domain/Members/DomainMembersPage.tsx
index c72832b091d5..9e05dd57c5cb 100644
--- a/src/pages/domain/Members/DomainMembersPage.tsx
+++ b/src/pages/domain/Members/DomainMembersPage.tsx
@@ -1,4 +1,4 @@
-import {defaultSecurityGroupIDSelector, memberAccountIDsSelector} from '@selectors/Domain';
+import {defaultSecurityGroupIDSelector, memberAccountIDsSelector, memberPendingActionSelector} from '@selectors/Domain';
 import React from 'react';
 import Button from '@components/Button';
 import {useMemoizedLazyExpensifyIcons, useMemoizedLazyIllustrations} from '@hooks/useLazyAsset';
@@ -6,7 +6,7 @@ import useLocalize from '@hooks/useLocalize';
 import useOnyx from '@hooks/useOnyx';
 import useResponsiveLayout from '@hooks/useResponsiveLayout';
 import useThemeStyles from '@hooks/useThemeStyles';
-import {clearAddMemberError} from '@libs/actions/Domain';
+import {clearDomainMemberError} from '@libs/actions/Domain';
 import {getLatestError} from '@libs/ErrorUtils';
 import Navigation from '@navigation/Navigation';
 import type {PlatformStackScreenProps} from '@navigation/PlatformStackNavigation/types';
@@ -27,7 +27,7 @@ function DomainMembersPage({route}: DomainMembersPageProps) {
     const styles = useThemeStyles();
 
     const [domainErrors] = useOnyx(`${ONYXKEYS.COLLECTION.DOMAIN_ERRORS}${domainAccountID}`, {canBeMissing: true});
-    const [domainPendingActions] = useOnyx(`${ONYXKEYS.COLLECTION.DOMAIN_PENDING_ACTIONS}${domainAccountID}`, {canBeMissing: true});
+    const [domainPendingActions] = useOnyx(`${ONYXKEYS.COLLECTION.DOMAIN_PENDING_ACTIONS}${domainAccountID}`, {canBeMissing: true, selector: memberPendingActionSelector});
     const [defaultSecurityGroupID] = useOnyx(`${ONYXKEYS.COLLECTION.DOMAIN}${domainAccountID}`, {canBeMissing: true, selector: defaultSecurityGroupIDSelector});
 
     const [memberIDs] = useOnyx(`${ONYXKEYS.COLLECTION.DOMAIN}${domainAccountID}`, {
@@ -46,10 +46,14 @@ function DomainMembersPage({route}: DomainMembersPageProps) {
         />
     );
 
-    const getCustomRowProps = (accountID: number, email?: string) => ({
-        errors: getLatestError(domainErrors?.memberErrors?.[email ?? accountID]?.errors),
-        pendingAction: domainPendingActions?.member?.[email ?? accountID]?.pendingAction,
-    });
+    const getCustomRowProps = (accountID: number, email?: string) => {
+        const emailError = email ? getLatestError(domainErrors?.memberErrors?.[email]?.errors) : undefined;
+        const accountIDError = getLatestError(domainErrors?.memberErrors?.[accountID]?.errors);
+        const emailPendingAction = email ? domainPendingActions?.[email]?.pendingAction : undefined;
+        const accountIDPendingAction = domainPendingActions?.[accountID]?.pendingAction;
+
+        return {errors: emailError ?? accountIDError, pendingAction: emailPendingAction ?? accountIDPendingAction};
+    };
 
     return (
         <BaseDomainMembersPage
@@ -59,18 +63,16 @@ function DomainMembersPage({route}: DomainMembersPageProps) {
             searchPlaceholder={translate('domain.members.findMember')}
             onSelectRow={(item) => Navigation.navigate(ROUTES.DOMAIN_MEMBER_DETAILS.getRoute(domainAccountID, item.accountID))}
             headerIcon={illustrations.Profile}
-            headerContent={renderHeaderButtons}
             getCustomRowProps={getCustomRowProps}
+            headerContent={renderHeaderButtons}
             onDismissError={(item) => {
                 if (!defaultSecurityGroupID) {
                     return;
                 }
-                clearAddMemberError(domainAccountID, item.accountID, item.login, defaultSecurityGroupID);
+                clearDomainMemberError(domainAccountID, item.accountID, item.login, defaultSecurityGroupID, item.pendingAction);
             }}
         />
     );
 }
 
-DomainMembersPage.displayName = 'DomainMembersPage';
-
 export default DomainMembersPage;
diff --git a/src/selectors/Domain.ts b/src/selectors/Domain.ts
index 06d1b7efa03e..bee9c15cc3da 100644
--- a/src/selectors/Domain.ts
+++ b/src/selectors/Domain.ts
@@ -2,6 +2,7 @@ import {Str} from 'expensify-common';
 import type {OnyxEntry} from 'react-native-onyx';
 import CONST from '@src/CONST';
 import type {CardFeeds, Domain, DomainPendingActions, DomainSecurityGroup, DomainSettings, SamlMetadata} from '@src/types/onyx';
+import type {SecurityGroupKey, UserSecurityGroupData} from '@src/types/onyx/Domain';
 import getEmptyArray from '@src/types/utils/getEmptyArray';
 
 const domainMemberSamlSettingsSelector = (domainSettings: OnyxEntry<CardFeeds>) => domainSettings?.settings;
@@ -55,6 +56,8 @@ const technicalContactSettingsSelector = (domainMemberSharedNVP: OnyxEntry<CardF
     };
 };
 
+const domainEmailSelector = (domain: OnyxEntry<Domain>) => domain?.email;
+
 /**
  * Extracts a list of member IDs (accountIDs) from the domain object.
  * It iterates through the security groups in the domain, extracts account IDs from the 'shared' property,
@@ -89,7 +92,50 @@ function memberAccountIDsSelector(domain: OnyxEntry<Domain>): number[] {
     return uniqueIDs.length > 0 ? uniqueIDs : getEmptyArray<number>();
 }
 
-const domainEmailSelector = (domain: OnyxEntry<Domain>) => domain?.email;
+/**
+ * Type guard to check if a domain entry is a security group entry.
+ */
+function isSecurityGroupEntry(entry: [string, unknown]): entry is [SecurityGroupKey, DomainSecurityGroup] {
+    const [key, value] = entry;
+    return key.startsWith(CONST.DOMAIN.DOMAIN_SECURITY_GROUP_PREFIX) && typeof value === 'object' && value !== null && 'shared' in value;
+}
+
+/**
+ * Creates a selector for a single security group for a specific account ID.
+ * The returned function searches through a domain and returns a group where
+ * the account ID is present in the 'shared' property.
+ *
+ * @param accountID - The account ID to filter by
+ * @returns A function that takes a domain and returns the filtered key and security group data
+ */
+function selectSecurityGroupForAccount(accountID: number) {
+    return (domain: OnyxEntry<Domain>): UserSecurityGroupData => {
+        if (!domain) {
+            return undefined;
+        }
+
+        const accountIDStr = String(accountID);
+
+        for (const entry of Object.entries(domain)) {
+            if (!isSecurityGroupEntry(entry)) {
+                continue;
+            }
+
+            const [key, group] = entry;
+
+            if (group.shared && accountIDStr in group.shared) {
+                return {
+                    key,
+                    securityGroup: group,
+                };
+            }
+        }
+
+        return undefined;
+    };
+}
+
+const memberPendingActionSelector = (pendingAction: OnyxEntry<DomainPendingActions>) => pendingAction?.member ?? {};
 
 const adminPendingActionSelector = (pendingAction: OnyxEntry<DomainPendingActions>) => pendingAction?.admin ?? {};
 
@@ -107,4 +153,7 @@ export {
     adminPendingActionSelector,
     technicalContactSettingsSelector,
     defaultSecurityGroupIDSelector,
+    selectSecurityGroupForAccount,
+    memberPendingActionSelector,
+    isSecurityGroupEntry,
 };
diff --git a/src/selectors/PersonalDetails.ts b/src/selectors/PersonalDetails.ts
index a11d3ff3dea6..eb1975294558 100644
--- a/src/selectors/PersonalDetails.ts
+++ b/src/selectors/PersonalDetails.ts
@@ -11,4 +11,6 @@ const createPersonalDetailsSelector = <T>(personalDetails: OnyxEntry<PersonalDet
 const personalDetailsByEmailSelector = (personalDetails: OnyxEntry<PersonalDetailsList>) =>
     personalDetails ? lodashMapKeys(personalDetails, (value, key) => value?.login ?? key) : undefined;
 
-export {createPersonalDetailsSelector, personalDetailsByEmailSelector};
+const personalDetailsSelector = (accountID: number) => (personalDetailsList: OnyxEntry<PersonalDetailsList>) => personalDetailsList?.[accountID];
+
+export {createPersonalDetailsSelector, personalDetailsByEmailSelector, personalDetailsSelector};
diff --git a/src/types/onyx/Domain.ts b/src/types/onyx/Domain.ts
index 52f181694264..6143c49c2d52 100644
--- a/src/types/onyx/Domain.ts
+++ b/src/types/onyx/Domain.ts
@@ -105,6 +105,29 @@ type DomainSecurityGroup = SecurityGroup & {
     shared: Record<string, 'read' | null>;
 };
 
-export {type SamlMetadata, type DomainSecurityGroup};
+/**
+ * Security group key prefix.
+ * @example `${CONST.DOMAIN.DOMAIN_SECURITY_GROUP_PREFIX}1234567890`
+ */
+type SecurityGroupKey = `${typeof CONST.DOMAIN.DOMAIN_SECURITY_GROUP_PREFIX}${string}`;
+
+/**
+ * Combination of security group key and security groups that the user belongs to.
+ */
+type UserSecurityGroupData =
+    | {
+          /**
+           * The ID (key) of the security group the user belongs to.
+           */
+          key: SecurityGroupKey;
+
+          /**
+           * The security group data.
+           */
+          securityGroup: Partial<DomainSecurityGroup>;
+      }
+    | undefined;
+
+export {type SamlMetadata, type DomainSecurityGroup, type UserSecurityGroupData, type SecurityGroupKey};
 
 export default Domain;
diff --git a/src/types/onyx/index.ts b/src/types/onyx/index.ts
index af46cae652e4..f16cf97d9b58 100644
--- a/src/types/onyx/index.ts
+++ b/src/types/onyx/index.ts
@@ -50,7 +50,7 @@ import type {
 import type DismissedProductTraining from './DismissedProductTraining';
 import type DismissedReferralBanners from './DismissedReferralBanners';
 import type Domain from './Domain';
-import type {DomainSecurityGroup, SamlMetadata} from './Domain';
+import type {DomainSecurityGroup, SamlMetadata, UserSecurityGroupData} from './Domain';
 import type DomainErrors from './DomainErrors';
 import type DomainPendingActions from './DomainPendingActions';
 import type Download from './Download';
@@ -346,4 +346,5 @@ export type {
     DomainPendingActions,
     DomainSecurityGroup,
     CodingRuleMatchingTransaction,
+    UserSecurityGroupData,
 };
diff --git a/tests/actions/DomainTest.ts b/tests/actions/DomainTest.ts
index 402ab87f8328..0f3cf0bc18e5 100644
--- a/tests/actions/DomainTest.ts
+++ b/tests/actions/DomainTest.ts
@@ -1,12 +1,12 @@
 import Onyx from 'react-native-onyx';
-import {addMemberToDomain, clearAddMemberError, clearDomainErrors, createDomain, resetCreateDomainForm, resetDomain} from '@libs/actions/Domain';
+import {addMemberToDomain, clearDomainErrors, clearDomainMemberError, closeUserAccount, createDomain, resetCreateDomainForm, resetDomain} from '@libs/actions/Domain';
 import {WRITE_COMMANDS} from '@libs/API/types';
 import {generateAccountID} from '@libs/UserUtils';
 import CONST from '@src/CONST';
 import IntlStore from '@src/languages/IntlStore';
 import OnyxUpdateManager from '@src/libs/actions/OnyxUpdateManager';
 import ONYXKEYS from '@src/ONYXKEYS';
-import type {Domain, DomainSecurityGroup} from '@src/types/onyx';
+import type {Domain, DomainSecurityGroup, UserSecurityGroupData} from '@src/types/onyx';
 import type PrefixedRecord from '@src/types/utils/PrefixedRecord';
 import * as TestHelper from '../utils/TestHelper';
 import waitForBatchedUpdates from '../utils/waitForBatchedUpdates';
@@ -202,7 +202,7 @@ describe('actions/Domain', () => {
             } as PrefixedRecord<typeof CONST.DOMAIN.DOMAIN_SECURITY_GROUP_PREFIX, Partial<DomainSecurityGroup>>,
         );
 
-        clearAddMemberError(domainAccountID, optimisticAccountID, email, defaultSecurityGroupID);
+        clearDomainMemberError(domainAccountID, optimisticAccountID, email, defaultSecurityGroupID, CONST.RED_BRICK_ROAD_PENDING_ACTION.ADD);
 
         await TestHelper.getOnyxData({
             key: `${ONYXKEYS.COLLECTION.DOMAIN_ERRORS}${domainAccountID}`,
@@ -222,4 +222,124 @@ describe('actions/Domain', () => {
             },
         });
     });
+
+    describe('closeUserAccount', () => {
+        it('closeUserAccount - sends DELETE_DOMAIN_MEMBER API request with correct data', () => {
+            const apiWriteSpy = jest.spyOn(require('@libs/API'), 'write').mockImplementation(() => Promise.resolve());
+            const domainAccountID = 123;
+            const domainName = 'test.com';
+            const accountID = 456;
+            const targetEmail = 'user@test.com';
+            const securityGroupKey = `${CONST.DOMAIN.DOMAIN_SECURITY_GROUP_PREFIX}1` as const;
+
+            const securityGroupsData: UserSecurityGroupData = {
+                key: securityGroupKey,
+                securityGroup: {
+                    shared: {
+                        [accountID]: 'read',
+                    },
+                },
+            };
+
+            closeUserAccount(domainAccountID, domainName, targetEmail, securityGroupsData);
+
+            expect(apiWriteSpy).toHaveBeenCalledWith(
+                WRITE_COMMANDS.DELETE_DOMAIN_MEMBER,
+                {domain: domainName, targetEmail, overrideProcessingReports: false},
+                {
+                    optimisticData: expect.arrayContaining([
+                        expect.objectContaining({
+                            key: `${ONYXKEYS.COLLECTION.DOMAIN_PENDING_ACTIONS}${domainAccountID}`,
+                            value: {member: {[targetEmail]: {pendingAction: CONST.RED_BRICK_ROAD_PENDING_ACTION.DELETE}}},
+                        }),
+                        expect.objectContaining({
+                            key: `${ONYXKEYS.COLLECTION.DOMAIN_ERRORS}${domainAccountID}`,
+                            value: {memberErrors: {[targetEmail]: null}},
+                        }),
+                    ]),
+                    successData: expect.arrayContaining([
+                        expect.objectContaining({
+                            key: `${ONYXKEYS.COLLECTION.DOMAIN_PENDING_ACTIONS}${domainAccountID}`,
+                            value: {member: {[targetEmail]: null}},
+                        }),
+                        expect.objectContaining({
+                            key: `${ONYXKEYS.COLLECTION.DOMAIN_ERRORS}${domainAccountID}`,
+                            value: {memberErrors: {[targetEmail]: null}},
+                        }),
+                    ]),
+                    failureData: expect.arrayContaining([
+                        expect.objectContaining({
+                            key: `${ONYXKEYS.COLLECTION.DOMAIN_ERRORS}${domainAccountID}`,
+                            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                            value: {memberErrors: {[targetEmail]: expect.any(Object)}},
+                        }),
+                        // This restores the user to the security group if the API call fails
+                        expect.objectContaining({
+                            key: `${ONYXKEYS.COLLECTION.DOMAIN}${domainAccountID}`,
+                            value: {[securityGroupKey]: {shared: {[accountID]: 'read'}}},
+                        }),
+                        expect.objectContaining({
+                            key: `${ONYXKEYS.COLLECTION.DOMAIN_PENDING_ACTIONS}${domainAccountID}`,
+                            value: {member: {[targetEmail]: null}},
+                        }),
+                    ]),
+                },
+            );
+
+            apiWriteSpy.mockRestore();
+        });
+
+        it('closeUserAccount - handles overrideProcessingReports flag', () => {
+            const apiWriteSpy = jest.spyOn(require('@libs/API'), 'write').mockImplementation(() => Promise.resolve());
+            const domainAccountID = 123;
+            const domainName = 'test.com';
+            const targetEmail = 'user@test.com';
+
+            closeUserAccount(domainAccountID, domainName, targetEmail, undefined, true);
+
+            expect(apiWriteSpy).toHaveBeenCalledWith(WRITE_COMMANDS.DELETE_DOMAIN_MEMBER, {domain: domainName, targetEmail, overrideProcessingReports: true}, expect.any(Object));
+
+            apiWriteSpy.mockRestore();
+        });
+    });
+
+    it('clearDomainMemberError - clears member errors and pending actions', async () => {
+        const domainAccountID = 123;
+        const accountID = 456;
+        const email = 'user@test.com';
+
+        await Onyx.set(`${ONYXKEYS.COLLECTION.DOMAIN_ERRORS}${domainAccountID}` as const, {
+            memberErrors: {
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                [accountID]: {errors: {123: 'error'}},
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                [email]: {errors: {456: 'error'}},
+            },
+        });
+
+        await Onyx.set(`${ONYXKEYS.COLLECTION.DOMAIN_PENDING_ACTIONS}${domainAccountID}` as const, {
+            member: {
+                [email]: {pendingAction: CONST.RED_BRICK_ROAD_PENDING_ACTION.DELETE},
+            },
+        });
+
+        clearDomainMemberError(domainAccountID, accountID, email, '');
+
+        await TestHelper.getOnyxData({
+            key: `${ONYXKEYS.COLLECTION.DOMAIN_ERRORS}${domainAccountID}`,
+            waitForCollectionCallback: false,
+            callback: (errors) => {
+                expect(errors?.memberErrors?.[accountID]).toBeFalsy();
+                expect(errors?.memberErrors?.[email]).toBeFalsy();
+            },
+        });
+
+        await TestHelper.getOnyxData({
+            key: `${ONYXKEYS.COLLECTION.DOMAIN_PENDING_ACTIONS}${domainAccountID}`,
+            waitForCollectionCallback: false,
+            callback: (pendingActions) => {
+                expect(pendingActions?.member?.[email]).toBeFalsy();
+            },
+        });
+    });
 });
diff --git a/tests/unit/DomainSelectorsTest.ts b/tests/unit/DomainSelectorsTest.ts
index 26739dad28de..d62d796215bd 100644
--- a/tests/unit/DomainSelectorsTest.ts
+++ b/tests/unit/DomainSelectorsTest.ts
@@ -4,12 +4,14 @@ import {
     defaultSecurityGroupIDSelector,
     domainEmailSelector,
     domainSettingsPrimaryContactSelector,
+    isSecurityGroupEntry,
     memberAccountIDsSelector,
+    selectSecurityGroupForAccount,
     technicalContactSettingsSelector,
 } from '@selectors/Domain';
 import type {OnyxEntry} from 'react-native-onyx';
 import CONST from '@src/CONST';
-import type {CardFeeds, Domain, DomainPendingActions, DomainSettings} from '@src/types/onyx';
+import type {CardFeeds, Domain, DomainPendingActions, DomainSecurityGroup, DomainSettings} from '@src/types/onyx';
 
 describe('domainSelectors', () => {
     const userID1 = 123;
@@ -297,4 +299,97 @@ describe('domainSelectors', () => {
             expect(defaultSecurityGroupIDSelector(domain)).toBeUndefined();
         });
     });
+
+    describe('selectSecurityGroupForAccount', () => {
+        it('Should return undefined when domain has no security groups', () => {
+            const domain = {
+                validated: true,
+                accountID: 1,
+                email: 'test@example.com',
+            } as Domain;
+
+            const result = selectSecurityGroupForAccount(123)(domain);
+
+            expect(result).toBeUndefined();
+        });
+
+        it('Should return undefined when account is not in any security group', () => {
+            const securityGroup = {
+                enableRestrictedPrimaryLogin: false,
+                enableRestrictedPolicyCreation: false,
+                shared: {
+                    // eslint-disable-next-line @typescript-eslint/naming-convention
+                    '456': 'read',
+                    // eslint-disable-next-line @typescript-eslint/naming-convention
+                    '789': 'read',
+                },
+            } as DomainSecurityGroup;
+
+            const domain: Domain = {
+                validated: true,
+                accountID: 1,
+                email: 'test@example.com',
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                domain_defaultSecurityGroupID: '1',
+                [`${CONST.DOMAIN.DOMAIN_SECURITY_GROUP_PREFIX}1`]: securityGroup,
+            } as unknown as Domain;
+
+            const result = selectSecurityGroupForAccount(123)(domain);
+
+            expect(result).toBeUndefined();
+        });
+
+        it('Should return the security group data when account belongs to a group', () => {
+            /* eslint-disable @typescript-eslint/naming-convention */
+            const group1 = {shared: {'123': 'read', '456': 'read'}, enableRestrictedPrimaryLogin: true, enableRestrictedPolicyCreation: true} as DomainSecurityGroup;
+            const group2 = {shared: {'789': 'read'}, enableRestrictedPrimaryLogin: true, enableRestrictedPolicyCreation: true} as DomainSecurityGroup;
+
+            const key1 = `${CONST.DOMAIN.DOMAIN_SECURITY_GROUP_PREFIX}1`;
+            const key2 = `${CONST.DOMAIN.DOMAIN_SECURITY_GROUP_PREFIX}2`;
+
+            const domain: Domain = {
+                validated: true,
+                accountID: 1,
+                email: 'test@example.com',
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                domain_defaultSecurityGroupID: '1',
+                [key1]: group1,
+                [key2]: group2,
+            } as unknown as Domain;
+
+            const result = selectSecurityGroupForAccount(123)(domain);
+
+            expect(result).toEqual({
+                key: key1,
+                securityGroup: group1,
+            });
+        });
+    });
+
+    describe('isSecurityGroupEntry', () => {
+        it('should return true for a valid security group entry', () => {
+            const entry: [string, unknown] = [`${CONST.DOMAIN.DOMAIN_SECURITY_GROUP_PREFIX}123`, {shared: {}}];
+            expect(isSecurityGroupEntry(entry)).toBe(true);
+        });
+
+        it('should return false if the key does not start with the security group prefix', () => {
+            const entry: [string, unknown] = ['invalid_prefix_123', {shared: {}}];
+            expect(isSecurityGroupEntry(entry)).toBe(false);
+        });
+
+        it('should return false if the value is not an object', () => {
+            const entry: [string, unknown] = [`${CONST.DOMAIN.DOMAIN_SECURITY_GROUP_PREFIX}123`, 'not an object'];
+            expect(isSecurityGroupEntry(entry)).toBe(false);
+        });
+
+        it('should return false if the value is null', () => {
+            const entry: [string, unknown] = [`${CONST.DOMAIN.DOMAIN_SECURITY_GROUP_PREFIX}123`, null];
+            expect(isSecurityGroupEntry(entry)).toBe(false);
+        });
+
+        it('should return false if the value does not have a "shared" property', () => {
+            const entry: [string, unknown] = [`${CONST.DOMAIN.DOMAIN_SECURITY_GROUP_PREFIX}123`, {other: {}}];
+            expect(isSecurityGroupEntry(entry)).toBe(false);
+        });
+    });
 });
diff --git a/tests/unit/PersonalDetailsSelectorTest.ts b/tests/unit/PersonalDetailsSelectorTest.ts
new file mode 100644
index 000000000000..36e47e72b331
--- /dev/null
+++ b/tests/unit/PersonalDetailsSelectorTest.ts
@@ -0,0 +1,30 @@
+import {personalDetailsSelector} from '@selectors/PersonalDetails';
+import type {PersonalDetailsList} from '@src/types/onyx';
+
+describe('PersonalDetailsSelector', () => {
+    describe('personalDetailsSelector', () => {
+        const accountID = 123;
+        const personalDetails = {
+            accountID,
+            displayName: 'Test User',
+        };
+        const personalDetailsList = {
+            [accountID]: personalDetails,
+        } as unknown as PersonalDetailsList;
+
+        it('should return the personal details for the given accountID', () => {
+            const result = personalDetailsSelector(accountID)(personalDetailsList);
+            expect(result).toEqual(personalDetails);
+        });
+
+        it('should return undefined if the accountID is not in the list', () => {
+            const result = personalDetailsSelector(999)(personalDetailsList);
+            expect(result).toBeUndefined();
+        });
+
+        it('should return undefined if the personalDetailsList is undefined', () => {
+            const result = personalDetailsSelector(accountID)(undefined);
+            expect(result).toBeUndefined();
+        });
+    });
+});
