diff --git a/package-lock.json b/package-lock.json
index 719066a..19b69f1 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -18,7 +18,7 @@
         "jotai": "^2.12.4",
         "localforage": "^1.10.0",
         "mediainfo.js": "^0.3.6",
-        "qapp-core": "^1.0.76",
+        "qapp-core": "^1.0.79",
         "quill-image-resize-module-react": "^3.0.0",
         "react": "^19.0.0",
         "react-dom": "^19.0.0",
@@ -5177,9 +5177,9 @@
       }
     },
     "node_modules/qapp-core": {
-      "version": "1.0.76",
-      "resolved": "https://registry.npmjs.org/qapp-core/-/qapp-core-1.0.76.tgz",
-      "integrity": "sha512-Jt7f+ma3jM7NorrS6DRrbO9eP24UdEybqL9K4reXfEm02g1DDfIQotbYKxHiLEYojdsqgAOFt3MX0K/S8ZyMQg==",
+      "version": "1.0.79",
+      "resolved": "https://registry.npmjs.org/qapp-core/-/qapp-core-1.0.79.tgz",
+      "integrity": "sha512-UJi4xAmHB6z63mKtydggZbm7XV9HoWKUWBZ/QSt75clcvJRWsODvMtlq1kHuL19es+t6y5AzaMjOju/lXJpj2g==",
       "license": "MIT",
       "dependencies": {
         "@tanstack/react-virtual": "^3.13.2",
diff --git a/package.json b/package.json
index 3029de4..d8cabab 100644
--- a/package.json
+++ b/package.json
@@ -27,7 +27,7 @@
     "jotai": "^2.12.4",
     "localforage": "^1.10.0",
     "mediainfo.js": "^0.3.6",
-    "qapp-core": "^1.0.76",
+    "qapp-core": "^1.0.79",
     "quill-image-resize-module-react": "^3.0.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
diff --git a/src/components/Feed.tsx b/src/components/Feed.tsx
index cb69e9e..d96ce5b 100644
--- a/src/components/Feed.tsx
+++ b/src/components/Feed.tsx
@@ -15,6 +15,7 @@ import {
   ENTITY_REPLY,
   ENTITY_REPOST,
   ENTITY_ROOT,
+  DISABLE_SUBSCRIPTIONS,
   GROUP_PRIVATE,
   LIST_POSTS_FEED,
   LIST_POSTS_FEED_FOLLOWING_SUB,
@@ -317,7 +318,6 @@ export function Feed({
     null
   );
   const [followingNames, setFollowingNames] = useState<string[] | null>(null);
-
   // Access group owner primary names on the fly without dependency
   const groupOwnerNames = useAtomValue(groupOwnerPrimaryNamesAtom);
   const [primaryNamesGroup, setPrimaryNamesGroup] = useState<string[] | null>(
@@ -340,11 +340,10 @@ export function Feed({
     if (isLoadingGroupOwnerNames) return;
     const buildPrefix = async () => {
       if (!identifierOperations) return;
-      if (memberGroups === null) return;
+      if (!DISABLE_SUBSCRIPTIONS && memberGroups === null) return;
 
       try {
         const followedNames = await fetchFollowedNames();
-
         setFollowingNames(followedNames);
         const prefix = await identifierOperations.buildSearchPrefix(
           ENTITY_POST,
@@ -362,17 +361,24 @@ export function Feed({
           ENTITY_REPOST,
           ''
         );
+        setRepostSearchPrefix(repostPrefix);
+        if (DISABLE_SUBSCRIPTIONS) {
+          setGroupSearchPrefix(null);
+          setPrimaryNamesGroup([]);
+          setGroupSearchPrefixes([]);
+          return;
+        }
+
         const groupPrefix = await identifierOperations.buildSearchPrefix(
           null,
           '',
           GROUP_PRIVATE
         );
 
-        setRepostSearchPrefix(repostPrefix);
         setGroupSearchPrefix(groupPrefix);
         setPrimaryNamesGroup(groupOwnerNames);
 
-        const groupIds = Array.from(memberGroups.keys());
+        const groupIds = Array.from(memberGroups?.keys() || []);
         if (groupIds.length > 0) {
           const groupSearchPrefixesResponses = await Promise.all(
             groupIds.map(async (groupId) => {
@@ -391,7 +397,13 @@ export function Feed({
     };
 
     buildPrefix();
-  }, [identifierOperations, isLoadingGroupOwnerNames, memberGroups]);
+  }, [
+    fetchFollowedNames,
+    groupOwnerNames,
+    identifierOperations,
+    isLoadingGroupOwnerNames,
+    memberGroups,
+  ]);
 
   const loaderItem = useCallback(() => {
     return <LoaderItem />;
@@ -474,8 +486,7 @@ export function Feed({
       !followingNames ||
       !replySearchPrefix ||
       !repostSearchPrefix ||
-      !primaryNamesGroup ||
-      !groupSearchPrefix
+      (!DISABLE_SUBSCRIPTIONS && (!primaryNamesGroup || !groupSearchPrefix))
     )
       return undefined;
 
@@ -571,7 +582,7 @@ export function Feed({
     !intervalSearch ||
     !searchPrefix ||
     !replySearchPrefix ||
-    !groupSearchPrefix ||
+    (!DISABLE_SUBSCRIPTIONS && !groupSearchPrefix) ||
     !repostSearchPrefix
   ) {
     return (
@@ -698,7 +709,7 @@ export function Feed({
             disabled={!isAuthenticated}
           >
             <PeopleIcon />
-            Following & Subs
+            {DISABLE_SUBSCRIPTIONS ? 'Following' : 'Following & Subs'}
           </StyledToggleButton>
         </StyledToggleButtonGroup>
       </FilterContainer>
@@ -743,6 +754,7 @@ export function Feed({
               searchNewData={undefined}
               onNewData={onNewData}
               ref={helperListMethodsRef}
+              isLoading={isLoadingChangeFeedType}
             />
           </>
         ) : (
@@ -778,6 +790,7 @@ export function Feed({
             }
             onNewData={onNewData}
             ref={helperListMethodsRef}
+            isLoading={isLoadingChangeFeedType}
           />
         )}
       </PostsContainer>
diff --git a/src/components/MobileNavigation.tsx b/src/components/MobileNavigation.tsx
index 2d0cc87..a3d4ba2 100644
--- a/src/components/MobileNavigation.tsx
+++ b/src/components/MobileNavigation.tsx
@@ -13,6 +13,7 @@ import { useState } from 'react';
 import { useAtomValue } from 'jotai';
 import { hasUnreadNotificationsAtom } from '../state/global/notifications';
 import { isPublicNodeAtom } from '../state/global/system';
+import { DISABLE_SUBSCRIPTIONS } from '../constants/qdn';
 import { useGlobal } from 'qapp-core';
 import { NameSwitcher } from './NameSwitcher';
 
@@ -174,7 +175,7 @@ export function MobileNavigation({
       page === 'profile' ||
       page === 'notifications' ||
       page === 'blocked' ||
-      page === 'groups'
+      (!DISABLE_SUBSCRIPTIONS && page === 'groups')
     ) {
       if (!auth?.name) return;
     }
@@ -195,7 +196,7 @@ export function MobileNavigation({
       page === 'profile' ||
       page === 'notifications' ||
       page === 'blocked' ||
-      page === 'groups'
+      (!DISABLE_SUBSCRIPTIONS && page === 'groups')
     ) {
       if (!auth?.name) return;
     }
@@ -312,17 +313,18 @@ export function MobileNavigation({
             </MenuButton>
           )}
 
-          <MenuButton
-            active={activePage === 'groups'}
-            onClick={() => handleMenuItemClick('groups')}
-            disabled={!auth?.name}
-          >
-            <GroupsIcon />
-            Subscriptions
-          </MenuButton>
+          {!DISABLE_SUBSCRIPTIONS && (
+            <MenuButton
+              active={activePage === 'groups'}
+              onClick={() => handleMenuItemClick('groups')}
+              disabled={!auth?.name}
+            >
+              <GroupsIcon />
+              Subscriptions
+            </MenuButton>
+          )}
         </DrawerContent>
       </Drawer>
     </>
   );
 }
-
diff --git a/src/components/NewPostInput.tsx b/src/components/NewPostInput.tsx
index cd5a080..a55ff71 100644
--- a/src/components/NewPostInput.tsx
+++ b/src/components/NewPostInput.tsx
@@ -32,6 +32,7 @@ import { showError } from 'qapp-core';
 import { useAtomValue } from 'jotai';
 import { attachedGroupsAtom, ownedGroupsAtom } from '../state/global/profile';
 import { AttachedGroup } from '../utils/profileQdn';
+import { DISABLE_SUBSCRIPTIONS } from '../constants/qdn';
 
 // Declare qortalRequest as a global function (provided by Qortal runtime)
 
@@ -444,11 +445,17 @@ export function NewPostInput({
   const [showEmojiPicker, setShowEmojiPicker] = useState(false);
   // Set initial visibility based on replyingToGroupId (for encrypted replies) or editingPostGroupId (for editing)
   const [visibility, setVisibility] = useState<string>(
-    replyingToGroupId?.toString() || editingPostGroupId?.toString() || 'public'
+    DISABLE_SUBSCRIPTIONS
+      ? 'public'
+      : replyingToGroupId?.toString() ||
+          editingPostGroupId?.toString() ||
+          'public'
   );
 
   // Enrich attached groups with groupName from ownedGroups if missing
   const enrichedAttachedGroups = useMemo(() => {
+    if (DISABLE_SUBSCRIPTIONS) return [];
+
     const groups = attachedGroups
       .filter((item) => !!ownedGroups.find((g) => g.groupId === item))
       .map((attachedGroup) => {
@@ -526,7 +533,9 @@ export function NewPostInput({
       setText(initialText);
       setMedia(initialMedia);
       // Set visibility based on editingPostGroupId
-      if (editingPostGroupId) {
+      if (DISABLE_SUBSCRIPTIONS) {
+        setVisibility('public');
+      } else if (editingPostGroupId) {
         setVisibility(editingPostGroupId.toString());
       } else {
         setVisibility('public');
@@ -668,7 +677,9 @@ export function NewPostInput({
       try {
         // Get groupId from visibility if it's not 'public'
         const selectedGroupId =
-          visibility !== 'public' ? parseInt(visibility) : undefined;
+          !DISABLE_SUBSCRIPTIONS && visibility !== 'public'
+            ? parseInt(visibility)
+            : undefined;
 
         await onPost({
           text,
@@ -1444,7 +1455,7 @@ export function NewPostInput({
             </MediaActions>
             <Box sx={{ display: 'flex', alignItems: 'center', gap: 1 }}>
               {/* Only show visibility selector when creating a new post (not editing or replying) */}
-              {!isEditing && !isReplying && (
+              {!DISABLE_SUBSCRIPTIONS && !isEditing && !isReplying && (
                 <VisibilitySelector size="small">
                   <Select
                     value={visibility}
diff --git a/src/components/PostPage.tsx b/src/components/PostPage.tsx
index 2903823..b7f345b 100644
--- a/src/components/PostPage.tsx
+++ b/src/components/PostPage.tsx
@@ -13,6 +13,7 @@ import {
   usePublish,
 } from 'qapp-core';
 import {
+  DISABLE_SUBSCRIPTIONS,
   ENTITY_POST,
   ENTITY_REPLY,
   ENTITY_REPLY_PRIVATE,
@@ -288,7 +289,7 @@ export function PostPage({
         resource.qortalMetadata.identifier,
         resource.qortalMetadata.name,
         content,
-        resource.data?.groupId // Pass groupId for encrypted replies
+        DISABLE_SUBSCRIPTIONS ? undefined : resource.data?.groupId
       );
     },
     [resource, onNewReply]
@@ -401,7 +402,9 @@ export function PostPage({
             userName={userName}
             isPublishing={isPublishing}
             placeholder="Post your reply..."
-            replyingToGroupId={currentPost?.groupId}
+            replyingToGroupId={
+              DISABLE_SUBSCRIPTIONS ? undefined : currentPost?.groupId
+            }
             isReplying={true}
           />
         </ReplyInputContainer>
@@ -425,7 +428,7 @@ export function PostPage({
           returnType="JSON"
           loaderList={loaderList}
           entityParams={{
-            entityType: currentPost?.groupId
+            entityType: !DISABLE_SUBSCRIPTIONS && currentPost?.groupId
               ? ENTITY_REPLY_PRIVATE
               : ENTITY_REPLY,
             parentId: postId,
diff --git a/src/components/Sidebar.tsx b/src/components/Sidebar.tsx
index 18988e6..ea267ff 100644
--- a/src/components/Sidebar.tsx
+++ b/src/components/Sidebar.tsx
@@ -5,13 +5,17 @@ import PersonIcon from '@mui/icons-material/Person';
 import NotificationsIcon from '@mui/icons-material/Notifications';
 import BlockIcon from '@mui/icons-material/Block';
 import GroupsIcon from '@mui/icons-material/Groups';
+import NotificationsActiveIcon from '@mui/icons-material/NotificationsActive';
 import { Badge } from '@mui/material';
 import { NameSwitcher } from './NameSwitcher';
 import { WhatsHappening } from './WhatsHappening';
-import { useAtom, useAtomValue } from 'jotai';
+import { useAtom, useAtomValue, useSetAtom } from 'jotai';
 import {
   notificationsAtom,
   hasUnreadNotificationsAtom,
+  hubNotificationSupportedAtom,
+  notificationPermissionAtom,
+  declinedNotificationPermissionAtom,
 } from '../state/global/notifications';
 import { isPublicNodeAtom } from '../state/global/system';
 import { useGlobal } from 'qapp-core';
@@ -20,6 +24,7 @@ import {
   getLastViewedTimestamp,
   setLastViewedNotificationsTimestamp,
 } from '../utils/notificationTimestamp';
+import { DISABLE_SUBSCRIPTIONS } from '../constants/qdn';
 
 const SidebarContainer = styled('div')(({ theme }) => ({
   width: '290px',
@@ -163,6 +168,88 @@ const TweetButtonIcon = styled('span')(({ theme }) => ({
   },
 }));
 
+const EnableNotificationsCard = styled('button')(({ theme }) => ({
+  display: 'flex',
+  alignItems: 'center',
+  gap: theme.spacing(1.5),
+  padding: theme.spacing(1.5, 2),
+  borderRadius: '16px',
+  border: `1px solid ${theme.palette.mode === 'dark' ? 'rgba(29, 155, 240, 0.35)' : 'rgba(29, 155, 240, 0.3)'}`,
+  background:
+    theme.palette.mode === 'dark'
+      ? 'linear-gradient(135deg, rgba(29,155,240,0.08) 0%, rgba(29,155,240,0.03) 100%)'
+      : 'linear-gradient(135deg, rgba(29,155,240,0.07) 0%, rgba(29,155,240,0.02) 100%)',
+  cursor: 'pointer',
+  textAlign: 'left',
+  width: '100%',
+  transition: 'all 0.25s ease',
+  '&:hover': {
+    borderColor: theme.palette.primary.main,
+    background:
+      theme.palette.mode === 'dark'
+        ? 'linear-gradient(135deg, rgba(29,155,240,0.18) 0%, rgba(29,155,240,0.08) 100%)'
+        : 'linear-gradient(135deg, rgba(29,155,240,0.14) 0%, rgba(29,155,240,0.06) 100%)',
+    transform: 'translateY(-1px)',
+    boxShadow:
+      theme.palette.mode === 'dark'
+        ? '0 4px 16px rgba(29,155,240,0.2)'
+        : '0 4px 16px rgba(29,155,240,0.15)',
+  },
+  '&:active': {
+    transform: 'scale(0.98)',
+  },
+  [theme.breakpoints.down('md')]: {
+    width: '52px',
+    height: '52px',
+    justifyContent: 'center',
+    padding: theme.spacing(1.5),
+    borderRadius: '50%',
+  },
+}));
+
+const EnableNotificationsIconWrap = styled('span')(() => ({
+  display: 'flex',
+  alignItems: 'center',
+  justifyContent: 'center',
+  flexShrink: 0,
+  '@keyframes bellRing': {
+    '0%, 100%': { transform: 'rotate(0deg)' },
+    '15%': { transform: 'rotate(15deg)' },
+    '30%': { transform: 'rotate(-12deg)' },
+    '45%': { transform: 'rotate(10deg)' },
+    '60%': { transform: 'rotate(-8deg)' },
+    '75%': { transform: 'rotate(5deg)' },
+  },
+  '& svg': {
+    color: '#1d9bf0',
+    fontSize: '22px',
+    animation: 'bellRing 3s ease-in-out infinite',
+  },
+}));
+
+const EnableNotificationsText = styled('span')(({ theme }) => ({
+  display: 'flex',
+  flexDirection: 'column',
+  gap: '1px',
+  [theme.breakpoints.down('md')]: {
+    display: 'none',
+  },
+}));
+
+const EnableNotificationsTitle = styled('span')(({ theme }) => ({
+  fontSize: '14px',
+  fontWeight: 600,
+  color: theme.palette.primary.main,
+  lineHeight: 1.3,
+}));
+
+const EnableNotificationsSubtitle = styled('span')(({ theme }) => ({
+  fontSize: '11px',
+  fontWeight: 400,
+  color: theme.palette.text.secondary,
+  lineHeight: 1.3,
+}));
+
 interface SidebarProps {
   onNavigate?: (page: string) => void;
   onTweet?: () => void;
@@ -172,6 +259,8 @@ interface SidebarProps {
   activePage?: string;
 }
 
+declare const qortalRequest: (params: any) => Promise<any>;
+
 export function Sidebar({
   onNavigate = () => {},
   onTweet = () => {},
@@ -181,6 +270,31 @@ export function Sidebar({
   const notifications = useAtomValue(notificationsAtom);
   const [hasUnread, setHasUnread] = useAtom(hasUnreadNotificationsAtom);
   const isPublicNode = useAtomValue(isPublicNodeAtom);
+  const hubSupported = useAtomValue(hubNotificationSupportedAtom);
+  const notificationPermission = useAtomValue(notificationPermissionAtom);
+  const setNotificationPermission = useSetAtom(notificationPermissionAtom);
+  const [, setDeclinedMap] = useAtom(declinedNotificationPermissionAtom);
+
+  const address = auth?.address;
+  const showEnableNotifications =
+    hubSupported && !notificationPermission && !!address;
+
+  const handleEnableHubNotifications = async () => {
+    if (!address) return;
+    try {
+      const result = await qortalRequest({ action: 'NOTIFICATION_PERMISSION' });
+      if (result) {
+        setNotificationPermission(true);
+        setDeclinedMap((prev) => {
+          const next = { ...prev };
+          delete next[address];
+          return next;
+        });
+      }
+    } catch (error) {
+      console.error('Notification permission declined or errored:', error);
+    }
+  };
 
   // Check for unread notifications
   useEffect(() => {
@@ -297,14 +411,16 @@ export function Sidebar({
           <NavLabel>Blocked Users</NavLabel>
         </NavButton>
       )}
-      <NavButton
-        active={activePage === 'groups'}
-        onClick={() => onNavigate('groups')}
-        disabled={!auth?.name}
-      >
-        <GroupsIcon />
-        <NavLabel>Subscriptions</NavLabel>
-      </NavButton>
+      {!DISABLE_SUBSCRIPTIONS && (
+        <NavButton
+          active={activePage === 'groups'}
+          onClick={() => onNavigate('groups')}
+          disabled={!auth?.name}
+        >
+          <GroupsIcon />
+          <NavLabel>Subscriptions</NavLabel>
+        </NavButton>
+      )}
       {/* <NavButton onClick={() => onNavigate('more')}>
         <MoreHorizIcon />
         <NavLabel>More</NavLabel>
@@ -315,6 +431,22 @@ export function Sidebar({
         <TweetButtonIcon>+</TweetButtonIcon>
       </TweetButton>
 
+      {showEnableNotifications && (
+        <EnableNotificationsCard onClick={handleEnableHubNotifications}>
+          <EnableNotificationsIconWrap>
+            <NotificationsActiveIcon />
+          </EnableNotificationsIconWrap>
+          <EnableNotificationsText>
+            <EnableNotificationsTitle>
+              Enable Hub notifications
+            </EnableNotificationsTitle>
+            <EnableNotificationsSubtitle>
+              Get notified about mentions &amp; replies
+            </EnableNotificationsSubtitle>
+          </EnableNotificationsText>
+        </EnableNotificationsCard>
+      )}
+
       <Spacer />
 
       <NameSwitcher />
diff --git a/src/components/SocialApp.tsx b/src/components/SocialApp.tsx
index 69c6034..65790e0 100644
--- a/src/components/SocialApp.tsx
+++ b/src/components/SocialApp.tsx
@@ -60,6 +60,9 @@ import {
   handleFollowUser,
   handleUnfollowUser,
 } from '../utils/followingHelpers';
+import { DISABLE_SUBSCRIPTIONS } from '../constants/qdn';
+
+import { updateFollowingPostsNotification } from '../hooks/useMentionNotificationRegistration';
 
 // Declare qortalRequest as a global function (provided by Qortal runtime)
 
@@ -352,6 +355,12 @@ export function SocialApp({ userName = 'User', userAvatar }: SocialAppProps) {
     useBlockedNames();
 
   // Auto-fetch blocked names when user authenticates
+  useEffect(() => {
+    if (DISABLE_SUBSCRIPTIONS && location.pathname === '/groups') {
+      navigate('/', { replace: true });
+    }
+  }, [location.pathname, navigate]);
+
   useEffect(() => {
     if (auth?.name && !hasBlockedNamesFetched) {
       refetchBlockedNames();
@@ -458,7 +467,8 @@ export function SocialApp({ userName = 'User', userAvatar }: SocialAppProps) {
   const isSearchPage = location.pathname.startsWith('/search');
   const isNotificationsPage = location.pathname === '/notifications';
   const isBlockedUsersPage = location.pathname === '/blocked';
-  const isGroupsPage = location.pathname === '/groups';
+  const isGroupsPage =
+    !DISABLE_SUBSCRIPTIONS && location.pathname === '/groups';
   const isOwnProfile = isUserPage && params.userName === auth?.name;
   const isFeedPage =
     !isPostPage &&
@@ -483,7 +493,7 @@ export function SocialApp({ userName = 'User', userAvatar }: SocialAppProps) {
       navigate('/notifications');
     } else if (page === 'blocked') {
       navigate('/blocked');
-    } else if (page === 'groups') {
+    } else if (!DISABLE_SUBSCRIPTIONS && page === 'groups') {
       navigate('/groups');
     }
   };
@@ -976,6 +986,12 @@ export function SocialApp({ userName = 'User', userAvatar }: SocialAppProps) {
         showSuccess(`You are now following @${targetUserName}`);
         // Refetch the follows list to update the UI
         await refetchFollows();
+        updateFollowingPostsNotification(
+          auth.name,
+          identifierOperations,
+          targetUserName,
+          'follow'
+        );
       } catch (error) {
         console.error('Error following user:', error);
         showError(
@@ -1015,6 +1031,12 @@ export function SocialApp({ userName = 'User', userAvatar }: SocialAppProps) {
         showSuccess(`You unfollowed @${targetUserName}`);
         // Refetch the follows list to update the UI
         await refetchFollows();
+        updateFollowingPostsNotification(
+          auth.name,
+          identifierOperations,
+          targetUserName,
+          'unfollow'
+        );
       } catch (error) {
         console.error('Error unfollowing user:', error);
         showError(
diff --git a/src/components/UserFeed.tsx b/src/components/UserFeed.tsx
index 2302b47..882c1cd 100644
--- a/src/components/UserFeed.tsx
+++ b/src/components/UserFeed.tsx
@@ -23,6 +23,7 @@ import {
 import { PostData } from './Post';
 import { PostWrapper } from './PostWrapper';
 import {
+  DISABLE_SUBSCRIPTIONS,
   ENTITY_POST,
   ENTITY_ROOT,
   ENTITY_REPLY,
@@ -406,7 +407,9 @@ export function UserFeed({
   // Determine active tab from route
   const getActiveTab = () => {
     if (location.pathname.endsWith('/replies')) return 'replies';
-    if (location.pathname.endsWith('/group-posts')) return 'group-posts';
+    if (!DISABLE_SUBSCRIPTIONS && location.pathname.endsWith('/group-posts')) {
+      return 'group-posts';
+    }
     if (location.pathname.endsWith('/followers')) return 'followers';
     if (location.pathname.endsWith('/following')) return 'following';
     return 'posts';
@@ -440,7 +443,7 @@ export function UserFeed({
   useEffect(() => {
     const buildGroupPostsPrefix = async () => {
       try {
-        if (!identifierOperations) return;
+        if (DISABLE_SUBSCRIPTIONS || !identifierOperations) return;
 
         const prefix = await identifierOperations.buildSearchPrefix(
           null,
@@ -790,12 +793,14 @@ export function UserFeed({
         >
           Replies
         </Tab>
-        <Tab
-          active={activeTab === 'group-posts'}
-          onClick={() => navigate(`/user/${userName}/group-posts`)}
-        >
-          Sub Posts
-        </Tab>
+        {!DISABLE_SUBSCRIPTIONS && (
+          <Tab
+            active={activeTab === 'group-posts'}
+            onClick={() => navigate(`/user/${userName}/group-posts`)}
+          >
+            Sub Posts
+          </Tab>
+        )}
         <Tab
           active={activeTab === 'followers'}
           onClick={() => navigate(`/user/${userName}/followers`)}
@@ -849,7 +854,7 @@ export function UserFeed({
           />
         )}
 
-        {activeTab === 'group-posts' && (
+        {!DISABLE_SUBSCRIPTIONS && activeTab === 'group-posts' && (
           <ResourceListDisplay
             styles={{
               gap: 20,
diff --git a/src/constants/qdn.ts b/src/constants/qdn.ts
index addf77f..0eff0b0 100644
--- a/src/constants/qdn.ts
+++ b/src/constants/qdn.ts
@@ -7,9 +7,9 @@ export const LIST_POSTS_FEED_FOLLOWING_SUB = 'LIST_POSTS_FEED_FOLLOWING_SUB';
 export const ENTITY_REPOST = 'REPOST';
 export const GROUP_PRIVATE = 'GROUP_PRIVATE';
 export const GROUP_VIDEO_PRIVATE = 'GROUP_VIDEO_PRIVATE';
+export const DISABLE_SUBSCRIPTIONS = true;
 // Video publishing constants
 export const useTestIdentifiers = false;
-
 export const QTUBE_VIDEO_BASE = useTestIdentifiers
   ? 'MYTEST3_vid_'
   : 'qtube_vid_';
diff --git a/src/hooks/useFollowingStorage.ts b/src/hooks/useFollowingStorage.ts
index 4728b20..7f026ee 100644
--- a/src/hooks/useFollowingStorage.ts
+++ b/src/hooks/useFollowingStorage.ts
@@ -4,17 +4,14 @@ import {
   loadFollowingList,
   saveFollowingList,
   addFollowedUser,
-  getFollowedUserByIdentifier,
-  FollowedUser,
 } from '../utils/followingStorageDB';
 
 // Configuration
-const BATCH_SIZE = 5; // Number of names to fetch at a time
 const FETCH_INTERVAL_MS = 3 * 60 * 1000; // 3 minutes
 const VALIDATION_INTERVAL_MS = 30 * 60 * 1000; // 30 minutes
 
 /**
- * Hook to progressively sync followed user names in the background using IndexedDB.
+ * Hook to sync followed user names in the background using IndexedDB.
  *
  * This hook runs background sync operations and DOES NOT return any reactive state.
  * It will not cause re-renders in the component that uses it.
@@ -22,8 +19,7 @@ const VALIDATION_INTERVAL_MS = 30 * 60 * 1000; // 30 minutes
  * Use `useFollowingListDB` hook to read the synced names.
  *
  * Features:
- * - Fetches the real followed user names from resource data (not just metadata)
- * - Fetches 5 names at a time every 3 minutes
+ * - Fetches all followed user names in a single batched POST request
  * - Validates identifiers still exist every 30 minutes
  * - Persists data in IndexedDB keyed by authenticated user's name
  * - Automatically initializes on mount
@@ -72,93 +68,81 @@ export function useFollowingStorage(): void {
   );
 
   /**
-   * Fetches the actual data for a resource to get the followed name
+   * Fetches all pending identifiers in a single batched POST request,
+   * decodes each base64 data payload, and saves resolved names to IndexedDB.
    */
-  const fetchResourceData = useCallback(
-    async (
-      identifier: string,
-      publisherName: string
-    ): Promise<{ followedName: string } | null> => {
-      try {
-        const response = await fetch(
-          `/arbitrary/DOCUMENT/${publisherName}/${identifier}`
+  const fetchBatch = useCallback(async (userName: string) => {
+    if (!isMountedRef.current || isFetchingRef.current) return;
+
+    const pendingArray = Array.from(pendingIdentifiersRef.current);
+    if (pendingArray.length === 0) return;
+
+    isFetchingRef.current = true;
+
+    try {
+      const response = await fetch('/arbitrary/resources/onchain/data', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(
+          pendingArray.map((identifier) => ({
+            service: 'DOCUMENT',
+            name: userName,
+            identifier,
+          }))
+        ),
+      });
+
+      if (!response.ok) {
+        console.warn(
+          `Batch fetch failed: ${response.status} ${response.statusText}`
         );
-
-        if (!response.ok) {
-          console.warn(
-            `Failed to fetch resource data: ${response.status} ${response.statusText}`
-          );
-          return null;
-        }
-
-        const data = await response.json();
-
-        if (!data.followedName) {
-          console.warn('Resource data missing followedName:', data);
-          return null;
-        }
-
-        return data;
-      } catch (error) {
-        console.error('Error fetching resource data:', error);
-        return null;
+        return;
       }
-    },
-    []
-  );
-
-  /**
-   * Fetches a batch of names from pending identifiers
-   */
-  const fetchBatch = useCallback(
-    async (userName: string) => {
-      if (!isMountedRef.current || isFetchingRef.current) return;
-
-      // Get the next batch of identifiers to process
-      const pendingArray = Array.from(pendingIdentifiersRef.current);
-      if (pendingArray.length === 0) return;
 
-      isFetchingRef.current = true;
+      const results: Array<{
+        service: string;
+        name: string;
+        identifier: string;
+        data: string | null;
+        error: string | null;
+      }> = await response.json();
 
-      try {
-        const batch = pendingArray.slice(0, BATCH_SIZE);
-
-        for (const identifier of batch) {
-          if (!isMountedRef.current) break;
+      if (!isMountedRef.current) return;
 
-          // Check if we already have this identifier
-          const existing = await getFollowedUserByIdentifier(
-            userName,
-            identifier
-          );
+      const now = Date.now();
 
-          if (existing) {
-            pendingIdentifiersRef.current.delete(identifier);
-            continue;
-          }
+      for (const result of results) {
+        if (!result.data || result.error) continue;
 
-          // Fetch the actual data
-          const data = await fetchResourceData(identifier, userName);
+        try {
+          const json = JSON.parse(atob(result.data));
+          const followedName =
+            typeof json.followedName === 'string'
+              ? json.followedName.trim()
+              : '';
 
-          if (data?.followedName && isMountedRef.current) {
+          if (followedName && followedName !== userName) {
             await addFollowedUser(userName, {
-              name: data.followedName,
-              identifier,
-              lastValidated: Date.now(),
+              name: followedName,
+              identifier: result.identifier,
+              lastValidated: now,
             });
           }
-
-          // Remove from pending
-          pendingIdentifiersRef.current.delete(identifier);
+        } catch {
+          console.warn(
+            'Failed to decode follow data for identifier:',
+            result.identifier
+          );
         }
-      } catch (error) {
-        console.error('Error fetching batch:', error);
-      } finally {
-        isFetchingRef.current = false;
+
+        pendingIdentifiersRef.current.delete(result.identifier);
       }
-    },
-    [fetchResourceData]
-  );
+    } catch (error) {
+      console.error('Error fetching batch:', error);
+    } finally {
+      isFetchingRef.current = false;
+    }
+  }, []);
 
   /**
    * Validates that stored identifiers still exist in the current resources
@@ -212,17 +196,25 @@ export function useFollowingStorage(): void {
         );
 
         // Find identifiers we haven't fetched yet
-        const storedIdentifiers = new Set(storedUsers.map((u) => u.identifier));
-        const newIdentifiers = Array.from(resourceIdentifiers).filter(
-          (id) => !storedIdentifiers.has(id as string)
-        ) as string[];
+        const storedUsersByIdentifier = new Map(
+          storedUsers.map((u) => [u.identifier, u])
+        );
+        const newIdentifiers = Array.from(resourceIdentifiers).filter((id) => {
+          const storedUser = storedUsersByIdentifier.get(id as string);
+          return (
+            !storedUser || !storedUser.name || storedUser.name === userName
+          );
+        }) as string[];
 
         // Add new identifiers to pending queue
         pendingIdentifiersRef.current = new Set(newIdentifiers);
 
         // Filter out stored users for identifiers that no longer exist
-        const validStoredUsers = storedUsers.filter((u) =>
-          resourceIdentifiers.has(u.identifier)
+        const validStoredUsers = storedUsers.filter(
+          (u) =>
+            resourceIdentifiers.has(u.identifier) &&
+            u.name &&
+            u.name !== userName
         );
 
         if (isMountedRef.current) {
diff --git a/src/hooks/useGroupOwnerNames.ts b/src/hooks/useGroupOwnerNames.ts
index 8612984..2019a43 100644
--- a/src/hooks/useGroupOwnerNames.ts
+++ b/src/hooks/useGroupOwnerNames.ts
@@ -11,6 +11,7 @@ import {
   setCachedPrimaryName,
   cleanupExpiredPrimaryNames,
 } from '../utils/primaryNamesCache';
+import { DISABLE_SUBSCRIPTIONS } from '../constants/qdn';
 
 /**
  * Hook to fetch and store primary names of group owners
@@ -27,9 +28,17 @@ export function useGroupOwnerNames() {
 
   useEffect(() => {
     const fetchGroupOwnerNames = async () => {
+      if (DISABLE_SUBSCRIPTIONS) {
+        setGroupOwnerNames([]);
+        setMemberGroups(new Map());
+        setIsLoading(false);
+        return;
+      }
+
       // Only fetch if we have an authenticated address
       if (!auth?.address) {
         setGroupOwnerNames([]);
+        setMemberGroups(new Map());
         setIsLoading(false);
         return;
       }
diff --git a/src/hooks/useInitializeNotificationPermission.ts b/src/hooks/useInitializeNotificationPermission.ts
new file mode 100644
index 0000000..8a05d68
--- /dev/null
+++ b/src/hooks/useInitializeNotificationPermission.ts
@@ -0,0 +1,78 @@
+import { useEffect } from 'react';
+import { useAtom, useSetAtom } from 'jotai';
+import { useGlobal } from 'qapp-core';
+import {
+  notificationPermissionAtom,
+  declinedNotificationPermissionAtom,
+  hubNotificationSupportedAtom,
+} from '../state/global/notifications';
+
+declare const qortalRequest: (params: any) => Promise<any>;
+
+/**
+ * Checks SHOW_ACTIONS once on mount to set hubNotificationSupportedAtom.
+ * Then, when the user is authenticated, auto-prompts for NOTIFICATION_PERMISSION
+ * unless they have already declined (persisted by address in localStorage).
+ * On accept, clears the address from declinedMap in case it was set previously.
+ */
+export const useInitializeNotificationPermission = () => {
+  const { auth } = useGlobal();
+  const setNotificationPermission = useSetAtom(notificationPermissionAtom);
+  const setHubNotificationSupported = useSetAtom(hubNotificationSupportedAtom);
+  const [declinedMap, setDeclinedMap] = useAtom(declinedNotificationPermissionAtom);
+
+  // Check once on mount whether the client supports NOTIFICATION_PERMISSION
+  useEffect(() => {
+    const checkSupport = async () => {
+      try {
+        const actions: string[] = await qortalRequest({ action: 'SHOW_ACTIONS' });
+        if (Array.isArray(actions) && actions.includes('NOTIFICATION_PERMISSION')) {
+          setHubNotificationSupported(true);
+        }
+      } catch {
+        // Client doesn't support SHOW_ACTIONS — treat as unsupported
+      }
+    };
+    checkSupport();
+  }, [setHubNotificationSupported]);
+
+  useEffect(() => {
+    const address = auth?.address;
+    if (!address) return;
+
+    // Already declined — skip the auto-prompt, let the sidebar button handle it
+    if (declinedMap[address]) return;
+
+    const executeNotificationPermission = async () => {
+      let supported = false;
+      try {
+        const actions: string[] = await qortalRequest({ action: 'SHOW_ACTIONS' });
+        supported = Array.isArray(actions) && actions.includes('NOTIFICATION_PERMISSION');
+        setHubNotificationSupported(supported);
+      } catch {
+        // Not supported
+      }
+
+      if (!supported) return;
+
+      try {
+        const result = await qortalRequest({ action: 'NOTIFICATION_PERMISSION' });
+        if (result) {
+          setNotificationPermission(true);
+          setDeclinedMap((prev) => {
+            const next = { ...prev };
+            delete next[address];
+            return next;
+          });
+        }
+      } catch (error) {
+        // Declined — persist so we never auto-prompt again
+        setDeclinedMap((prev) => ({ ...prev, [address]: true }));
+        console.error('Notification permission declined or errored:', error);
+      }
+    };
+
+    executeNotificationPermission();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [auth?.address]);
+};
diff --git a/src/hooks/useInitializeOwnedGroups.ts b/src/hooks/useInitializeOwnedGroups.ts
index 75638f4..1d9f7a2 100644
--- a/src/hooks/useInitializeOwnedGroups.ts
+++ b/src/hooks/useInitializeOwnedGroups.ts
@@ -6,6 +6,7 @@ import {
   isLoadingOwnedGroupsAtom,
   ownedGroupsErrorAtom,
 } from '../state/global/profile';
+import { DISABLE_SUBSCRIPTIONS } from '../constants/qdn';
 
 /**
  * Hook to initialize owned groups from API
@@ -19,6 +20,13 @@ export const useInitializeOwnedGroups = () => {
 
   useEffect(() => {
     const fetchOwnedGroups = async () => {
+      if (DISABLE_SUBSCRIPTIONS) {
+        setOwnedGroups([]);
+        setError(null);
+        setIsLoading(false);
+        return;
+      }
+
       if (!auth?.address) {
         setOwnedGroups([]);
         setError(null);
diff --git a/src/hooks/useMentionNotificationRegistration.ts b/src/hooks/useMentionNotificationRegistration.ts
new file mode 100644
index 0000000..b3b31ea
--- /dev/null
+++ b/src/hooks/useMentionNotificationRegistration.ts
@@ -0,0 +1,248 @@
+import { useEffect, useRef } from 'react';
+import { useAtomValue } from 'jotai';
+import { useGlobal, EnumCollisionStrength } from 'qapp-core';
+import { notificationPermissionAtom } from '../state/global/notifications';
+import { ENTITY_POST, ENTITY_ROOT, ENTITY_REPLY } from '../constants/qdn';
+import { loadFollowingList } from '../utils/followingStorageDB';
+
+declare const qortalRequest: (params: any) => Promise<any>;
+
+const APP_NAME = 'Quitter';
+const SERVICE_DOCUMENT = 'DOCUMENT';
+
+const FOLLOWING_POSTS_NOTIFICATION_ID = (userName: string) =>
+  `quitter-following-posts-${userName}`;
+
+type NotificationMessage = Record<string, string>;
+
+const MENTION_NOTIFICATION_MESSAGE: NotificationMessage = {
+  en: '{name} mentioned you in a post',
+  de: '{name} hat dich in einem Beitrag erwähnt',
+  ar: 'ذكرك {name} في منشور',
+  fi: '{name} mainitsi sinut julkaisussa',
+  it: '{name} ti ha menzionato in un post',
+  et: '{name} mainis sind postituses',
+  ru: '{name} упомянул(а) вас в публикации',
+  fr: '{name} vous a mentionné dans une publication',
+  pt: '{name} mencionou-te numa publicação',
+  es: '{name} te mencionó en una publicación',
+  ja: '{name} が投稿であなたをメンションしました',
+  zh: '{name} 在帖子中提到了你',
+};
+
+const REPLY_NOTIFICATION_MESSAGE: NotificationMessage = {
+  en: '{name} replied to your post',
+  de: '{name} hat auf deinen Beitrag geantwortet',
+  ar: 'رد {name} على منشورك',
+  fi: '{name} vastasi julkaisuusi',
+  it: '{name} ha risposto al tuo post',
+  et: '{name} vastas sinu postitusele',
+  ru: '{name} ответил(а) на вашу публикацию',
+  fr: '{name} a répondu à votre publication',
+  pt: '{name} respondeu à tua publicação',
+  es: '{name} respondió a tu publicación',
+  ja: '{name} があなたの投稿に返信しました',
+  zh: '{name} 回复了你的帖子',
+};
+
+const FOLLOWING_POST_NOTIFICATION_MESSAGE: NotificationMessage = {
+  en: '{name} posted',
+  de: '{name} hat gepostet',
+  ar: 'نشر {name}',
+  fi: '{name} julkaisi',
+  it: '{name} ha pubblicato',
+  et: '{name} postitas',
+  ru: '{name} опубликовал(а) запись',
+  fr: '{name} a publié',
+  pt: '{name} publicou',
+  es: '{name} publicó',
+  ja: '{name} が投稿しました',
+  zh: '{name} 发布了帖子',
+};
+
+/**
+ * Updates the "following posts" push notification to match the current follow list.
+ * Call after follow/unfollow. Pass targetUserName and action to include or exclude
+ * that user (no duplicates when adding). If the user has no followed users, removes the notification.
+ */
+export async function updateFollowingPostsNotification(
+  userName: string,
+  identifierOperations: {
+    buildSearchPrefix: (a: string, b: string) => Promise<string | undefined>;
+  },
+  targetUserName?: string,
+  action?: 'follow' | 'unfollow'
+): Promise<void> {
+  try {
+    const prefix = await identifierOperations.buildSearchPrefix(
+      ENTITY_POST,
+      ENTITY_ROOT
+    );
+    if (!prefix) return;
+
+    let followedNames = (await loadFollowingList(userName)).map((u) => u.name);
+
+    if (targetUserName !== undefined && action === 'follow') {
+      if (!followedNames.includes(targetUserName)) {
+        followedNames = [...followedNames, targetUserName];
+      }
+    } else if (targetUserName !== undefined && action === 'unfollow') {
+      followedNames = followedNames.filter((n) => n !== targetUserName);
+    }
+
+    if (followedNames.length > 0) {
+      await qortalRequest({
+        action: 'NOTIFICATION_ADD',
+        notifications: [
+          {
+            notificationId: FOLLOWING_POSTS_NOTIFICATION_ID(userName),
+            link: `qortal://APP/${APP_NAME}/post/{name}/{identifier}`,
+            image: '/arbitrary/THUMBNAIL/Quitter/qortal_avatar?async=true',
+            message: FOLLOWING_POST_NOTIFICATION_MESSAGE,
+            filters: {
+              service: SERVICE_DOCUMENT,
+              identifier: prefix,
+              excludeBlocked: true,
+              mode: 'ALL' as const,
+              names: followedNames,
+            },
+          },
+        ],
+      });
+    } else {
+      await qortalRequest({
+        action: 'NOTIFICATION_REMOVE',
+        notificationIds: [FOLLOWING_POSTS_NOTIFICATION_ID(userName)],
+      });
+    }
+  } catch (err) {
+    console.error('Failed to update following-posts notification:', err);
+  }
+}
+
+/**
+ * Global hook: when notification permission is granted, registers NOTIFICATION_ADD
+ * so the user receives push notifications for:
+ * - mentions in posts
+ * - main posts from users they follow
+ * - replies to their posts
+ * Run once in Layout.
+ */
+export function useMentionNotificationRegistration() {
+  const { auth, identifierOperations } = useGlobal();
+  const notificationPermission = useAtomValue(notificationPermissionAtom);
+  const hasRequestedRef = useRef(false);
+
+  useEffect(() => {
+    const userName = auth?.name;
+    if (!notificationPermission || !userName || !identifierOperations) {
+      return;
+    }
+    if (hasRequestedRef.current) return;
+
+    let cancelled = false;
+
+    (async () => {
+      try {
+        const hashedName = await identifierOperations.hashString(
+          userName,
+          EnumCollisionStrength.HIGH
+        );
+        if (cancelled || !hashedName) return;
+        if (hasRequestedRef.current) return;
+
+        const prefix = await identifierOperations.buildSearchPrefix(
+          ENTITY_POST,
+          ENTITY_ROOT
+        );
+        if (cancelled) return;
+        if (hasRequestedRef.current) return;
+
+        const replyPrefix = await identifierOperations.buildSearchPrefix(
+          ENTITY_REPLY,
+          ''
+        );
+        if (cancelled) return;
+        if (hasRequestedRef.current) return;
+
+        const followedUsers = await loadFollowingList(userName);
+        const followedNames =
+          followedUsers.length > 0
+            ? followedUsers.map((u) => u.name)
+            : undefined;
+
+        const mentionDescription = `~@${hashedName}~`;
+        const replyDescription = `~rply${hashedName}~`;
+
+        const notifications: Array<{
+          notificationId: string;
+          link: string;
+          image: string;
+          message: NotificationMessage;
+          filters: Record<string, unknown>;
+        }> = [
+          {
+            notificationId: `quitter-mention-${userName}`,
+            link: `qortal://APP/${APP_NAME}/post/{name}/{identifier}`,
+            image: '/arbitrary/THUMBNAIL/Quitter/qortal_avatar?async=true',
+            message: MENTION_NOTIFICATION_MESSAGE,
+            filters: {
+              service: SERVICE_DOCUMENT,
+              identifier: prefix,
+              description: mentionDescription,
+              excludeBlocked: true,
+              mode: 'ALL' as const,
+            },
+          },
+          {
+            notificationId: `quitter-reply-${userName}`,
+            link: `qortal://APP/${APP_NAME}/post/{name}/{identifier}`,
+            image: '/arbitrary/THUMBNAIL/Quitter/qortal_avatar?async=true',
+            message: REPLY_NOTIFICATION_MESSAGE,
+            filters: {
+              service: SERVICE_DOCUMENT,
+              identifier: replyPrefix,
+              description: replyDescription,
+              excludeBlocked: true,
+              mode: 'ALL' as const,
+            },
+          },
+        ];
+
+        if (followedNames && followedNames.length > 0) {
+          notifications.push({
+            notificationId: FOLLOWING_POSTS_NOTIFICATION_ID(userName),
+            link: `qortal://APP/${APP_NAME}/post/{name}/{identifier}`,
+            image: '/arbitrary/THUMBNAIL/Quitter/qortal_avatar?async=true',
+            message: FOLLOWING_POST_NOTIFICATION_MESSAGE,
+            filters: {
+              service: SERVICE_DOCUMENT,
+              identifier: prefix,
+              excludeBlocked: true,
+              mode: 'ALL' as const,
+              names: followedNames,
+            },
+          });
+        }
+        await qortalRequest({
+          action: 'NOTIFICATION_REMOVE',
+        });
+        hasRequestedRef.current = true;
+        await qortalRequest({
+          action: 'NOTIFICATION_ADD',
+          notifications,
+        });
+      } catch (err) {
+        console.error('Failed to register notifications:', err);
+        hasRequestedRef.current = false;
+        if (!cancelled) {
+          console.error('Failed to register notifications:', err);
+        }
+      }
+    })();
+
+    return () => {
+      cancelled = true;
+    };
+  }, [notificationPermission, auth?.name, identifierOperations]);
+}
diff --git a/src/hooks/useOwnedGroups.ts b/src/hooks/useOwnedGroups.ts
index c839e2e..ebf55b3 100644
--- a/src/hooks/useOwnedGroups.ts
+++ b/src/hooks/useOwnedGroups.ts
@@ -6,6 +6,7 @@ import {
   ownedGroupsErrorAtom,
   type OwnedGroup,
 } from '../state/global/profile';
+import { DISABLE_SUBSCRIPTIONS } from '../constants/qdn';
 
 // Re-export the interface for backwards compatibility
 export type { OwnedGroup };
@@ -25,6 +26,13 @@ export function useOwnedGroups() {
   const [, setError] = useAtom(ownedGroupsErrorAtom);
 
   const refetch = async () => {
+    if (DISABLE_SUBSCRIPTIONS) {
+      setOwnedGroups([]);
+      setError(null);
+      setIsLoading(false);
+      return;
+    }
+
     if (!auth?.address) return;
 
     setIsLoading(true);
diff --git a/src/hooks/useReplyCount.ts b/src/hooks/useReplyCount.ts
index acd1ac0..bda6a0a 100644
--- a/src/hooks/useReplyCount.ts
+++ b/src/hooks/useReplyCount.ts
@@ -1,6 +1,10 @@
 import { useState, useEffect } from 'react';
 import { useGlobal } from 'qapp-core';
-import { ENTITY_REPLY, ENTITY_REPLY_PRIVATE } from '../constants/qdn';
+import {
+  DISABLE_SUBSCRIPTIONS,
+  ENTITY_REPLY,
+  ENTITY_REPLY_PRIVATE,
+} from '../constants/qdn';
 
 // Declare qortalRequest as a global function
 
@@ -38,7 +42,10 @@ export function useReplyCount(
 
         // For encrypted posts, search for ENTITY_REPLY_PRIVATE
         // For public posts, search for ENTITY_REPLY
-        const entityType = groupId ? ENTITY_REPLY_PRIVATE : ENTITY_REPLY;
+        const entityType =
+          !DISABLE_SUBSCRIPTIONS && groupId
+            ? ENTITY_REPLY_PRIVATE
+            : ENTITY_REPLY;
 
         // Build the identifier prefix for replies to this post
         const replyIdentifierPrefix =
diff --git a/src/state/global/notifications.ts b/src/state/global/notifications.ts
index 033569c..870df90 100644
--- a/src/state/global/notifications.ts
+++ b/src/state/global/notifications.ts
@@ -1,4 +1,5 @@
 import { atom } from 'jotai';
+import { atomWithStorage } from 'jotai/utils';
 
 export interface Notification {
   id: string;
@@ -40,3 +41,15 @@ export const shownNotificationIdsAtom = atom<string[]>([]);
 // Atom to track if there are unread notifications (for badge indicator)
 // Updated by Sidebar useEffect and cleared when notifications are viewed
 export const hasUnreadNotificationsAtom = atom<boolean>(false);
+
+// Atom to track if the user has granted notification permission (via Qortal NOTIFICATION_PERMISSION)
+export const notificationPermissionAtom = atom<boolean>(false);
+
+// Atom to track if the connected Qortal client supports the NOTIFICATION_PERMISSION action
+export const hubNotificationSupportedAtom = atom<boolean>(false);
+
+// Persisted map of address -> true for users who have declined the notification permission prompt.
+// Keyed by address so each account's choice is tracked independently.
+export const declinedNotificationPermissionAtom = atomWithStorage<
+  Record<string, boolean>
+>('quitter-declined-notification-permission', {});
diff --git a/src/styles/Layout.tsx b/src/styles/Layout.tsx
index d81c8bc..6864dbb 100644
--- a/src/styles/Layout.tsx
+++ b/src/styles/Layout.tsx
@@ -16,6 +16,8 @@ import { useGlobal } from 'qapp-core';
 import { useFollowingStorage } from '../hooks/useFollowingStorage';
 import { useNotificationStorage } from '../hooks/useNotificationStorage';
 import { useInitializePublicNode } from '../hooks/useInitializePublicNode';
+import { useInitializeNotificationPermission } from '../hooks/useInitializeNotificationPermission';
+import { useMentionNotificationRegistration } from '../hooks/useMentionNotificationRegistration';
 
 const LoadingContainer = styled(Box)(({ theme }) => ({
   display: 'flex',
@@ -56,9 +58,11 @@ const Layout = () => {
   // Initialize public node status
   useInitializePublicNode();
 
-  const [hasProfile] = useAtom(hasProfileAtom);
-  const [isLoadingProfile] = useAtom(isLoadingProfileAtom);
-  const [profileName] = useAtom(profileNameAtom);
+  // Request notification permission when user is authenticated
+  useInitializeNotificationPermission();
+
+  // Register for push notifications when someone mentions the user
+  useMentionNotificationRegistration();
 
   // Show loading indicator while authentication is in progress
   if (auth?.isLoadingUser) {