diff --git a/src/components/BaseWidgetItem.tsx b/src/components/BaseWidgetItem.tsx
index 344beb6d5d645..35fabbf15e8e9 100644
--- a/src/components/BaseWidgetItem.tsx
+++ b/src/components/BaseWidgetItem.tsx
@@ -5,6 +5,7 @@ import useThemeStyles from '@hooks/useThemeStyles';
 import variables from '@styles/variables';
 import type IconAsset from '@src/types/utils/IconAsset';
 import Button from './Button';
+import type {ButtonProps} from './Button';
 import Icon from './Icon';
 import Text from './Text';
 
@@ -31,12 +32,18 @@ type BaseWidgetItemProps = {
 
     /** Optional: fill color for the icon (defaults to white) */
     iconFill?: string;
+
+    /** Optional: additional props to pass to the Button component (e.g., danger, success) */
+    buttonProps?: Partial<Pick<ButtonProps, 'success' | 'danger'>>;
 };
 
-function BaseWidgetItem({icon, iconBackgroundColor, title, subtitle, ctaText, onCtaPress, iconFill}: BaseWidgetItemProps) {
+function BaseWidgetItem({icon, iconBackgroundColor, title, subtitle, ctaText, onCtaPress, iconFill, buttonProps}: BaseWidgetItemProps) {
     const styles = useThemeStyles();
     const theme = useTheme();
 
+    // Default to success style unless buttonProps specifies otherwise
+    const showSuccess = buttonProps?.success ?? !buttonProps?.danger;
+
     return (
         <View style={[styles.flexRow, styles.alignItemsCenter, styles.gap3]}>
             <View style={styles.getWidgetItemIconContainerStyle(iconBackgroundColor)}>
@@ -54,7 +61,8 @@ function BaseWidgetItem({icon, iconBackgroundColor, title, subtitle, ctaText, on
             <Button
                 text={ctaText}
                 onPress={onCtaPress}
-                success
+                success={showSuccess}
+                danger={buttonProps?.danger}
                 small
                 style={styles.widgetItemButton}
             />
diff --git a/src/languages/de.ts b/src/languages/de.ts
index a5904b5ce028e..06acbd84f636e 100644
--- a/src/languages/de.ts
+++ b/src/languages/de.ts
@@ -8307,6 +8307,12 @@ Hier ist ein *Testbeleg*, um dir zu zeigen, wie es funktioniert:`,
             offer25off: {title: 'Erhalten Sie 25 % Rabatt auf Ihr erstes Jahr!', subtitle: ({days}: {days: number}) => `${days} ${days === 1 ? 'Tag' : 'Tage'} verbleiben`},
             addShippingAddress: {title: 'Wir benötigen Ihre Versandadresse', subtitle: 'Gib eine Adresse an, um deine Expensify Card zu erhalten.', cta: 'Adresse hinzufügen'},
             activateCard: {title: 'Aktiviere deine Expensify Card', subtitle: 'Bestätige deine Karte und beginne mit dem Ausgeben.', cta: 'Aktivieren'},
+            reviewCardFraud: {
+                title: 'Möglichen Betrug mit Ihrer Expensify Card überprüfen',
+                titleWithDetails: ({amount, merchant}: {amount: string; merchant: string}) => `Überprüfen Sie potenziellen Betrug in Höhe von ${amount} bei ${merchant}`,
+                subtitle: 'Expensify Card',
+                cta: 'Überprüfen',
+            },
         },
     },
 };
diff --git a/src/languages/en.ts b/src/languages/en.ts
index 78fe93d1e5d07..9f8c5340c60ff 100644
--- a/src/languages/en.ts
+++ b/src/languages/en.ts
@@ -1015,6 +1015,12 @@ const translations = {
                 subtitle: 'Validate your card and start spending.',
                 cta: 'Activate',
             },
+            reviewCardFraud: {
+                title: 'Review potential fraud on your Expensify Card',
+                titleWithDetails: ({amount, merchant}: {amount: string; merchant: string}) => `Review ${amount} in potential fraud at ${merchant}`,
+                subtitle: 'Expensify Card',
+                cta: 'Review',
+            },
         },
         announcements: 'Announcements',
         discoverSection: {
diff --git a/src/languages/es.ts b/src/languages/es.ts
index 3a3e63299da42..c5f74b53c7309 100644
--- a/src/languages/es.ts
+++ b/src/languages/es.ts
@@ -760,6 +760,12 @@ const translations: TranslationDeepObject<typeof en> = {
                 subtitle: 'Valida tu tarjeta y empieza a gastar.',
                 cta: 'Activa',
             },
+            reviewCardFraud: {
+                title: 'Revisa un posible fraude en tu tarjeta Expensify',
+                titleWithDetails: ({amount, merchant}: {amount: string; merchant: string}) => `Revisa ${amount} en posible fraude en ${merchant}`,
+                subtitle: 'Tarjeta Expensify',
+                cta: 'Revisar',
+            },
         },
         announcements: 'Anuncios',
         discoverSection: {
diff --git a/src/languages/fr.ts b/src/languages/fr.ts
index 55297041b7030..7176217dc8fff 100644
--- a/src/languages/fr.ts
+++ b/src/languages/fr.ts
@@ -8313,6 +8313,12 @@ Voici un *reçu test* pour vous montrer comment cela fonctionne :`,
             offer25off: {title: 'Obtenez 25 % de réduction sur votre première année !', subtitle: ({days}: {days: number}) => `${days} ${days === 1 ? 'jour' : 'jours'} restants`},
             addShippingAddress: {title: 'Nous avons besoin de votre adresse de livraison', subtitle: 'Indiquez une adresse pour recevoir votre carte Expensify.', cta: 'Ajouter une adresse'},
             activateCard: {title: 'Activer votre carte Expensify', subtitle: 'Validez votre carte et commencez à dépenser.', cta: 'Activer'},
+            reviewCardFraud: {
+                title: 'Examiner une fraude potentielle sur votre carte Expensify',
+                titleWithDetails: ({amount, merchant}: {amount: string; merchant: string}) => `Examiner ${amount} de fraude potentielle chez ${merchant}`,
+                subtitle: 'Carte Expensify',
+                cta: 'Vérifier',
+            },
         },
     },
 };
diff --git a/src/languages/it.ts b/src/languages/it.ts
index 169e7064b93c1..ca39cf38f1ec6 100644
--- a/src/languages/it.ts
+++ b/src/languages/it.ts
@@ -8293,6 +8293,12 @@ Ecco una *ricevuta di prova* per mostrarti come funziona:`,
             offer25off: {title: 'Ottieni il 25% di sconto sul tuo primo anno!', subtitle: ({days}: {days: number}) => `${days} ${days === 1 ? 'giorno' : 'giorni'} rimanenti`},
             addShippingAddress: {title: 'Abbiamo bisogno del tuo indirizzo di spedizione', subtitle: 'Fornisci un indirizzo per ricevere la tua Expensify Card.', cta: 'Aggiungi indirizzo'},
             activateCard: {title: 'Attiva la tua Expensify Card', subtitle: 'Convalida la tua carta e inizia a spendere.', cta: 'Attiva'},
+            reviewCardFraud: {
+                title: 'Esamina una potenziale frode sulla tua Expensify Card',
+                titleWithDetails: ({amount, merchant}: {amount: string; merchant: string}) => `Controlla ${amount} di potenziale frode presso ${merchant}`,
+                subtitle: 'Carta Expensify',
+                cta: 'Rivedi',
+            },
         },
     },
 };
diff --git a/src/languages/ja.ts b/src/languages/ja.ts
index c4669e8b00932..d384254a1b6e0 100644
--- a/src/languages/ja.ts
+++ b/src/languages/ja.ts
@@ -8204,6 +8204,12 @@ Expensify の使い方をお見せするための*テストレシート*がこ
             offer25off: {title: '初年度が25％オフ！', subtitle: ({days}: {days: number}) => `残り ${days} ${days === 1 ? '日' : '日'}`},
             addShippingAddress: {title: '配送先住所が必要です', subtitle: 'Expensify Card を受け取る住所を入力してください。', cta: '住所を追加'},
             activateCard: {title: 'Expensify Card を有効化', subtitle: 'カードを認証して、すぐに支出を始めましょう。', cta: '有効化'},
+            reviewCardFraud: {
+                title: 'Expensify Card の不正利用の可能性を確認する',
+                titleWithDetails: ({amount, merchant}: {amount: string; merchant: string}) => `${merchant} での不正の可能性がある ${amount} を確認`,
+                subtitle: 'Expensify Card',
+                cta: 'レビュー',
+            },
         },
     },
 };
diff --git a/src/languages/nl.ts b/src/languages/nl.ts
index e6bd121bd966e..89e9b908e1852 100644
--- a/src/languages/nl.ts
+++ b/src/languages/nl.ts
@@ -8269,6 +8269,12 @@ Hier is een *testbon* om je te laten zien hoe het werkt:`,
             offer25off: {title: 'Krijg 25% korting op je eerste jaar!', subtitle: ({days}: {days: number}) => `Nog ${days} ${days === 1 ? 'dag' : 'dagen'} resterend`},
             addShippingAddress: {title: 'We hebben je verzendadres nodig', subtitle: 'Voer een adres in om je Expensify Card te ontvangen.', cta: 'Adres toevoegen'},
             activateCard: {title: 'Activeer je Expensify Card', subtitle: 'Valideer je kaart en begin met uitgeven.', cta: 'Activeren'},
+            reviewCardFraud: {
+                title: 'Controleer mogelijke fraude op je Expensify Card',
+                titleWithDetails: ({amount, merchant}: {amount: string; merchant: string}) => `Controleer ${amount} aan mogelijke fraude bij ${merchant}`,
+                subtitle: 'Expensify Card',
+                cta: 'Beoordeling',
+            },
         },
     },
 };
diff --git a/src/languages/pl.ts b/src/languages/pl.ts
index 8953295506bae..4ccf2269228a1 100644
--- a/src/languages/pl.ts
+++ b/src/languages/pl.ts
@@ -8253,6 +8253,12 @@ Oto *paragon testowy*, który pokazuje, jak to działa:`,
             offer25off: {title: 'Uzyskaj 25% zniżki na pierwszy rok!', subtitle: ({days}: {days: number}) => `Pozostało ${days} ${days === 1 ? 'dzień' : 'dni'}`},
             addShippingAddress: {title: 'Potrzebujemy Twojego adresu do wysyłki', subtitle: 'Podaj adres, na który mamy wysłać Twoją kartę Expensify.', cta: 'Dodaj adres'},
             activateCard: {title: 'Aktywuj swoją kartę Expensify', subtitle: 'Zweryfikuj swoją kartę i zacznij wydawać.', cta: 'Aktywuj'},
+            reviewCardFraud: {
+                title: 'Przejrzyj potencjalne oszustwo na swojej karcie Expensify',
+                titleWithDetails: ({amount, merchant}: {amount: string; merchant: string}) => `Sprawdź ${amount} pod kątem potencjalnego oszustwa w ${merchant}`,
+                subtitle: 'Karta Expensify',
+                cta: 'Przejrzyj',
+            },
         },
     },
 };
diff --git a/src/languages/pt-BR.ts b/src/languages/pt-BR.ts
index 74bc594d78d7e..14144144354b1 100644
--- a/src/languages/pt-BR.ts
+++ b/src/languages/pt-BR.ts
@@ -8263,6 +8263,12 @@ Aqui está um *recibo de teste* para mostrar como funciona:`,
             offer25off: {title: 'Ganhe 25% de desconto no seu primeiro ano!', subtitle: ({days}: {days: number}) => `${days} ${days === 1 ? 'dia' : 'dias'} restantes`},
             addShippingAddress: {title: 'Precisamos do seu endereço de entrega', subtitle: 'Forneça um endereço para receber seu Expensify Card.', cta: 'Adicionar endereço'},
             activateCard: {title: 'Ative seu Cartão Expensify', subtitle: 'Valide seu cartão e comece a gastar.', cta: 'Ativar'},
+            reviewCardFraud: {
+                title: 'Analisar possível fraude no seu Cartão Expensify',
+                titleWithDetails: ({amount, merchant}: {amount: string; merchant: string}) => `Revisar ${amount} em potencial fraude em ${merchant}`,
+                subtitle: 'Cartão Expensify',
+                cta: 'Revisar',
+            },
         },
     },
 };
diff --git a/src/languages/zh-hans.ts b/src/languages/zh-hans.ts
index 41c860b495bc3..9c9513d34e339 100644
--- a/src/languages/zh-hans.ts
+++ b/src/languages/zh-hans.ts
@@ -8021,6 +8021,12 @@ ${reportName}
             offer25off: {title: '首次年度订阅立享 25% 折扣！', subtitle: ({days}: {days: number}) => `剩余 ${days} ${days === 1 ? '天' : '天'}`},
             addShippingAddress: {title: '我们需要您的收货地址', subtitle: '请提供一个地址以接收您的 Expensify Card。', cta: '添加地址'},
             activateCard: {title: '激活您的 Expensify Card', subtitle: '验证您的卡片并开始消费。', cta: '激活'},
+            reviewCardFraud: {
+                title: '审查您的 Expensify Card 潜在欺诈行为',
+                titleWithDetails: ({amount, merchant}: {amount: string; merchant: string}) => `在 ${merchant} 发现疑似欺诈金额 ${amount}，请审核`,
+                subtitle: 'Expensify Card',
+                cta: '审核',
+            },
         },
     },
 };
diff --git a/src/pages/home/TimeSensitiveSection/hooks/useTimeSensitiveCards.ts b/src/pages/home/TimeSensitiveSection/hooks/useTimeSensitiveCards.ts
index 909683ad61ba4..c1b646fb256e6 100644
--- a/src/pages/home/TimeSensitiveSection/hooks/useTimeSensitiveCards.ts
+++ b/src/pages/home/TimeSensitiveSection/hooks/useTimeSensitiveCards.ts
@@ -1,45 +1,28 @@
-import {useMemo} from 'react';
+import {timeSensitiveCardsSelector} from '@selectors/Card';
 import useOnyx from '@hooks/useOnyx';
-import {isCard, isCardPendingActivate, isCardPendingIssue} from '@libs/CardUtils';
-import CONST from '@src/CONST';
 import ONYXKEYS from '@src/ONYXKEYS';
-import type {Card} from '@src/types/onyx';
 
 function useTimeSensitiveCards() {
-    const [cardList] = useOnyx(ONYXKEYS.CARD_LIST, {canBeMissing: true});
+    const [timeSensitiveCards] = useOnyx(ONYXKEYS.CARD_LIST, {
+        canBeMissing: true,
+        selector: timeSensitiveCardsSelector,
+    });
 
-    const {cardsNeedingShippingAddress, cardsNeedingActivation} = useMemo<{cardsNeedingShippingAddress: Card[]; cardsNeedingActivation: Card[]}>(() => {
-        const cards = Object.values(cardList ?? {}).filter(isCard);
-        const isPhysicalExpensifyCard = (card: Card) => card.bank === CONST.EXPENSIFY_CARD.BANK && !card.nameValuePairs?.isVirtual;
-
-        return cards.reduce<{cardsNeedingShippingAddress: Card[]; cardsNeedingActivation: Card[]}>(
-            (acc, card) => {
-                if (!isPhysicalExpensifyCard(card)) {
-                    return acc;
-                }
-
-                if (isCardPendingIssue(card)) {
-                    acc.cardsNeedingShippingAddress.push(card);
-                }
-
-                if (isCardPendingActivate(card)) {
-                    acc.cardsNeedingActivation.push(card);
-                }
-
-                return acc;
-            },
-            {cardsNeedingShippingAddress: [], cardsNeedingActivation: []},
-        );
-    }, [cardList]);
+    const cardsNeedingShippingAddress = timeSensitiveCards?.cardsNeedingShippingAddress ?? [];
+    const cardsNeedingActivation = timeSensitiveCards?.cardsNeedingActivation ?? [];
+    const cardsWithFraud = timeSensitiveCards?.cardsWithFraud ?? [];
 
     const shouldShowAddShippingAddress = cardsNeedingShippingAddress.length > 0;
     const shouldShowActivateCard = cardsNeedingActivation.length > 0;
+    const shouldShowReviewCardFraud = cardsWithFraud.length > 0;
 
     return {
         shouldShowAddShippingAddress,
         shouldShowActivateCard,
+        shouldShowReviewCardFraud,
         cardsNeedingShippingAddress,
         cardsNeedingActivation,
+        cardsWithFraud,
     };
 }
 
diff --git a/src/pages/home/TimeSensitiveSection/index.tsx b/src/pages/home/TimeSensitiveSection/index.tsx
index 09f45482b1bfa..27cc38db028eb 100644
--- a/src/pages/home/TimeSensitiveSection/index.tsx
+++ b/src/pages/home/TimeSensitiveSection/index.tsx
@@ -13,6 +13,7 @@ import ActivateCard from './items/ActivateCard';
 import AddShippingAddress from './items/AddShippingAddress';
 import Offer25off from './items/Offer25off';
 import Offer50off from './items/Offer50off';
+import ReviewCardFraud from './items/ReviewCardFraud';
 
 function TimeSensitiveSection() {
     const styles = useThemeStyles();
@@ -22,9 +23,9 @@ function TimeSensitiveSection() {
     const {shouldUseNarrowLayout} = useResponsiveLayout();
 
     const {shouldShow50off, shouldShow25off, firstDayFreeTrial, discountInfo} = useTimeSensitiveOffers();
-    const {shouldShowAddShippingAddress, shouldShowActivateCard, cardsNeedingShippingAddress, cardsNeedingActivation} = useTimeSensitiveCards();
+    const {shouldShowAddShippingAddress, shouldShowActivateCard, shouldShowReviewCardFraud, cardsNeedingShippingAddress, cardsNeedingActivation, cardsWithFraud} = useTimeSensitiveCards();
 
-    const hasAnyItemToShow = shouldShow50off || shouldShow25off || shouldShowAddShippingAddress || shouldShowActivateCard;
+    const hasAnyItemToShow = shouldShowReviewCardFraud || shouldShow50off || shouldShow25off || shouldShowAddShippingAddress || shouldShowActivateCard;
 
     if (!hasAnyItemToShow) {
         return null;
@@ -40,6 +41,14 @@ function TimeSensitiveSection() {
             titleColor={theme.danger}
         >
             <View style={styles.getForYouSectionContainerStyle(shouldUseNarrowLayout)}>
+                {/* Priority order: 1. Fraud, 2. Discounts, 3. Shipping, 4. Activation */}
+                {shouldShowReviewCardFraud &&
+                    cardsWithFraud.map((card) => (
+                        <ReviewCardFraud
+                            key={card.cardID}
+                            card={card}
+                        />
+                    ))}
                 {shouldShow50off && <Offer50off firstDayFreeTrial={firstDayFreeTrial} />}
                 {shouldShow25off && !!discountInfo && <Offer25off days={discountInfo.days} />}
                 {shouldShowAddShippingAddress &&
diff --git a/src/pages/home/TimeSensitiveSection/items/ReviewCardFraud.tsx b/src/pages/home/TimeSensitiveSection/items/ReviewCardFraud.tsx
new file mode 100644
index 0000000000000..eacceb0c37e75
--- /dev/null
+++ b/src/pages/home/TimeSensitiveSection/items/ReviewCardFraud.tsx
@@ -0,0 +1,60 @@
+import React, {useMemo} from 'react';
+import ExpensifyCardIcon from '@assets/images/expensify-card-icon.svg';
+import BaseWidgetItem from '@components/BaseWidgetItem';
+import useLocalize from '@hooks/useLocalize';
+import {convertToDisplayString} from '@libs/CurrencyUtils';
+import Navigation from '@libs/Navigation/Navigation';
+import colors from '@styles/theme/colors';
+import CONST from '@src/CONST';
+import ROUTES from '@src/ROUTES';
+import type {Card} from '@src/types/onyx';
+
+type ReviewCardFraudProps = {
+    /** The card with potential fraud */
+    card: Card;
+};
+
+function ReviewCardFraud({card}: ReviewCardFraudProps) {
+    const {translate} = useLocalize();
+
+    const possibleFraud = card.message?.possibleFraud;
+    const fraudAlertReportID = possibleFraud?.fraudAlertReportID;
+    const triggerAmount = possibleFraud?.triggerAmount;
+    const triggerMerchant = possibleFraud?.triggerMerchant;
+
+    const handleReviewPress = () => {
+        if (!fraudAlertReportID) {
+            return;
+        }
+
+        // Navigate to the report containing the fraud alert action
+        Navigation.navigate(ROUTES.REPORT_WITH_ID.getRoute(String(fraudAlertReportID)));
+    };
+
+    // Generate the title with amount and merchant if available
+    const title = useMemo(() => {
+        if (triggerAmount !== undefined && triggerMerchant) {
+            const formattedAmount = convertToDisplayString(triggerAmount, CONST.CURRENCY.USD);
+            return translate('homePage.timeSensitiveSection.reviewCardFraud.titleWithDetails', {
+                amount: formattedAmount,
+                merchant: triggerMerchant,
+            });
+        }
+        return translate('homePage.timeSensitiveSection.reviewCardFraud.title');
+    }, [triggerAmount, triggerMerchant, translate]);
+
+    return (
+        <BaseWidgetItem
+            icon={ExpensifyCardIcon}
+            iconBackgroundColor={colors.tangerine100}
+            iconFill={colors.tangerine700}
+            title={title}
+            subtitle={translate('homePage.timeSensitiveSection.reviewCardFraud.subtitle')}
+            ctaText={translate('homePage.timeSensitiveSection.reviewCardFraud.cta')}
+            onCtaPress={handleReviewPress}
+            buttonProps={{danger: true}}
+        />
+    );
+}
+
+export default ReviewCardFraud;
diff --git a/src/selectors/Card.ts b/src/selectors/Card.ts
index f8c1cba43866b..4dcd191746c19 100644
--- a/src/selectors/Card.ts
+++ b/src/selectors/Card.ts
@@ -1,8 +1,9 @@
 import type {OnyxEntry} from 'react-native-onyx';
 import {getCardFeedsForDisplay} from '@libs/CardFeedUtils';
-import {isCard, isCardHiddenFromSearch, isPersonalCard} from '@libs/CardUtils';
+import {isCard, isCardHiddenFromSearch, isCardPendingActivate, isCardPendingIssue, isExpensifyCard, isPersonalCard} from '@libs/CardUtils';
 import {filterObject} from '@libs/ObjectUtils';
-import type {CardList, NonPersonalAndWorkspaceCardListDerivedValue} from '@src/types/onyx';
+import CONST from '@src/CONST';
+import type {Card, CardList, NonPersonalAndWorkspaceCardListDerivedValue} from '@src/types/onyx';
 
 /**
  * Filter out cards that are hidden from search.
@@ -28,14 +29,6 @@ const filterOutPersonalCards = (cards: OnyxEntry<CardList>): CardList => {
     return filterObject(cards ?? {}, (key, card) => !isPersonalCard(card));
 };
 
-/**
- * Filter to keep only personal cards from the card list.
- * Personal cards have fundID === '0' or no fundID.
- */
-const filterPersonalCards = (cards: OnyxEntry<CardList>): CardList => {
-    return filterObject(cards ?? {}, (key, card) => isPersonalCard(card));
-};
-
 /**
  * Selects the Expensify Card feed from the card list and returns the first one.
  */
@@ -49,4 +42,63 @@ const defaultExpensifyCardSelector = (allCards: OnyxEntry<NonPersonalAndWorkspac
  */
 const cardByIdSelector = (cardID: string) => (cardList: OnyxEntry<CardList>) => cardList?.[cardID];
 
-export {filterCardsHiddenFromSearch, filterOutPersonalCards, filterPersonalCards, defaultExpensifyCardSelector, cardByIdSelector};
+type TimeSensitiveCardsResult = {
+    cardsNeedingShippingAddress: Card[];
+    cardsNeedingActivation: Card[];
+    cardsWithFraud: Card[];
+};
+
+/**
+ * Check if a card has potential fraud that needs review.
+ * Returns true if the card has fraud type 'domain' or 'individual'.
+ */
+const isCardWithPotentialFraud = (card: Card): boolean => {
+    return card.fraud === CONST.EXPENSIFY_CARD.FRAUD_TYPES.DOMAIN || card.fraud === CONST.EXPENSIFY_CARD.FRAUD_TYPES.INDIVIDUAL;
+};
+
+/**
+ * Selector that filters cards to find Expensify cards that need time-sensitive action.
+ * Returns arrays for: cards with potential fraud, cards pending issue (need shipping), and cards pending activation.
+ */
+const timeSensitiveCardsSelector = (cards: OnyxEntry<CardList>): TimeSensitiveCardsResult => {
+    const result: TimeSensitiveCardsResult = {
+        cardsNeedingShippingAddress: [],
+        cardsNeedingActivation: [],
+        cardsWithFraud: [],
+    };
+
+    for (const card of Object.values(cards ?? {})) {
+        if (!isCard(card)) {
+            continue;
+        }
+
+        // Only consider Expensify cards
+        if (!isExpensifyCard(card)) {
+            continue;
+        }
+
+        // Check for fraud on any Expensify card (physical or virtual)
+        if (isCardWithPotentialFraud(card)) {
+            result.cardsWithFraud.push(card);
+        }
+
+        // Physical card checks (shipping address and activation)
+        const isPhysicalCard = !card.nameValuePairs?.isVirtual;
+        if (!isPhysicalCard) {
+            continue;
+        }
+
+        if (isCardPendingIssue(card)) {
+            result.cardsNeedingShippingAddress.push(card);
+        }
+
+        if (isCardPendingActivate(card)) {
+            result.cardsNeedingActivation.push(card);
+        }
+    }
+
+    return result;
+};
+
+export {filterCardsHiddenFromSearch, filterOutPersonalCards, defaultExpensifyCardSelector, cardByIdSelector, timeSensitiveCardsSelector};
+export type {TimeSensitiveCardsResult};
diff --git a/src/types/onyx/Card.ts b/src/types/onyx/Card.ts
index 1782702a80aa9..4b758e81040e1 100644
--- a/src/types/onyx/Card.ts
+++ b/src/types/onyx/Card.ts
@@ -13,6 +13,36 @@ type CardStatusChanges = {
     status: ValueOf<typeof CONST.EXPENSIFY_CARD.STATE>;
 };
 
+/** Model of possible fraud data stored on a card */
+type PossibleFraudData = {
+    /** Fraud state of the card */
+    state?: number;
+
+    /** Date when fraud was detected */
+    date?: string;
+
+    /** Card ID that triggered the fraud detection (for domain-level fraud) */
+    triggerCardID?: number;
+
+    /** Amount that triggered the fraud detection (in cents) */
+    triggerAmount?: number;
+
+    /** Merchant name that triggered the fraud detection */
+    triggerMerchant?: string;
+
+    /** Report ID for the fraud alert action (used for deeplink) */
+    fraudAlertReportID?: number;
+
+    /** Report action ID for the fraud alert (used for deeplink) */
+    fraudAlertReportActionID?: number;
+};
+
+/** Model of card message data */
+type CardMessage = {
+    /** Possible fraud information */
+    possibleFraud?: PossibleFraudData;
+};
+
 /** Model of Expensify card */
 type Card = OnyxCommon.OnyxValueWithOfflineFeedback<{
     /** Card ID number */
@@ -60,6 +90,9 @@ type Card = OnyxCommon.OnyxValueWithOfflineFeedback<{
     /** Current fraud state of the card */
     fraud: ValueOf<typeof CONST.EXPENSIFY_CARD.FRAUD_TYPES>;
 
+    /** Card message data containing possible fraud info and other metadata */
+    message?: CardMessage;
+
     /** Card name */
     cardName?: string;
 
@@ -374,4 +407,6 @@ export type {
     ProvisioningCardData,
     AssignableCardsList,
     UnassignedCard,
+    CardMessage,
+    PossibleFraudData,
 };
diff --git a/tests/unit/hooks/useTimeSensitiveCards.test.ts b/tests/unit/hooks/useTimeSensitiveCards.test.ts
new file mode 100644
index 0000000000000..abc2a9e6e2cf9
--- /dev/null
+++ b/tests/unit/hooks/useTimeSensitiveCards.test.ts
@@ -0,0 +1,200 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import {renderHook} from '@testing-library/react-native';
+import Onyx from 'react-native-onyx';
+import useTimeSensitiveCards from '@pages/home/TimeSensitiveSection/hooks/useTimeSensitiveCards';
+import CONST from '@src/CONST';
+import ONYXKEYS from '@src/ONYXKEYS';
+import type {Card, CardList} from '@src/types/onyx';
+import {createRandomExpensifyCard} from '../../utils/collections/card';
+import waitForBatchedUpdates from '../../utils/waitForBatchedUpdates';
+
+describe('useTimeSensitiveCards', () => {
+    beforeAll(() => {
+        Onyx.init({keys: ONYXKEYS});
+    });
+
+    beforeEach(async () => {
+        await Onyx.clear();
+        await waitForBatchedUpdates();
+    });
+
+    afterEach(async () => {
+        await Onyx.clear();
+    });
+
+    it('should return empty arrays when no cards exist', () => {
+        const {result} = renderHook(() => useTimeSensitiveCards());
+
+        expect(result.current.cardsNeedingShippingAddress).toEqual([]);
+        expect(result.current.cardsNeedingActivation).toEqual([]);
+        expect(result.current.cardsWithFraud).toEqual([]);
+        expect(result.current.shouldShowAddShippingAddress).toBe(false);
+        expect(result.current.shouldShowActivateCard).toBe(false);
+        expect(result.current.shouldShowReviewCardFraud).toBe(false);
+    });
+
+    it('should return empty arrays when no cards need action', async () => {
+        const openCard = createRandomExpensifyCard(1, {state: CONST.EXPENSIFY_CARD.STATE.OPEN});
+        const cardList: CardList = {'1': openCard};
+
+        await Onyx.merge(ONYXKEYS.CARD_LIST, cardList);
+        await waitForBatchedUpdates();
+
+        const {result} = renderHook(() => useTimeSensitiveCards());
+
+        expect(result.current.cardsNeedingShippingAddress).toEqual([]);
+        expect(result.current.cardsNeedingActivation).toEqual([]);
+        expect(result.current.shouldShowAddShippingAddress).toBe(false);
+        expect(result.current.shouldShowActivateCard).toBe(false);
+    });
+
+    it('should identify cards needing shipping address and set shouldShowAddShippingAddress to true', async () => {
+        const cardNeedingShipping = createRandomExpensifyCard(1, {state: CONST.EXPENSIFY_CARD.STATE.STATE_NOT_ISSUED});
+        const cardList: CardList = {'1': cardNeedingShipping};
+
+        await Onyx.merge(ONYXKEYS.CARD_LIST, cardList);
+        await waitForBatchedUpdates();
+
+        const {result} = renderHook(() => useTimeSensitiveCards());
+
+        expect(result.current.cardsNeedingShippingAddress).toHaveLength(1);
+        expect(result.current.cardsNeedingShippingAddress[0].cardID).toBe(1);
+        expect(result.current.shouldShowAddShippingAddress).toBe(true);
+        expect(result.current.shouldShowActivateCard).toBe(false);
+    });
+
+    it('should identify cards needing activation and set shouldShowActivateCard to true', async () => {
+        const cardNeedingActivation = createRandomExpensifyCard(1, {state: CONST.EXPENSIFY_CARD.STATE.NOT_ACTIVATED});
+        const cardList: CardList = {'1': cardNeedingActivation};
+
+        await Onyx.merge(ONYXKEYS.CARD_LIST, cardList);
+        await waitForBatchedUpdates();
+
+        const {result} = renderHook(() => useTimeSensitiveCards());
+
+        expect(result.current.cardsNeedingActivation).toHaveLength(1);
+        expect(result.current.cardsNeedingActivation[0].cardID).toBe(1);
+        expect(result.current.shouldShowActivateCard).toBe(true);
+        expect(result.current.shouldShowAddShippingAddress).toBe(false);
+    });
+
+    it('should handle multiple cards needing different actions', async () => {
+        const cardNeedingShipping = createRandomExpensifyCard(1, {state: CONST.EXPENSIFY_CARD.STATE.STATE_NOT_ISSUED});
+        const cardNeedingActivation = createRandomExpensifyCard(2, {state: CONST.EXPENSIFY_CARD.STATE.NOT_ACTIVATED});
+        const openCard = createRandomExpensifyCard(3, {state: CONST.EXPENSIFY_CARD.STATE.OPEN});
+
+        const cardList: CardList = {
+            '1': cardNeedingShipping,
+            '2': cardNeedingActivation,
+            '3': openCard,
+        };
+
+        await Onyx.merge(ONYXKEYS.CARD_LIST, cardList);
+        await waitForBatchedUpdates();
+
+        const {result} = renderHook(() => useTimeSensitiveCards());
+
+        expect(result.current.cardsNeedingShippingAddress).toHaveLength(1);
+        expect(result.current.cardsNeedingActivation).toHaveLength(1);
+        expect(result.current.shouldShowAddShippingAddress).toBe(true);
+        expect(result.current.shouldShowActivateCard).toBe(true);
+    });
+
+    it('should exclude virtual cards from time-sensitive results', async () => {
+        const virtualCard: Card = {
+            ...createRandomExpensifyCard(1, {state: CONST.EXPENSIFY_CARD.STATE.NOT_ACTIVATED}),
+            nameValuePairs: {isVirtual: true} as Card['nameValuePairs'],
+        };
+        const physicalCard = createRandomExpensifyCard(2, {state: CONST.EXPENSIFY_CARD.STATE.NOT_ACTIVATED});
+
+        const cardList: CardList = {
+            '1': virtualCard,
+            '2': physicalCard,
+        };
+
+        await Onyx.merge(ONYXKEYS.CARD_LIST, cardList);
+        await waitForBatchedUpdates();
+
+        const {result} = renderHook(() => useTimeSensitiveCards());
+
+        // Only physical card should be included
+        expect(result.current.cardsNeedingActivation).toHaveLength(1);
+        expect(result.current.cardsNeedingActivation[0].cardID).toBe(2);
+    });
+
+    it('should exclude non-Expensify cards from time-sensitive results', async () => {
+        // Company card with pending state
+        const companyCard: Card = {
+            cardID: 1,
+            bank: 'vcf',
+            state: CONST.EXPENSIFY_CARD.STATE.STATE_NOT_ISSUED,
+            fraud: CONST.EXPENSIFY_CARD.FRAUD_TYPES.NONE,
+            lastUpdated: '2024-01-01',
+        } as Card;
+
+        const expensifyCard = createRandomExpensifyCard(2, {state: CONST.EXPENSIFY_CARD.STATE.STATE_NOT_ISSUED});
+
+        const cardList: CardList = {
+            '1': companyCard,
+            '2': expensifyCard,
+        };
+
+        await Onyx.merge(ONYXKEYS.CARD_LIST, cardList);
+        await waitForBatchedUpdates();
+
+        const {result} = renderHook(() => useTimeSensitiveCards());
+
+        // Only Expensify card should be included
+        expect(result.current.cardsNeedingShippingAddress).toHaveLength(1);
+        expect(result.current.cardsNeedingShippingAddress[0].cardID).toBe(2);
+    });
+
+    it('should update when card list changes', async () => {
+        const openCard = createRandomExpensifyCard(1, {state: CONST.EXPENSIFY_CARD.STATE.OPEN});
+        const cardList: CardList = {'1': openCard};
+
+        await Onyx.merge(ONYXKEYS.CARD_LIST, cardList);
+        await waitForBatchedUpdates();
+
+        const {result, rerender} = renderHook(() => useTimeSensitiveCards());
+
+        expect(result.current.shouldShowActivateCard).toBe(false);
+
+        // Add a card needing activation
+        const cardNeedingActivation = createRandomExpensifyCard(2, {state: CONST.EXPENSIFY_CARD.STATE.NOT_ACTIVATED});
+        await Onyx.merge(ONYXKEYS.CARD_LIST, {'2': cardNeedingActivation});
+        await waitForBatchedUpdates();
+
+        rerender({});
+
+        expect(result.current.cardsNeedingActivation).toHaveLength(1);
+        expect(result.current.shouldShowActivateCard).toBe(true);
+    });
+
+    it('should identify cards with fraud and set shouldShowReviewCardFraud to true', async () => {
+        const cardWithFraud = createRandomExpensifyCard(1, {state: CONST.EXPENSIFY_CARD.STATE.OPEN, fraud: CONST.EXPENSIFY_CARD.FRAUD_TYPES.DOMAIN});
+        const cardList: CardList = {'1': cardWithFraud};
+
+        await Onyx.merge(ONYXKEYS.CARD_LIST, cardList);
+        await waitForBatchedUpdates();
+
+        const {result} = renderHook(() => useTimeSensitiveCards());
+
+        expect(result.current.cardsWithFraud).toHaveLength(1);
+        expect(result.current.cardsWithFraud[0].cardID).toBe(1);
+        expect(result.current.shouldShowReviewCardFraud).toBe(true);
+    });
+
+    it('should not show fraud review for cards with fraud type NONE', async () => {
+        const cardWithNoFraud = createRandomExpensifyCard(1, {state: CONST.EXPENSIFY_CARD.STATE.OPEN, fraud: CONST.EXPENSIFY_CARD.FRAUD_TYPES.NONE});
+        const cardList: CardList = {'1': cardWithNoFraud};
+
+        await Onyx.merge(ONYXKEYS.CARD_LIST, cardList);
+        await waitForBatchedUpdates();
+
+        const {result} = renderHook(() => useTimeSensitiveCards());
+
+        expect(result.current.cardsWithFraud).toHaveLength(0);
+        expect(result.current.shouldShowReviewCardFraud).toBe(false);
+    });
+});
diff --git a/tests/unit/hooks/useTimeSensitiveOffers.test.ts b/tests/unit/hooks/useTimeSensitiveOffers.test.ts
new file mode 100644
index 0000000000000..4a093afe1fc97
--- /dev/null
+++ b/tests/unit/hooks/useTimeSensitiveOffers.test.ts
@@ -0,0 +1,212 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import {renderHook} from '@testing-library/react-native';
+import Onyx from 'react-native-onyx';
+// Import mocks after they're defined
+import useHasTeam2025Pricing from '@hooks/useHasTeam2025Pricing';
+import useSubscriptionPlan from '@hooks/useSubscriptionPlan';
+import {getEarlyDiscountInfo, shouldShowDiscountBanner} from '@libs/SubscriptionUtils';
+import useTimeSensitiveOffers from '@pages/home/TimeSensitiveSection/hooks/useTimeSensitiveOffers';
+import ONYXKEYS from '@src/ONYXKEYS';
+import waitForBatchedUpdates from '../../utils/waitForBatchedUpdates';
+
+// Mock the hooks and utils that useTimeSensitiveOffers depends on
+jest.mock('@hooks/useHasTeam2025Pricing', () => ({
+    __esModule: true,
+    default: jest.fn(() => false),
+}));
+
+jest.mock('@hooks/useSubscriptionPlan', () => ({
+    __esModule: true,
+    default: jest.fn(() => 'corporate'),
+}));
+
+jest.mock('@libs/SubscriptionUtils', () => ({
+    shouldShowDiscountBanner: jest.fn(() => false),
+    getEarlyDiscountInfo: jest.fn(() => null),
+}));
+
+const mockedUseHasTeam2025Pricing = useHasTeam2025Pricing as jest.Mock;
+const mockedUseSubscriptionPlan = useSubscriptionPlan as jest.Mock;
+const mockedShouldShowDiscountBanner = shouldShowDiscountBanner as jest.Mock;
+const mockedGetEarlyDiscountInfo = getEarlyDiscountInfo as jest.Mock;
+
+describe('useTimeSensitiveOffers', () => {
+    beforeAll(() => {
+        Onyx.init({keys: ONYXKEYS});
+    });
+
+    beforeEach(async () => {
+        await Onyx.clear();
+        await waitForBatchedUpdates();
+        jest.clearAllMocks();
+    });
+
+    afterEach(async () => {
+        await Onyx.clear();
+    });
+
+    describe('when discount banner should not be shown', () => {
+        it('should return shouldShow50off and shouldShow25off as false when shouldShowDiscountBanner returns false', () => {
+            mockedShouldShowDiscountBanner.mockReturnValue(false);
+            mockedGetEarlyDiscountInfo.mockReturnValue({discountType: 50, days: 5});
+
+            const {result} = renderHook(() => useTimeSensitiveOffers());
+
+            expect(result.current.shouldShow50off).toBe(false);
+            expect(result.current.shouldShow25off).toBe(false);
+        });
+
+        it('should return shouldShow50off and shouldShow25off as false when discountInfo is null', () => {
+            mockedShouldShowDiscountBanner.mockReturnValue(true);
+            mockedGetEarlyDiscountInfo.mockReturnValue(null);
+
+            const {result} = renderHook(() => useTimeSensitiveOffers());
+
+            expect(result.current.shouldShow50off).toBe(false);
+            expect(result.current.shouldShow25off).toBe(false);
+        });
+    });
+
+    describe('when 50% discount should be shown', () => {
+        it('should return shouldShow50off as true when discountType is 50', () => {
+            mockedShouldShowDiscountBanner.mockReturnValue(true);
+            mockedGetEarlyDiscountInfo.mockReturnValue({discountType: 50, days: 1});
+
+            const {result} = renderHook(() => useTimeSensitiveOffers());
+
+            expect(result.current.shouldShow50off).toBe(true);
+            expect(result.current.shouldShow25off).toBe(false);
+        });
+
+        it('should set discountInfo correctly when showing 50% off', () => {
+            mockedShouldShowDiscountBanner.mockReturnValue(true);
+            mockedGetEarlyDiscountInfo.mockReturnValue({discountType: 50, days: 1});
+
+            const {result} = renderHook(() => useTimeSensitiveOffers());
+
+            expect(result.current.discountInfo).toEqual({discountType: 50, days: 1});
+        });
+    });
+
+    describe('when 25% discount should be shown', () => {
+        it('should return shouldShow25off as true when discountType is 25', () => {
+            mockedShouldShowDiscountBanner.mockReturnValue(true);
+            mockedGetEarlyDiscountInfo.mockReturnValue({discountType: 25, days: 5});
+
+            const {result} = renderHook(() => useTimeSensitiveOffers());
+
+            expect(result.current.shouldShow50off).toBe(false);
+            expect(result.current.shouldShow25off).toBe(true);
+        });
+
+        it('should set discountInfo correctly when showing 25% off', () => {
+            mockedShouldShowDiscountBanner.mockReturnValue(true);
+            mockedGetEarlyDiscountInfo.mockReturnValue({discountType: 25, days: 10});
+
+            const {result} = renderHook(() => useTimeSensitiveOffers());
+
+            expect(result.current.discountInfo).toEqual({discountType: 25, days: 10});
+        });
+    });
+
+    describe('discount type exclusivity', () => {
+        it('should only show one discount type at a time (50% takes precedence)', () => {
+            // When discount is 50%, only shouldShow50off should be true
+            mockedShouldShowDiscountBanner.mockReturnValue(true);
+            mockedGetEarlyDiscountInfo.mockReturnValue({discountType: 50, days: 1});
+
+            const {result} = renderHook(() => useTimeSensitiveOffers());
+
+            expect(result.current.shouldShow50off).toBe(true);
+            expect(result.current.shouldShow25off).toBe(false);
+        });
+
+        it('should show 25% when discountType is 25', () => {
+            mockedShouldShowDiscountBanner.mockReturnValue(true);
+            mockedGetEarlyDiscountInfo.mockReturnValue({discountType: 25, days: 5});
+
+            const {result} = renderHook(() => useTimeSensitiveOffers());
+
+            expect(result.current.shouldShow50off).toBe(false);
+            expect(result.current.shouldShow25off).toBe(true);
+        });
+    });
+
+    describe('firstDayFreeTrial data', () => {
+        it('should return firstDayFreeTrial from Onyx', async () => {
+            const testDate = '2026-01-15';
+            await Onyx.merge(ONYXKEYS.NVP_FIRST_DAY_FREE_TRIAL, testDate);
+            await waitForBatchedUpdates();
+
+            mockedShouldShowDiscountBanner.mockReturnValue(false);
+            mockedGetEarlyDiscountInfo.mockReturnValue(null);
+
+            const {result} = renderHook(() => useTimeSensitiveOffers());
+
+            expect(result.current.firstDayFreeTrial).toBe(testDate);
+        });
+
+        it('should return undefined for firstDayFreeTrial when not set in Onyx', () => {
+            mockedShouldShowDiscountBanner.mockReturnValue(false);
+            mockedGetEarlyDiscountInfo.mockReturnValue(null);
+
+            const {result} = renderHook(() => useTimeSensitiveOffers());
+
+            expect(result.current.firstDayFreeTrial).toBeUndefined();
+        });
+    });
+
+    describe('hook dependencies', () => {
+        it('should call shouldShowDiscountBanner with correct parameters', async () => {
+            const firstDayFreeTrial = '2026-01-15';
+            const lastDayFreeTrial = '2026-01-22';
+            const userBillingFundID = 12345;
+
+            await Onyx.merge(ONYXKEYS.NVP_FIRST_DAY_FREE_TRIAL, firstDayFreeTrial);
+            await Onyx.merge(ONYXKEYS.NVP_LAST_DAY_FREE_TRIAL, lastDayFreeTrial);
+            await Onyx.merge(ONYXKEYS.NVP_BILLING_FUND_ID, userBillingFundID);
+            await waitForBatchedUpdates();
+
+            mockedUseHasTeam2025Pricing.mockReturnValue(true);
+            mockedUseSubscriptionPlan.mockReturnValue('team');
+            mockedShouldShowDiscountBanner.mockReturnValue(false);
+            mockedGetEarlyDiscountInfo.mockReturnValue(null);
+
+            renderHook(() => useTimeSensitiveOffers());
+
+            expect(mockedShouldShowDiscountBanner).toHaveBeenCalledWith(
+                true, // hasTeam2025Pricing
+                'team', // subscriptionPlan
+                firstDayFreeTrial,
+                lastDayFreeTrial,
+                userBillingFundID,
+            );
+        });
+
+        it('should call getEarlyDiscountInfo with firstDayFreeTrial', async () => {
+            const firstDayFreeTrial = '2026-01-15';
+
+            await Onyx.merge(ONYXKEYS.NVP_FIRST_DAY_FREE_TRIAL, firstDayFreeTrial);
+            await waitForBatchedUpdates();
+
+            mockedShouldShowDiscountBanner.mockReturnValue(false);
+            mockedGetEarlyDiscountInfo.mockReturnValue(null);
+
+            renderHook(() => useTimeSensitiveOffers());
+
+            expect(mockedGetEarlyDiscountInfo).toHaveBeenCalledWith(firstDayFreeTrial);
+        });
+    });
+
+    describe('other discount types', () => {
+        it('should not show any discount when discountType is neither 50 nor 25', () => {
+            mockedShouldShowDiscountBanner.mockReturnValue(true);
+            mockedGetEarlyDiscountInfo.mockReturnValue({discountType: 10, days: 5}); // Some other discount type
+
+            const {result} = renderHook(() => useTimeSensitiveOffers());
+
+            expect(result.current.shouldShow50off).toBe(false);
+            expect(result.current.shouldShow25off).toBe(false);
+        });
+    });
+});
diff --git a/tests/unit/selectors/CardTest.ts b/tests/unit/selectors/CardTest.ts
index 395ce3b10da51..624077fd14fd6 100644
--- a/tests/unit/selectors/CardTest.ts
+++ b/tests/unit/selectors/CardTest.ts
@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/naming-convention */
-import {defaultExpensifyCardSelector, filterCardsHiddenFromSearch} from '@selectors/Card';
+import {defaultExpensifyCardSelector, filterCardsHiddenFromSearch, timeSensitiveCardsSelector} from '@selectors/Card';
 import type {ValueOf} from 'type-fest';
 import CONST from '@src/CONST';
 import type {Card, CardList} from '@src/types/onyx';
@@ -187,3 +187,271 @@ describe('defaultExpensifyCardSelector', () => {
         });
     });
 });
+
+describe('timeSensitiveCardsSelector', () => {
+    it('returns empty arrays when cardList is undefined or empty', () => {
+        expect(timeSensitiveCardsSelector(undefined)).toEqual({
+            cardsNeedingShippingAddress: [],
+            cardsNeedingActivation: [],
+            cardsWithFraud: [],
+        });
+        expect(timeSensitiveCardsSelector({})).toEqual({
+            cardsNeedingShippingAddress: [],
+            cardsNeedingActivation: [],
+            cardsWithFraud: [],
+        });
+    });
+
+    it('returns empty arrays when no physical Expensify cards need action', () => {
+        const cardList: CardList = {
+            '1': createRandomExpensifyCard(1, {state: CONST.EXPENSIFY_CARD.STATE.OPEN, fraud: CONST.EXPENSIFY_CARD.FRAUD_TYPES.NONE}),
+            '2': createRandomExpensifyCard(2, {state: CONST.EXPENSIFY_CARD.STATE.CLOSED, fraud: CONST.EXPENSIFY_CARD.FRAUD_TYPES.NONE}),
+        };
+
+        const result = timeSensitiveCardsSelector(cardList);
+
+        expect(result.cardsNeedingShippingAddress).toHaveLength(0);
+        expect(result.cardsNeedingActivation).toHaveLength(0);
+        expect(result.cardsWithFraud).toHaveLength(0);
+    });
+
+    it('identifies cards needing shipping address (STATE_NOT_ISSUED)', () => {
+        const cardNeedingShipping = createRandomExpensifyCard(1, {state: CONST.EXPENSIFY_CARD.STATE.STATE_NOT_ISSUED});
+        const openCard = createRandomExpensifyCard(2, {state: CONST.EXPENSIFY_CARD.STATE.OPEN});
+
+        const cardList: CardList = {
+            '1': cardNeedingShipping,
+            '2': openCard,
+        };
+
+        const result = timeSensitiveCardsSelector(cardList);
+
+        expect(result.cardsNeedingShippingAddress).toHaveLength(1);
+        expect(result.cardsNeedingShippingAddress[0].cardID).toBe(1);
+        expect(result.cardsNeedingActivation).toHaveLength(0);
+    });
+
+    it('identifies cards needing activation (NOT_ACTIVATED)', () => {
+        const cardNeedingActivation = createRandomExpensifyCard(1, {state: CONST.EXPENSIFY_CARD.STATE.NOT_ACTIVATED});
+        const openCard = createRandomExpensifyCard(2, {state: CONST.EXPENSIFY_CARD.STATE.OPEN});
+
+        const cardList: CardList = {
+            '1': cardNeedingActivation,
+            '2': openCard,
+        };
+
+        const result = timeSensitiveCardsSelector(cardList);
+
+        expect(result.cardsNeedingShippingAddress).toHaveLength(0);
+        expect(result.cardsNeedingActivation).toHaveLength(1);
+        expect(result.cardsNeedingActivation[0].cardID).toBe(1);
+    });
+
+    it('identifies multiple cards needing different actions', () => {
+        const cardNeedingShipping1 = createRandomExpensifyCard(1, {state: CONST.EXPENSIFY_CARD.STATE.STATE_NOT_ISSUED});
+        const cardNeedingShipping2 = createRandomExpensifyCard(2, {state: CONST.EXPENSIFY_CARD.STATE.STATE_NOT_ISSUED});
+        const cardNeedingActivation1 = createRandomExpensifyCard(3, {state: CONST.EXPENSIFY_CARD.STATE.NOT_ACTIVATED});
+        const cardNeedingActivation2 = createRandomExpensifyCard(4, {state: CONST.EXPENSIFY_CARD.STATE.NOT_ACTIVATED});
+        const openCard = createRandomExpensifyCard(5, {state: CONST.EXPENSIFY_CARD.STATE.OPEN});
+
+        const cardList: CardList = {
+            '1': cardNeedingShipping1,
+            '2': cardNeedingShipping2,
+            '3': cardNeedingActivation1,
+            '4': cardNeedingActivation2,
+            '5': openCard,
+        };
+
+        const result = timeSensitiveCardsSelector(cardList);
+
+        expect(result.cardsNeedingShippingAddress).toHaveLength(2);
+        expect(result.cardsNeedingActivation).toHaveLength(2);
+    });
+
+    it('excludes virtual Expensify cards from time-sensitive results', () => {
+        const virtualCardNeedingActivation: Card = {
+            ...createRandomExpensifyCard(1, {state: CONST.EXPENSIFY_CARD.STATE.NOT_ACTIVATED}),
+            nameValuePairs: {isVirtual: true} as Card['nameValuePairs'],
+        };
+        const physicalCardNeedingActivation = createRandomExpensifyCard(2, {state: CONST.EXPENSIFY_CARD.STATE.NOT_ACTIVATED});
+
+        const cardList: CardList = {
+            '1': virtualCardNeedingActivation,
+            '2': physicalCardNeedingActivation,
+        };
+
+        const result = timeSensitiveCardsSelector(cardList);
+
+        expect(result.cardsNeedingActivation).toHaveLength(1);
+        expect(result.cardsNeedingActivation[0].cardID).toBe(2);
+    });
+
+    it('excludes non-Expensify cards (company cards) from time-sensitive results', () => {
+        const companyCard = createRandomCompanyCard(1, {bank: 'vcf'});
+        // Manually set state to match pending issue
+        const companyCardWithPendingState: Card = {
+            ...companyCard,
+            state: CONST.EXPENSIFY_CARD.STATE.STATE_NOT_ISSUED,
+        };
+        const expensifyCardNeedingShipping = createRandomExpensifyCard(2, {state: CONST.EXPENSIFY_CARD.STATE.STATE_NOT_ISSUED});
+
+        const cardList: CardList = {
+            '1': companyCardWithPendingState,
+            '2': expensifyCardNeedingShipping,
+        };
+
+        const result = timeSensitiveCardsSelector(cardList);
+
+        expect(result.cardsNeedingShippingAddress).toHaveLength(1);
+        expect(result.cardsNeedingShippingAddress[0].cardID).toBe(2);
+    });
+
+    it('filters out invalid card objects (missing cardID or bank)', () => {
+        const validCard = createRandomExpensifyCard(1, {state: CONST.EXPENSIFY_CARD.STATE.STATE_NOT_ISSUED});
+        const invalidCard1 = {cardID: 2, state: CONST.EXPENSIFY_CARD.STATE.STATE_NOT_ISSUED} as Card;
+        const invalidCard2 = {bank: CONST.EXPENSIFY_CARD.BANK, state: CONST.EXPENSIFY_CARD.STATE.STATE_NOT_ISSUED} as Card;
+
+        const cardList: CardList = {
+            '1': validCard,
+            '2': invalidCard1,
+            '3': invalidCard2,
+        };
+
+        const result = timeSensitiveCardsSelector(cardList);
+
+        expect(result.cardsNeedingShippingAddress).toHaveLength(1);
+        expect(result.cardsNeedingShippingAddress[0].cardID).toBe(1);
+    });
+
+    it('handles mixed scenarios with various card types and states', () => {
+        const physicalExpensifyNeedingShipping = createRandomExpensifyCard(1, {state: CONST.EXPENSIFY_CARD.STATE.STATE_NOT_ISSUED});
+        const physicalExpensifyNeedingActivation = createRandomExpensifyCard(2, {state: CONST.EXPENSIFY_CARD.STATE.NOT_ACTIVATED});
+        const physicalExpensifyOpen = createRandomExpensifyCard(3, {state: CONST.EXPENSIFY_CARD.STATE.OPEN});
+        const virtualExpensifyNeedingActivation: Card = {
+            ...createRandomExpensifyCard(4, {state: CONST.EXPENSIFY_CARD.STATE.NOT_ACTIVATED}),
+            nameValuePairs: {isVirtual: true} as Card['nameValuePairs'],
+        };
+        const companyCard = createRandomCompanyCard(5, {bank: 'vcf'});
+        const suspendedCard = createRandomExpensifyCard(6, {state: CONST.EXPENSIFY_CARD.STATE.STATE_SUSPENDED});
+        const closedCard = createRandomExpensifyCard(7, {state: CONST.EXPENSIFY_CARD.STATE.CLOSED});
+
+        const cardList: CardList = {
+            '1': physicalExpensifyNeedingShipping,
+            '2': physicalExpensifyNeedingActivation,
+            '3': physicalExpensifyOpen,
+            '4': virtualExpensifyNeedingActivation,
+            '5': companyCard,
+            '6': suspendedCard,
+            '7': closedCard,
+        };
+
+        const result = timeSensitiveCardsSelector(cardList);
+
+        // Only physical Expensify cards with pending states should be included
+        expect(result.cardsNeedingShippingAddress).toHaveLength(1);
+        expect(result.cardsNeedingShippingAddress[0].cardID).toBe(1);
+        expect(result.cardsNeedingActivation).toHaveLength(1);
+        expect(result.cardsNeedingActivation[0].cardID).toBe(2);
+    });
+
+    it('returns cards in correct arrays based on their state', () => {
+        // Cards with STATE_NOT_ISSUED should be in cardsNeedingShippingAddress
+        // Cards with NOT_ACTIVATED should be in cardsNeedingActivation
+        const pendingIssueCard = createRandomExpensifyCard(1, {state: CONST.EXPENSIFY_CARD.STATE.STATE_NOT_ISSUED});
+        const pendingActivateCard = createRandomExpensifyCard(2, {state: CONST.EXPENSIFY_CARD.STATE.NOT_ACTIVATED});
+
+        const cardList: CardList = {
+            '1': pendingIssueCard,
+            '2': pendingActivateCard,
+        };
+
+        const result = timeSensitiveCardsSelector(cardList);
+
+        // Verify STATE_NOT_ISSUED (2) goes to cardsNeedingShippingAddress
+        expect(result.cardsNeedingShippingAddress.every((card) => card.state === CONST.EXPENSIFY_CARD.STATE.STATE_NOT_ISSUED)).toBe(true);
+
+        // Verify NOT_ACTIVATED (4) goes to cardsNeedingActivation
+        expect(result.cardsNeedingActivation.every((card) => card.state === CONST.EXPENSIFY_CARD.STATE.NOT_ACTIVATED)).toBe(true);
+    });
+
+    it('identifies cards with domain fraud', () => {
+        const cardWithDomainFraud = createRandomExpensifyCard(1, {state: CONST.EXPENSIFY_CARD.STATE.OPEN, fraud: CONST.EXPENSIFY_CARD.FRAUD_TYPES.DOMAIN});
+        const normalCard = createRandomExpensifyCard(2, {state: CONST.EXPENSIFY_CARD.STATE.OPEN, fraud: CONST.EXPENSIFY_CARD.FRAUD_TYPES.NONE});
+
+        const cardList: CardList = {
+            '1': cardWithDomainFraud,
+            '2': normalCard,
+        };
+
+        const result = timeSensitiveCardsSelector(cardList);
+
+        expect(result.cardsWithFraud).toHaveLength(1);
+        expect(result.cardsWithFraud[0].cardID).toBe(1);
+        expect(result.cardsWithFraud[0].fraud).toBe(CONST.EXPENSIFY_CARD.FRAUD_TYPES.DOMAIN);
+    });
+
+    it('identifies cards with individual fraud', () => {
+        const cardWithIndividualFraud = createRandomExpensifyCard(1, {state: CONST.EXPENSIFY_CARD.STATE.OPEN, fraud: CONST.EXPENSIFY_CARD.FRAUD_TYPES.INDIVIDUAL});
+        const normalCard = createRandomExpensifyCard(2, {state: CONST.EXPENSIFY_CARD.STATE.OPEN, fraud: CONST.EXPENSIFY_CARD.FRAUD_TYPES.NONE});
+
+        const cardList: CardList = {
+            '1': cardWithIndividualFraud,
+            '2': normalCard,
+        };
+
+        const result = timeSensitiveCardsSelector(cardList);
+
+        expect(result.cardsWithFraud).toHaveLength(1);
+        expect(result.cardsWithFraud[0].cardID).toBe(1);
+        expect(result.cardsWithFraud[0].fraud).toBe(CONST.EXPENSIFY_CARD.FRAUD_TYPES.INDIVIDUAL);
+    });
+
+    it('detects fraud on both physical and virtual Expensify cards', () => {
+        const physicalCardWithFraud = createRandomExpensifyCard(1, {state: CONST.EXPENSIFY_CARD.STATE.OPEN, fraud: CONST.EXPENSIFY_CARD.FRAUD_TYPES.DOMAIN});
+        const virtualCardWithFraud: Card = {
+            ...createRandomExpensifyCard(2, {state: CONST.EXPENSIFY_CARD.STATE.OPEN, fraud: CONST.EXPENSIFY_CARD.FRAUD_TYPES.INDIVIDUAL}),
+            nameValuePairs: {isVirtual: true} as Card['nameValuePairs'],
+        };
+
+        const cardList: CardList = {
+            '1': physicalCardWithFraud,
+            '2': virtualCardWithFraud,
+        };
+
+        const result = timeSensitiveCardsSelector(cardList);
+
+        // Both physical and virtual cards with fraud should be included
+        expect(result.cardsWithFraud).toHaveLength(2);
+    });
+
+    it('excludes non-Expensify cards from fraud detection', () => {
+        const companyCardWithFraud: Card = {
+            ...createRandomCompanyCard(1, {bank: 'vcf'}),
+            fraud: CONST.EXPENSIFY_CARD.FRAUD_TYPES.DOMAIN,
+        };
+        const expensifyCardWithFraud = createRandomExpensifyCard(2, {state: CONST.EXPENSIFY_CARD.STATE.OPEN, fraud: CONST.EXPENSIFY_CARD.FRAUD_TYPES.DOMAIN});
+
+        const cardList: CardList = {
+            '1': companyCardWithFraud,
+            '2': expensifyCardWithFraud,
+        };
+
+        const result = timeSensitiveCardsSelector(cardList);
+
+        // Only Expensify card should be included
+        expect(result.cardsWithFraud).toHaveLength(1);
+        expect(result.cardsWithFraud[0].cardID).toBe(2);
+    });
+
+    it('does not include cards with fraud type NONE', () => {
+        const cardWithNoFraud = createRandomExpensifyCard(1, {state: CONST.EXPENSIFY_CARD.STATE.OPEN, fraud: CONST.EXPENSIFY_CARD.FRAUD_TYPES.NONE});
+
+        const cardList: CardList = {
+            '1': cardWithNoFraud,
+        };
+
+        const result = timeSensitiveCardsSelector(cardList);
+
+        expect(result.cardsWithFraud).toHaveLength(0);
+    });
+});