diff --git a/src/app/api/notifications/stream/route.ts b/src/app/api/notifications/stream/route.ts
deleted file mode 100644
index 6d9718015..000000000
--- a/src/app/api/notifications/stream/route.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-import { auth } from '@clerk/nextjs/server'
-import { connection, type NextRequest } from 'next/server'
-import { logger } from '@/lib/logger'
-import {
-  realtimeNotificationService,
-  createSSEResponse,
-} from '@/server/notifications/realtimeService'
-
-export async function GET(request: NextRequest) {
-  await connection()
-
-  try {
-    const { userId } = await auth()
-
-    if (!userId) return new Response('Unauthorized', { status: 401 })
-
-    const stream = realtimeNotificationService.createSSEConnection(userId)
-    const origin = request.headers.get('origin') || undefined
-
-    return createSSEResponse(stream, origin)
-  } catch (error) {
-    logger.error('SSE connection error:', error)
-    return new Response('Internal Server Error', { status: 500 })
-  }
-}
diff --git a/src/components/notifications/NotificationCenter.tsx b/src/components/notifications/NotificationCenter.tsx
index 5304169a3..ec0fe76a3 100644
--- a/src/components/notifications/NotificationCenter.tsx
+++ b/src/components/notifications/NotificationCenter.tsx
@@ -6,7 +6,7 @@ import { Bell, X } from 'lucide-react'
 import { useRouter } from 'next/navigation'
 import { useState, useEffect, type MouseEvent } from 'react'
 import { createPortal } from 'react-dom'
-import { POLLING_INTERVALS } from '@/data/constants'
+import { CACHE_DURATIONS, POLLING_INTERVALS } from '@/data/constants'
 import { api } from '@/lib/api'
 import toast from '@/lib/toast'
 import { cn } from '@/lib/utils'
@@ -27,18 +27,20 @@ function NotificationCenter(props: Props) {
   const notificationsQuery = api.notifications.get.useQuery(
     { limit: 10, offset: 0 },
     {
-      enabled: !!user,
-      refetchOnWindowFocus: true,
-      refetchInterval: POLLING_INTERVALS.NOTIFICATIONS,
+      enabled: !!user && isOpen,
+      refetchOnWindowFocus: isOpen,
+      refetchInterval: isOpen ? POLLING_INTERVALS.SHORT : false,
+      staleTime: CACHE_DURATIONS.VERY_SHORT,
     },
   )
   const unreadCountQuery = api.notifications.getUnreadCount.useQuery(undefined, {
     enabled: !!user,
+    staleTime: CACHE_DURATIONS.SHORT,
     refetchOnWindowFocus: true,
-    refetchInterval: POLLING_INTERVALS.NOTIFICATIONS,
+    refetchInterval: isOpen ? false : POLLING_INTERVALS.EXTRA_LONG,
+    refetchIntervalInBackground: false,
   })
 
-  // Mutations
   const markAsReadMutation = api.notifications.markAsRead.useMutation({
     onMutate: () => setIsLoading(true),
     onSuccess: () => {
@@ -85,7 +87,15 @@ function NotificationCenter(props: Props) {
     router.push('/notifications')
   }
 
-  // Add escape key handler
+  const handleToggleNotifications = () => {
+    const nextIsOpen = !isOpen
+    setIsOpen(nextIsOpen)
+
+    if (nextIsOpen) {
+      void utils.notifications.getUnreadCount.invalidate()
+    }
+  }
+
   useEffect(() => {
     const handleEscape = (event: KeyboardEvent) => {
       if (event.key === 'Escape' && isOpen) {
@@ -104,21 +114,17 @@ function NotificationCenter(props: Props) {
     }
   }, [isOpen])
 
-  // Don't render anything if user is not authenticated
   if (!user) return null
 
   const handleNotificationClick = (notification: (typeof notifications)[0]) => {
-    // Mark as read if not already read (swallow error if it fails)
     if (!notification.isRead) {
       markAsReadMutation.mutateAsync({ notificationId: notification.id }).catch(console.error)
     }
 
     setIsOpen(false)
 
-    // Navigate based on actionUrl if available
     if (notification.actionUrl) return router.push(notification.actionUrl)
 
-    // Try to extract route from metadata if actionUrl is not available
     const metadata = notification.metadata as Record<string, unknown>
     if (typeof metadata?.listingId === 'string') {
       router.push(`/listings/${metadata.listingId}`)
@@ -127,7 +133,6 @@ function NotificationCenter(props: Props) {
     } else if (typeof metadata?.userId === 'string') {
       router.push(`/users/${metadata.userId}`)
     } else {
-      // Default to notifications page if no specific route
       router.push('/notifications')
     }
   }
@@ -141,7 +146,6 @@ function NotificationCenter(props: Props) {
   }
 
   const handleBackdropClick = (ev: MouseEvent) => {
-    // Only close if the click is directly on the backdrop, not bubbling from child elements
     if (ev.target !== ev.currentTarget) return
     setIsOpen(false)
   }
@@ -151,14 +155,13 @@ function NotificationCenter(props: Props) {
 
   return (
     <div className={cn('relative', props.className)}>
-      {/* Notification Bell Button */}
       <button
         aria-label={
           unreadCount > 0 ? `Open notifications (${unreadCount} unread)` : 'Open notifications'
         }
         onClick={(ev) => {
           ev.stopPropagation()
-          setIsOpen(!isOpen)
+          handleToggleNotifications()
         }}
         className="relative p-2 text-gray-600 hover:text-gray-900 dark:text-gray-400 dark:hover:text-gray-100 transition-colors"
         disabled={isLoading}
@@ -175,7 +178,6 @@ function NotificationCenter(props: Props) {
         )}
       </button>
 
-      {/* Desktop Dropdown */}
       <AnimatePresence>
         {isOpen && (
           <motion.div
@@ -189,7 +191,6 @@ function NotificationCenter(props: Props) {
             role="region"
             aria-label="Notifications"
           >
-            {/* Header */}
             <div className="flex items-center justify-between p-4 border-b border-gray-200 dark:border-gray-700">
               <h3 className="text-lg font-semibold text-gray-900 dark:text-white">Notifications</h3>
               <div className="flex items-center gap-2">
@@ -212,7 +213,6 @@ function NotificationCenter(props: Props) {
               </div>
             </div>
 
-            {/* Notifications List */}
             <div className="max-h-72 overflow-y-auto">
               <NotificationList
                 notifications={notifications}
@@ -225,7 +225,6 @@ function NotificationCenter(props: Props) {
               />
             </div>
 
-            {/* Footer */}
             {notifications.length > 0 && (
               <div className="p-4 border-t border-gray-200 dark:border-gray-700 bg-white dark:bg-gray-800 sticky bottom-0">
                 <button
@@ -240,13 +239,11 @@ function NotificationCenter(props: Props) {
         )}
       </AnimatePresence>
 
-      {/* Mobile Bottom Sheet */}
       {typeof document !== 'undefined' &&
         createPortal(
           <AnimatePresence mode="wait">
             {isOpen && (
               <>
-                {/* Backdrop for mobile */}
                 <motion.div
                   initial={{ opacity: 0 }}
                   animate={{ opacity: 1 }}
@@ -257,7 +254,6 @@ function NotificationCenter(props: Props) {
                   aria-hidden="true"
                 />
 
-                {/* Bottom Sheet */}
                 <motion.div
                   initial={{ translateY: '100%' }}
                   animate={{ translateY: 0 }}
@@ -273,12 +269,10 @@ function NotificationCenter(props: Props) {
                   aria-modal="true"
                   aria-label="Notifications"
                 >
-                  {/* Handle Bar */}
                   <div className="flex flex-shrink-0 justify-center pb-2 pt-3">
                     <div className="h-1 w-12 rounded-full bg-gray-300 dark:bg-gray-600" />
                   </div>
 
-                  {/* Header */}
                   <div className="flex flex-shrink-0 items-center justify-between border-b border-gray-200 px-4 py-3 dark:border-gray-700">
                     <h3 className="text-lg font-semibold text-gray-900 dark:text-white">
                       Notifications
@@ -303,7 +297,6 @@ function NotificationCenter(props: Props) {
                     </div>
                   </div>
 
-                  {/* Notifications List */}
                   <div className="min-h-0 flex-1 overflow-y-auto">
                     <NotificationList
                       notifications={notifications}
@@ -316,7 +309,6 @@ function NotificationCenter(props: Props) {
                     />
                   </div>
 
-                  {/* Footer */}
                   {notifications.length > 0 && (
                     <div className="flex-shrink-0 border-t border-gray-200 p-4 pb-safe dark:border-gray-700">
                       <button
@@ -334,7 +326,6 @@ function NotificationCenter(props: Props) {
           document.body,
         )}
 
-      {/* Desktop Backdrop */}
       <AnimatePresence>
         {isOpen && (
           <motion.div
diff --git a/src/data/constants.ts b/src/data/constants.ts
index 6d83d8709..831f31375 100644
--- a/src/data/constants.ts
+++ b/src/data/constants.ts
@@ -3,7 +3,6 @@ import { ms } from '@/utils/time'
 // Polling intervals in milliseconds
 export const POLLING_INTERVALS = {
   SHORT: ms.minutes(1),
-  NOTIFICATIONS: ms.minutes(3),
   LONG: ms.minutes(5),
   EXTRA_LONG: ms.minutes(10),
 } as const
diff --git a/src/hooks/useRealtimeNotifications.ts b/src/hooks/useRealtimeNotifications.ts
deleted file mode 100644
index 68668cd7d..000000000
--- a/src/hooks/useRealtimeNotifications.ts
+++ /dev/null
@@ -1,207 +0,0 @@
-'use client'
-
-import { useUser } from '@clerk/nextjs'
-import { useCallback, useEffect, useRef, useState } from 'react'
-import { z } from 'zod'
-import { safeParseJSON } from '@/utils/client-validation'
-
-interface RealtimeNotification {
-  id: string
-  type: string
-  title: string
-  message: string
-  actionUrl?: string
-  createdAt: string
-}
-
-interface SSEMessage {
-  type: 'connected' | 'notification' | 'unread_count' | 'ping'
-  data: unknown
-}
-
-// Schemas for validation
-const RealtimeNotificationSchema = z.object({
-  id: z.string(),
-  type: z.string(),
-  title: z.string(),
-  message: z.string(),
-  actionUrl: z.string().optional(),
-  createdAt: z.string(),
-})
-
-const SSEMessageSchema = z.object({
-  type: z.enum(['connected', 'notification', 'unread_count', 'ping']),
-  data: z.unknown(),
-})
-
-interface UseRealtimeNotificationsReturn {
-  isConnected: boolean
-  notifications: RealtimeNotification[]
-  unreadCount: number
-  connect: () => void
-  disconnect: () => void
-  markAsRead: (notificationId: string) => void
-  clearNotifications: () => void
-}
-
-export function useRealtimeNotifications(): UseRealtimeNotificationsReturn {
-  const { user, isLoaded } = useUser()
-  const [isConnected, setIsConnected] = useState(false)
-  const [notifications, setNotifications] = useState<RealtimeNotification[]>([])
-  const [unreadCount, setUnreadCount] = useState(0)
-
-  const eventSourceRef = useRef<EventSource | null>(null)
-  const reconnectTimeoutRef = useRef<NodeJS.Timeout | null>(null)
-  const maxReconnectAttempts = 5
-  const reconnectAttempts = useRef(0)
-
-  const disconnect = useCallback(() => {
-    if (eventSourceRef.current) {
-      eventSourceRef.current.close()
-      eventSourceRef.current = null
-    }
-
-    if (reconnectTimeoutRef.current) {
-      clearTimeout(reconnectTimeoutRef.current)
-      reconnectTimeoutRef.current = null
-    }
-
-    setIsConnected(false)
-  }, [])
-
-  const connect = useCallback(() => {
-    if (!user?.id || eventSourceRef.current) {
-      return
-    }
-
-    try {
-      const eventSource = new EventSource(`/api/notifications/stream`)
-      eventSourceRef.current = eventSource
-
-      eventSource.onopen = () => {
-        console.log('SSE connection opened')
-        setIsConnected(true)
-        reconnectAttempts.current = 0
-      }
-
-      eventSource.onmessage = (event) => {
-        try {
-          const message = safeParseJSON(event.data, SSEMessageSchema, {
-            type: 'ping',
-            data: null,
-          } as SSEMessage)
-
-          switch (message.type) {
-            case 'connected':
-              console.log('Connected to notification stream')
-              break
-
-            case 'notification':
-              const validationResult = RealtimeNotificationSchema.safeParse(message.data)
-              if (!validationResult.success) {
-                console.warn('Invalid notification data:', validationResult.error)
-                break
-              }
-              const notification = validationResult.data
-              setNotifications((prev) => [notification, ...prev].slice(0, 50)) // Keep last 50
-
-              // Show browser notification if permission granted
-              if (Notification.permission === 'granted') {
-                new Notification(notification.title, {
-                  body: notification.message,
-                  icon: '/favicon/favicon-32x32.png',
-                  tag: notification.id,
-                })
-              }
-              break
-
-            case 'unread_count':
-              setUnreadCount((message.data as { count: number }).count)
-              break
-
-            case 'ping':
-              // Respond to ping to keep connection alive
-              console.log('Received ping from server')
-              break
-
-            default:
-              console.log('Unknown SSE message type:', message.type)
-          }
-        } catch (error) {
-          console.error('Error parsing SSE message:', error)
-        }
-      }
-
-      eventSource.onerror = () => {
-        console.error('SSE connection error')
-        setIsConnected(false)
-
-        // Attempt to reconnect
-        if (reconnectAttempts.current < maxReconnectAttempts) {
-          reconnectAttempts.current++
-          const delay = Math.min(1000 * Math.pow(2, reconnectAttempts.current), 30000) // Exponential backoff, max 30s
-
-          console.log(
-            `Attempting to reconnect in ${delay}ms (attempt ${reconnectAttempts.current})`,
-          )
-
-          reconnectTimeoutRef.current = setTimeout(() => {
-            disconnect()
-            connect()
-          }, delay)
-        } else {
-          console.error('Max reconnection attempts reached')
-        }
-      }
-    } catch (error) {
-      console.error('Failed to create SSE connection:', error)
-    }
-  }, [user?.id, disconnect])
-
-  const markAsRead = useCallback((notificationId: string) => {
-    setNotifications((prev) =>
-      prev.map((notif) => (notif.id === notificationId ? { ...notif, read: true } : notif)),
-    )
-  }, [])
-
-  const clearNotifications = useCallback(() => {
-    setNotifications([])
-  }, [])
-
-  // Auto-connect when user is loaded
-  useEffect(() => {
-    if (isLoaded && user?.id) {
-      connect()
-    }
-
-    return () => {
-      disconnect()
-    }
-  }, [isLoaded, user?.id, connect, disconnect])
-
-  // Request notification permission on mount
-  useEffect(() => {
-    if ('Notification' in window && Notification.permission === 'default') {
-      Notification.requestPermission().then((permission) => {
-        console.log('Notification permission:', permission)
-      })
-    }
-  }, [])
-
-  // Cleanup on unmount
-  useEffect(() => {
-    return () => {
-      disconnect()
-    }
-  }, [disconnect])
-
-  return {
-    isConnected,
-    notifications,
-    unreadCount,
-    connect,
-    disconnect,
-    markAsRead,
-    clearNotifications,
-  }
-}
diff --git a/src/server/notifications/batchingService.ts b/src/server/notifications/batchingService.ts
index 0f9d99347..58fa1120e 100644
--- a/src/server/notifications/batchingService.ts
+++ b/src/server/notifications/batchingService.ts
@@ -1,16 +1,10 @@
 import { prisma } from '@/server/db'
 import { notificationAnalyticsService } from '@/server/notifications/analyticsService'
-import {
-  NotificationDeliveryStatus,
-  DeliveryChannel,
-  NotificationCategory,
-  NotificationType,
-} from '@orm/client'
+import { NotificationDeliveryStatus, DeliveryChannel } from '@orm/client'
 import { createEmailService } from './emailService'
-import { realtimeNotificationService } from './realtimeService'
 import type { NotificationData } from './types'
 
-export interface BatchedNotification {
+interface BatchedNotification {
   id: string
   userId: string
   data: NotificationData
@@ -19,14 +13,14 @@ export interface BatchedNotification {
   maxAttempts: number
 }
 
-export interface BatchConfig {
+interface BatchConfig {
   batchSize: number
   batchIntervalMs: number
   maxRetries: number
   retryDelayMs: number
 }
 
-export class NotificationBatchingService {
+class NotificationBatchingService {
   private queue: BatchedNotification[] = []
   private processing = false
   private batchTimer: NodeJS.Timeout | null = null
@@ -36,16 +30,15 @@ export class NotificationBatchingService {
   constructor(config: Partial<BatchConfig> = {}) {
     this.config = {
       batchSize: 50,
-      batchIntervalMs: 30000, // 30 seconds
+      batchIntervalMs: 30000,
       maxRetries: 3,
-      retryDelayMs: 5000, // 5 seconds
+      retryDelayMs: 5000,
       ...config,
     }
 
     this.startBatchTimer()
   }
 
-  // Add notification to batch queue
   scheduleNotification(
     data: NotificationData,
     scheduledFor: Date = new Date(),
@@ -65,7 +58,6 @@ export class NotificationBatchingService {
     this.queue.push(batchedNotification)
     console.log(`Notification scheduled for batch processing: ${id}`)
 
-    // Process immediately if batch is full
     if (this.queue.length >= this.config.batchSize) {
       this.processBatch().catch(console.error)
     }
@@ -73,59 +65,6 @@ export class NotificationBatchingService {
     return id
   }
 
-  // Schedule weekly digest notifications
-  scheduleWeeklyDigest(userId: string): void {
-    const nextWeek = new Date()
-    nextWeek.setDate(nextWeek.getDate() + 7)
-    nextWeek.setHours(9, 0, 0, 0) // 9 AM next week
-
-    this.scheduleNotification(
-      {
-        userId,
-        type: NotificationType.WEEKLY_DIGEST,
-        category: NotificationCategory.SYSTEM,
-        title: 'Weekly EmuReady Digest',
-        message: "Here's what happened this week in your gaming community.",
-        deliveryChannel: DeliveryChannel.EMAIL,
-      },
-      nextWeek,
-    )
-  }
-
-  // Schedule maintenance notifications
-  scheduleMaintenanceNotification(scheduledFor: Date, title: string, message: string): void {
-    // Get all users who want maintenance notifications
-    prisma.user
-      .findMany({
-        where: {
-          notificationPreferences: {
-            some: {
-              type: NotificationType.MAINTENANCE_NOTICE,
-              inAppEnabled: true,
-            },
-          },
-        },
-        select: { id: true },
-      })
-      .then((users) => {
-        for (const user of users) {
-          this.scheduleNotification(
-            {
-              userId: user.id,
-              type: NotificationType.MAINTENANCE_NOTICE,
-              category: NotificationCategory.SYSTEM,
-              title,
-              message,
-              deliveryChannel: DeliveryChannel.BOTH,
-            },
-            scheduledFor,
-          )
-        }
-      })
-      .catch(console.error)
-  }
-
-  // Process batch of notifications
   private async processBatch(): Promise<void> {
     if (this.processing || this.queue.length === 0) {
       return
@@ -134,7 +73,6 @@ export class NotificationBatchingService {
     this.processing = true
     const now = new Date()
 
-    // Get notifications ready for processing
     const readyNotifications = this.queue.filter((notification) => notification.scheduledFor <= now)
 
     if (readyNotifications.length === 0) {
@@ -142,7 +80,6 @@ export class NotificationBatchingService {
       return
     }
 
-    // Take up to batchSize notifications
     const batch = readyNotifications.slice(0, this.config.batchSize)
 
     console.log(`Processing batch of ${batch.length} notifications`)
@@ -151,16 +88,13 @@ export class NotificationBatchingService {
       batch.map((notification) => this.processNotification(notification)),
     )
 
-    // Handle results and retries
     for (let i = 0; i < batch.length; i++) {
       const notification = batch[i]
       const result = results[i]
 
       if (result.status === 'fulfilled' && result.value) {
-        // Success - remove from queue
         this.removeFromQueue(notification.id)
       } else {
-        // Failed - increment attempts and potentially retry
         notification.attempts++
 
         if (notification.attempts >= notification.maxAttempts) {
@@ -169,7 +103,6 @@ export class NotificationBatchingService {
           )
           this.removeFromQueue(notification.id)
         } else {
-          // Schedule retry
           notification.scheduledFor = new Date(Date.now() + this.config.retryDelayMs)
           console.log(
             `Notification ${notification.id} scheduled for retry (attempt ${notification.attempts + 1})`,
@@ -181,12 +114,10 @@ export class NotificationBatchingService {
     this.processing = false
   }
 
-  // Process individual notification
   private async processNotification(notification: BatchedNotification): Promise<boolean> {
     try {
       const { data } = notification
 
-      // Create notification in database
       const dbNotification = await prisma.notification.create({
         data: {
           userId: data.userId,
@@ -201,20 +132,18 @@ export class NotificationBatchingService {
         },
       })
 
-      // Deliver via appropriate channels
       const deliveryPromises: Promise<boolean>[] = []
 
-      // In-app delivery
       if (
         data.deliveryChannel === DeliveryChannel.IN_APP ||
         data.deliveryChannel === DeliveryChannel.BOTH
       ) {
-        deliveryPromises.push(this.deliverInApp(dbNotification.id, data))
+        deliveryPromises.push(Promise.resolve(true))
       }
 
-      // Email delivery
       if (
-        (data.deliveryChannel === 'EMAIL' || data.deliveryChannel === 'BOTH') &&
+        (data.deliveryChannel === DeliveryChannel.EMAIL ||
+          data.deliveryChannel === DeliveryChannel.BOTH) &&
         this.emailService
       ) {
         deliveryPromises.push(this.deliverEmail(data))
@@ -223,7 +152,6 @@ export class NotificationBatchingService {
       const results = await Promise.all(deliveryPromises)
       const success = results.some((result) => result)
 
-      // Update delivery status
       await prisma.notification.update({
         where: { id: dbNotification.id },
         data: {
@@ -233,7 +161,6 @@ export class NotificationBatchingService {
         },
       })
 
-      // Invalidate analytics cache when notifications are processed in batches
       if (success) {
         notificationAnalyticsService.clearCache()
       }
@@ -245,42 +172,6 @@ export class NotificationBatchingService {
     }
   }
 
-  // Deliver in-app notification
-  private async deliverInApp(notificationId: string, data: NotificationData): Promise<boolean> {
-    try {
-      const notification = await prisma.notification.findUnique({
-        where: { id: notificationId },
-      })
-
-      if (!notification) return false
-
-      realtimeNotificationService.sendNotificationToUser(data.userId, {
-        id: notification.id,
-        type: notification.type,
-        title: notification.title,
-        message: notification.message,
-        actionUrl: notification.actionUrl || undefined,
-        createdAt: notification.createdAt.toISOString(),
-      })
-
-      // Update unread count
-      const unreadCount = await prisma.notification.count({
-        where: {
-          userId: data.userId,
-          isRead: false,
-        },
-      })
-
-      realtimeNotificationService.sendUnreadCountToUser(data.userId, unreadCount)
-
-      return true
-    } catch (error) {
-      console.error('In-app delivery error:', error)
-      return false
-    }
-  }
-
-  // Deliver email notification
   private async deliverEmail(data: NotificationData): Promise<boolean> {
     if (!this.emailService) return false
 
@@ -300,7 +191,6 @@ export class NotificationBatchingService {
     }
   }
 
-  // Remove notification from queue
   private removeFromQueue(id: string): void {
     const index = this.queue.findIndex((notification) => notification.id === id)
     if (index !== -1) {
@@ -308,16 +198,13 @@ export class NotificationBatchingService {
     }
   }
 
-  // Start batch processing timer
   private startBatchTimer(): void {
     this.batchTimer = setInterval(() => {
       this.processBatch().catch(console.error)
     }, this.config.batchIntervalMs)
-    // Allow process to exit if no other tasks are queued
     this.batchTimer.unref?.()
   }
 
-  // Get queue status
   getQueueStatus(): {
     queueLength: number
     processing: boolean
@@ -334,14 +221,6 @@ export class NotificationBatchingService {
       nextScheduled,
     }
   }
-
-  // Cleanup
-  destroy() {
-    if (!this.batchTimer) return
-    clearInterval(this.batchTimer)
-    this.batchTimer = null
-  }
 }
 
-// Singleton instance
 export const notificationBatchingService = new NotificationBatchingService()
diff --git a/src/server/notifications/realtimeService.ts b/src/server/notifications/realtimeService.ts
deleted file mode 100644
index d60618218..000000000
--- a/src/server/notifications/realtimeService.ts
+++ /dev/null
@@ -1,230 +0,0 @@
-import { getAllowedOrigins } from '@/lib/cors'
-
-interface SSEConnection {
-  userId: string
-  controller: ReadableStreamDefaultController
-  lastPing: number
-}
-
-class RealtimeNotificationService {
-  private connections = new Map<string, SSEConnection>()
-  private pingInterval: NodeJS.Timeout | null = null
-
-  // Connection limits
-  private readonly MAX_CONNECTIONS = 1000 // Maximum total connections
-  private readonly MAX_CONNECTIONS_PER_IP = 10 // Maximum connections per IP
-  private connectionsByIp = new Map<string, Set<string>>() // IP -> Set of userIds
-
-  constructor() {
-    this.startPingInterval()
-  }
-
-  // Create SSE connection for a user
-  createSSEConnection(userId: string, clientIp?: string): ReadableStream {
-    // Check total connection limit
-    if (this.connections.size >= this.MAX_CONNECTIONS) {
-      throw new Error('Server connection limit reached')
-    }
-
-    // Check per-IP connection limit if IP is provided
-    if (clientIp) {
-      const ipConnections = this.connectionsByIp.get(clientIp) || new Set()
-      if (ipConnections.size >= this.MAX_CONNECTIONS_PER_IP) {
-        throw new Error('Connection limit exceeded for this IP')
-      }
-    }
-
-    return new ReadableStream({
-      start: (controller) => {
-        // Close existing connection for this user if any
-        if (this.connections.has(userId)) {
-          const existing = this.connections.get(userId)
-          existing?.controller.close()
-          this.connections.delete(userId)
-        }
-
-        // Store connection
-        this.connections.set(userId, {
-          userId,
-          controller,
-          lastPing: Date.now(),
-        })
-
-        // Track IP connection if provided
-        if (clientIp) {
-          const ipConnections = this.connectionsByIp.get(clientIp) || new Set()
-          ipConnections.add(userId)
-          this.connectionsByIp.set(clientIp, ipConnections)
-        }
-
-        // Send initial connection message
-        this.sendToUser(userId, {
-          type: 'connected',
-          data: { message: 'Connected to notification stream' },
-        })
-
-        console.log(`SSE connection established for user: ${userId}`)
-      },
-      cancel: () => {
-        this.connections.delete(userId)
-
-        // Clean up IP tracking
-        if (clientIp) {
-          const ipConnections = this.connectionsByIp.get(clientIp)
-          if (ipConnections) {
-            ipConnections.delete(userId)
-            if (ipConnections.size === 0) {
-              this.connectionsByIp.delete(clientIp)
-            }
-          }
-        }
-
-        console.log(`SSE connection closed for user: ${userId}`)
-      },
-    })
-  }
-
-  // Send notification to specific user
-  sendNotificationToUser(
-    userId: string,
-    notification: {
-      id: string
-      type: string
-      title: string
-      message: string
-      actionUrl?: string
-      createdAt: string
-    },
-  ): boolean {
-    return this.sendToUser(userId, {
-      type: 'notification',
-      data: notification,
-    })
-  }
-
-  // Send unread count update to user
-  sendUnreadCountToUser(userId: string, count: number): boolean {
-    return this.sendToUser(userId, {
-      type: 'unread_count',
-      data: { count },
-    })
-  }
-
-  // Broadcast to all connected users
-  broadcast(message: { type: string; data: unknown }): void {
-    for (const [userId] of this.connections) {
-      this.sendToUser(userId, message)
-    }
-  }
-
-  // Send message to specific user
-  private sendToUser(userId: string, message: { type: string; data: unknown }): boolean {
-    const connection = this.connections.get(userId)
-    if (!connection) return false
-
-    try {
-      const sseData = `data: ${JSON.stringify(message)}\n\n`
-      connection.controller.enqueue(new TextEncoder().encode(sseData))
-      return true
-    } catch (error) {
-      console.error(`Failed to send SSE message to user ${userId}:`, error)
-      this.connections.delete(userId)
-      return false
-    }
-  }
-
-  // Keep connections alive with periodic pings
-  private startPingInterval(): void {
-    this.pingInterval = setInterval(() => {
-      const now = Date.now()
-      const staleConnections: string[] = []
-
-      for (const [userId, connection] of this.connections) {
-        // Send ping
-        const pingSuccess = this.sendToUser(userId, {
-          type: 'ping',
-          data: { timestamp: now },
-        })
-
-        if (!pingSuccess || now - connection.lastPing > 60000) {
-          // Connection failed or hasn't responded to ping in 60 seconds
-          staleConnections.push(userId)
-        } else {
-          connection.lastPing = now
-        }
-      }
-
-      // Clean up stale connections
-      for (const userId of staleConnections) {
-        this.connections.delete(userId)
-        console.log(`Removed stale SSE connection for user: ${userId}`)
-      }
-    }, 30000) // Ping every 30 seconds
-    // Let process exit if this is the only timer
-    this.pingInterval.unref?.()
-  }
-
-  // Get connection status
-  getConnectionStatus(): {
-    totalConnections: number
-    connectedUsers: string[]
-  } {
-    return {
-      totalConnections: this.connections.size,
-      connectedUsers: Array.from(this.connections.keys()),
-    }
-  }
-
-  // Cleanup
-  destroy(): void {
-    if (this.pingInterval) {
-      clearInterval(this.pingInterval)
-      this.pingInterval = null
-    }
-
-    // Close all connections
-    for (const [userId, connection] of this.connections) {
-      try {
-        connection.controller.close()
-      } catch (error) {
-        console.error(`Error closing connection for user ${userId}:`, error)
-      }
-    }
-
-    this.connections.clear()
-    this.connectionsByIp.clear()
-  }
-}
-
-// Singleton instance
-export const realtimeNotificationService = new RealtimeNotificationService()
-
-/**
- * Helper function to create SSE response with proper CORS
- * @param stream
- * @param origin
- */
-export function createSSEResponse(stream: ReadableStream, origin?: string): Response {
-  // Use centralized CORS configuration
-  const allowedOrigins = getAllowedOrigins()
-
-  // Allow mobile apps (no origin) or explicitly allowed origins
-  const allowOrigin = !origin
-    ? '*' // No origin header (mobile apps)
-    : allowedOrigins.length === 0
-      ? '*' // No origins configured (dev mode)
-      : allowedOrigins.includes(origin)
-        ? origin // Origin is allowed
-        : allowedOrigins[0] || '*' // Fallback to first allowed origin
-
-  return new Response(stream, {
-    headers: {
-      'Content-Type': 'text/event-stream',
-      'Cache-Control': 'no-cache',
-      Connection: 'keep-alive',
-      'Access-Control-Allow-Origin': allowOrigin,
-      'Access-Control-Allow-Headers': 'Cache-Control',
-      'Access-Control-Allow-Credentials': 'true',
-    },
-  })
-}
diff --git a/src/server/notifications/service.test.ts b/src/server/notifications/service.test.ts
index d72236f0b..235bb19f3 100644
--- a/src/server/notifications/service.test.ts
+++ b/src/server/notifications/service.test.ts
@@ -1,5 +1,10 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { DeliveryChannel, NotificationCategory, NotificationType } from '@orm/client'
+import {
+  DeliveryChannel,
+  NotificationCategory,
+  NotificationDeliveryStatus,
+  NotificationType,
+} from '@orm/client'
 import { NOTIFICATION_EVENTS } from './eventEmitter'
 import type { NotificationEventData } from './eventEmitter'
 import type { NotificationService } from './service'
@@ -105,16 +110,9 @@ vi.mock('@/server/notifications/rateLimitService', () => ({
   },
 }))
 
-vi.mock('@/server/notifications/realtimeService', () => ({
-  realtimeNotificationService: {
-    sendNotificationToUser: vi.fn().mockReturnValue(true),
-    sendUnreadCountToUser: vi.fn(),
-  },
-}))
-
 vi.mock('@/server/notifications/emailService', () => ({
   createEmailService: vi.fn().mockReturnValue({
-    sendNotificationEmail: vi.fn().mockResolvedValue({ success: true }),
+    sendNotificationEmail: mockSendNotificationEmail,
   }),
 }))
 
@@ -122,12 +120,16 @@ vi.mock('@/lib/logger', () => ({
   logger: { log: vi.fn(), error: vi.fn() },
 }))
 
-const { mockIterateFollowerUserIds, mockScheduleNotification } = vi.hoisted(() => ({
-  mockIterateFollowerUserIds: vi.fn(),
-  mockScheduleNotification: vi
-    .fn<(data: NotificationData, scheduledFor?: Date, maxAttempts?: number) => string>()
-    .mockReturnValue('batch-id-1'),
-}))
+const { mockIterateFollowerUserIds, mockScheduleNotification, mockSendNotificationEmail } =
+  vi.hoisted(() => ({
+    mockIterateFollowerUserIds: vi.fn(),
+    mockScheduleNotification: vi
+      .fn<(data: NotificationData, scheduledFor?: Date, maxAttempts?: number) => string>()
+      .mockReturnValue('batch-id-1'),
+    mockSendNotificationEmail: vi
+      .fn<(email: string, data: NotificationData) => Promise<{ success: boolean }>>()
+      .mockResolvedValue({ success: true }),
+  }))
 vi.mock('@/server/repositories/game-follow.repository', () => {
   class MockGameFollowRepository {
     iterateFollowerUserIds = mockIterateFollowerUserIds
@@ -146,8 +148,6 @@ vi.mock('@/server/repositories/notification-preferences.repository', () => ({
     }),
 }))
 
-// ── Helpers ────────────────────────────────────────────────────────
-
 function resetMocks() {
   for (const model of Object.values(mockPrisma)) {
     for (const fn of Object.values(model)) {
@@ -156,6 +156,8 @@ function resetMocks() {
   }
   mockIterateFollowerUserIds.mockReset()
   mockScheduleNotification.mockClear()
+  mockSendNotificationEmail.mockReset()
+  mockSendNotificationEmail.mockResolvedValue({ success: true })
   mockPrisma.userBan.findMany.mockResolvedValue([])
   mockPrisma.userRelationship.findMany.mockResolvedValue([])
   mockPrisma.notification.findFirst.mockResolvedValue(null)
@@ -572,6 +574,41 @@ describe('NotificationService', () => {
     })
   })
 
+  describe('createNotification', () => {
+    it('sends email for immediate BOTH delivery', async () => {
+      const { NotificationService } = await import('./service')
+      service = new NotificationService({ enableEmailDelivery: true })
+      mockPrisma.notification.create.mockResolvedValue({ id: 'notification-1' })
+      mockPrisma.notification.update.mockResolvedValue({ id: 'notification-1' })
+      mockPrisma.user.findUnique.mockResolvedValue({ email: 'user@example.com' })
+
+      const result = await service.createNotification(
+        {
+          userId: 'user-1',
+          type: NotificationType.FEATURE_ANNOUNCEMENT,
+          category: NotificationCategory.SYSTEM,
+          title: 'Release available',
+          message: 'A new release is ready.',
+          deliveryChannel: DeliveryChannel.BOTH,
+        },
+        { immediate: true },
+      )
+
+      expect(result).toBe('notification-1')
+      expect(mockSendNotificationEmail).toHaveBeenCalledWith(
+        'user@example.com',
+        expect.objectContaining({
+          userId: 'user-1',
+          deliveryChannel: DeliveryChannel.BOTH,
+        }),
+      )
+      expect(mockPrisma.notification.update).toHaveBeenCalledWith({
+        where: { id: 'notification-1' },
+        data: { deliveryStatus: NotificationDeliveryStatus.SENT },
+      })
+    })
+  })
+
   describe('createNotificationFromEvent', () => {
     it('creates a scheduled listing approval notification from enriched listing data', async () => {
       mockPrisma.listing.findUnique.mockResolvedValue(
diff --git a/src/server/notifications/service.ts b/src/server/notifications/service.ts
index a42161fcc..80b6d7854 100644
--- a/src/server/notifications/service.ts
+++ b/src/server/notifications/service.ts
@@ -19,7 +19,6 @@ import {
 import { createEmailService } from './emailService'
 import { type NotificationEventData, notificationEventEmitter } from './eventEmitter'
 import { notificationRateLimitService } from './rateLimitService'
-import { realtimeNotificationService } from './realtimeService'
 import { notificationTemplateEngine, type TemplateContext } from './templates'
 import type {
   NotificationData,
@@ -44,11 +43,6 @@ export class NotificationService {
   constructor(config: Partial<NotificationServiceConfig> = {}) {
     this.config = {
       enableEmailDelivery: false,
-      enableRealTimeDelivery: true,
-      maxRetries: 3,
-      retryDelayMs: 1000,
-      batchSize: 50,
-      rateLimitPerMinute: 60,
       ...config,
     }
     this.setupEventListeners()
@@ -61,7 +55,6 @@ export class NotificationService {
       scheduledFor?: Date
     } = {},
   ): Promise<string> {
-    // Check rate limits first
     const rateLimitStatus = await notificationRateLimitService.checkRateLimit(
       data.userId,
       data.type,
@@ -72,15 +65,12 @@ export class NotificationService {
       throw new Error(`Rate limit exceeded: ${rateLimitStatus.reason}`)
     }
 
-    // Record the notification for rate limiting
     notificationRateLimitService.recordNotification(data.userId, data.type)
 
-    // Determine if we should use immediate processing or batching
     const useImmediate = options.immediate ?? false
     const scheduledFor = options.scheduledFor ?? new Date()
 
     if (useImmediate) {
-      // Process immediately (for direct API calls, admin notifications, etc.)
       const notification = await prisma.notification.create({
         data: {
           userId: data.userId,
@@ -95,20 +85,14 @@ export class NotificationService {
         },
       })
 
-      // Attempt immediate delivery
       await this.deliverNotification(notification.id, data)
 
-      // Invalidate analytics cache when new notifications are created
       notificationAnalyticsService.clearCache()
 
       return notification.id
-    } else {
-      // Use batching service for better performance and retry logic
-      const batchId = notificationBatchingService.scheduleNotification(data, scheduledFor)
-
-      console.log(`Notification scheduled for batch processing: ${batchId}`)
-      return batchId
     }
+
+    return notificationBatchingService.scheduleNotification(data, scheduledFor)
   }
 
   async createNotificationFromEvent(
@@ -116,9 +100,7 @@ export class NotificationService {
     userId: string,
   ): Promise<string | null> {
     try {
-      // Map event type to notification type (with payload-based refinements)
       let notificationType = this.mapEventToNotificationType(eventData.eventType)
-      // Refine types that depend on payload values
       if (eventData.eventType === 'listing.voted') {
         const vote = eventData.payload?.voteValue ?? true
         notificationType = vote
@@ -133,27 +115,22 @@ export class NotificationService {
       }
       if (!notificationType) return null
 
-      // Check user preferences
       const shouldSend = await this.shouldSendNotification(userId, notificationType, eventData)
       if (!shouldSend) return null
 
-      // Check for duplicate notifications before creating
       const isDuplicate = await this.checkForDuplicateNotification(userId, notificationType)
       if (isDuplicate) {
         logger.log(`Skipping duplicate notification for user ${userId}, type ${notificationType}`)
         return null
       }
 
-      // Enrich context with database data
       const enrichedContext = await this.enrichContextWithData(eventData, notificationType)
 
-      // Generate notification content
       const template = notificationTemplateEngine.generateTemplate(
         notificationType,
         enrichedContext,
       )
 
-      // Create notification data
       const notificationData: NotificationData = {
         userId,
         type: notificationType,
@@ -162,13 +139,11 @@ export class NotificationService {
         message: template.message,
         actionUrl: template.actionUrl,
         metadata: template.metadata,
-        deliveryChannel: DeliveryChannel.IN_APP, // Default to in-app for now
+        deliveryChannel: DeliveryChannel.IN_APP,
       }
 
-      // Event-driven notifications use batching for better performance
-      // This is especially important for bulk operations like listing approvals
       return await this.createNotification(notificationData, {
-        immediate: false, // Use batching for event-driven notifications
+        immediate: false,
       })
     } catch (error) {
       logger.error('Error creating notification from event:', error)
@@ -179,15 +154,14 @@ export class NotificationService {
   private async deliverNotification(notificationId: string, data: NotificationData): Promise<void> {
     const deliveryResults: NotificationDeliveryResult[] = []
 
-    // Always deliver in-app notifications
-    const inAppResult = await this.deliverInApp(notificationId, data)
+    const inAppResult = this.deliverInApp()
     deliveryResults.push(inAppResult)
 
-    // Deliver email if enabled and email service is configured
     if (
       this.config.enableEmailDelivery &&
       this.emailService &&
-      data.deliveryChannel === DeliveryChannel.EMAIL
+      (data.deliveryChannel === DeliveryChannel.EMAIL ||
+        data.deliveryChannel === DeliveryChannel.BOTH)
     ) {
       const user = await prisma.user.findUnique({
         where: { id: data.userId },
@@ -200,7 +174,6 @@ export class NotificationService {
       }
     }
 
-    // Update delivery status based on results
     const hasSuccessfulDelivery = deliveryResults.some((result) => result.success)
     const allDeliveriesFailed = deliveryResults.every((result) => !result.success)
 
@@ -216,49 +189,11 @@ export class NotificationService {
     })
   }
 
-  private async deliverInApp(
-    notificationId: string,
-    data: NotificationData,
-  ): Promise<NotificationDeliveryResult> {
-    try {
-      // Send real-time notification if user is connected
-      const notification = await prisma.notification.findUnique({
-        where: { id: notificationId },
-      })
-
-      if (notification) {
-        const sent = realtimeNotificationService.sendNotificationToUser(data.userId, {
-          id: notification.id,
-          type: notification.type,
-          title: notification.title,
-          message: notification.message,
-          actionUrl: notification.actionUrl || undefined,
-          createdAt: notification.createdAt.toISOString(),
-        })
-
-        // Also update unread count
-        const unreadCount = await prisma.notification.count({
-          where: { userId: data.userId, isRead: false },
-        })
-
-        realtimeNotificationService.sendUnreadCountToUser(data.userId, unreadCount)
-
-        logger.log(`Real-time notification ${sent ? 'sent' : 'queued'} for user ${data.userId}`)
-      }
-
-      return {
-        success: true,
-        channel: DeliveryChannel.IN_APP,
-        status: NotificationDeliveryStatus.SENT,
-      }
-    } catch (error) {
-      console.error('In-app delivery error:', error)
-      return {
-        success: false,
-        channel: DeliveryChannel.IN_APP,
-        status: NotificationDeliveryStatus.FAILED,
-        error: error instanceof Error ? error.message : 'Unknown error',
-      }
+  private deliverInApp(): NotificationDeliveryResult {
+    return {
+      success: true,
+      channel: DeliveryChannel.IN_APP,
+      status: NotificationDeliveryStatus.SENT,
     }
   }
 
@@ -269,13 +204,10 @@ export class NotificationService {
   ): Promise<boolean> {
     const preference = await this.prefRepo.getByType(userId, notificationType)
 
-    // If no preference exists and this type has an alias, check alias preference
     const aliasType = this.aliasPreferenceMap[notificationType]
     const aliasPreference =
       !preference && aliasType ? await this.prefRepo.getByType(userId, aliasType) : null
 
-    // If no preference exists, default to enabled for most notification types
-    // Only default to disabled for system notifications for non-admin users
     if (!preference && !aliasPreference) {
       if (
         notificationType === NotificationType.MAINTENANCE_NOTICE ||
@@ -292,7 +224,6 @@ export class NotificationService {
     }
     if (!(preference?.inAppEnabled ?? aliasPreference?.inAppEnabled ?? true)) return false
 
-    // Check per-listing preferences for listing-related notifications
     if (eventData.payload?.listingId) {
       const listingPreference = await this.prefRepo.getListingPreference(
         userId,
@@ -378,23 +309,12 @@ export class NotificationService {
   }
 
   async markAsRead(notificationId: string, userId: string): Promise<void> {
-    // Update notification as read
     const updatedCount = await prisma.notification.updateMany({
-      where: { id: notificationId, userId, isRead: false }, // Only update if currently unread
+      where: { id: notificationId, userId, isRead: false },
       data: { isRead: true },
     })
 
-    // If notification was actually updated, invalidate caches and update real-time count
     if (updatedCount.count > 0) {
-      // Get updated unread count
-      const unreadCount = await prisma.notification.count({
-        where: { userId, isRead: false },
-      })
-
-      // Send real-time unread count update
-      realtimeNotificationService.sendUnreadCountToUser(userId, unreadCount)
-
-      // Clear analytics cache since notification status changed
       notificationAnalyticsService.clearCache()
 
       logger.log(`Marked notification ${notificationId} as read for user ${userId}`)
@@ -402,18 +322,12 @@ export class NotificationService {
   }
 
   async markAllAsRead(userId: string): Promise<void> {
-    // Update all unread notifications as read
     const updatedCount = await prisma.notification.updateMany({
       where: { userId, isRead: false },
       data: { isRead: true },
     })
 
-    // If any notifications were updated, invalidate caches and update real-time count
     if (updatedCount.count > 0) {
-      // Send real-time unread count update (should be 0 after marking all as read)
-      realtimeNotificationService.sendUnreadCountToUser(userId, 0)
-
-      // Clear analytics cache since notification status changed
       notificationAnalyticsService.clearCache()
 
       logger.log(`Marked ${updatedCount.count} notifications as read for user ${userId}`)
@@ -421,30 +335,11 @@ export class NotificationService {
   }
 
   async deleteNotification(notificationId: string, userId: string): Promise<void> {
-    // First check if the notification exists and is unread
-    const notification = await prisma.notification.findFirst({
-      where: { id: notificationId, userId },
-      select: { isRead: true },
-    })
-
-    // Delete the notification
     const deletedCount = await prisma.notification.deleteMany({
       where: { id: notificationId, userId },
     })
 
-    // If notification was deleted and was unread, update real-time count
     if (deletedCount.count > 0) {
-      // If the deleted notification was unread, update the unread count
-      if (notification && !notification.isRead) {
-        const unreadCount = await prisma.notification.count({
-          where: { userId, isRead: false },
-        })
-
-        // Send real-time unread count update
-        realtimeNotificationService.sendUnreadCountToUser(userId, unreadCount)
-      }
-
-      // Clear analytics cache since a notification was deleted
       notificationAnalyticsService.clearCache()
 
       console.log(`Deleted notification ${notificationId} for user ${userId}`)
@@ -475,7 +370,6 @@ export class NotificationService {
   }
 
   setupEventListeners(): void {
-    // Prevent duplicate listener registration
     if (this.listenersSetup) return
 
     notificationEventEmitter.onNotificationEvent(this.handleNotificationEvent.bind(this))
@@ -485,23 +379,19 @@ export class NotificationService {
 
   private async handleNotificationEvent(eventData: NotificationEventData): Promise<void> {
     try {
-      // Get users to notify
       const userIds = await this.getUsersForEvent(eventData)
 
-      // Create notifications for each user
       const notificationPromises = userIds.map((userId) =>
         this.createNotificationFromEvent(eventData, userId),
       )
 
       await Promise.allSettled(notificationPromises)
 
-      // On listing approval, notify hardware-preference matches and game followers
       if (eventData.eventType === 'listing.approved' && eventData.payload?.listingId) {
         await this.notifyMatchingHardwareUsers(eventData, userIds)
         await this.notifyGameFollowers(eventData, userIds, 'listing')
       }
 
-      // On PC listing approval, notify game followers
       if (eventData.eventType === 'pcListing.approved' && eventData.payload?.pcListingId) {
         await this.notifyGameFollowers(eventData, userIds, 'pcListing')
       }
@@ -634,7 +524,6 @@ export class NotificationService {
 
     switch (eventData.eventType) {
       case 'listing.verified': {
-        // Notify listing author (exclude actor via global filter below)
         if (eventData.payload?.listingId) {
           const listing = await prisma.listing.findUnique({
             where: { id: eventData.payload.listingId },
@@ -646,7 +535,6 @@ export class NotificationService {
       }
       case 'listing.commented':
       case 'listing.voted':
-        // Get listing author (but not the person who triggered the event)
         if (eventData.payload?.listingId && eventData.triggeredBy) {
           const listing = await prisma.listing.findUnique({
             where: { id: eventData.payload.listingId },
@@ -662,7 +550,6 @@ export class NotificationService {
       case 'comment.downvoted':
       case 'comment.created':
       case 'comment.replied':
-        // Notify comment author (but not the actor)
         if (eventData.payload?.commentId && eventData.triggeredBy) {
           const comment = await prisma.comment.findUnique({
             where: { id: eventData.payload.commentId },
@@ -672,7 +559,6 @@ export class NotificationService {
             userIds.push(comment.userId)
           }
         }
-        // For replies, also notify the parent comment author
         if (
           eventData.eventType === 'comment.replied' &&
           eventData.payload?.parentId &&
@@ -693,7 +579,6 @@ export class NotificationService {
         break
 
       case 'user.mentioned':
-        // Get mentioned user
         if (eventData.payload?.userId) {
           userIds.push(eventData.payload.userId)
         }
@@ -709,7 +594,6 @@ export class NotificationService {
         break
 
       case 'report.created':
-        // Notify moderators and above
         {
           const systemUsers = await prisma.user.findMany({
             where: {
@@ -722,14 +606,12 @@ export class NotificationService {
         break
 
       case 'report.status_changed':
-        // Notify reporting user if provided
         if (eventData.payload?.userId) {
           userIds.push(eventData.payload.userId)
         }
         break
 
       case 'listing.approved':
-        // Get listing author + users with matching hardware preferences
         if (eventData.payload?.listingId) {
           const listing = await prisma.listing.findUnique({
             where: { id: eventData.payload.listingId },
@@ -737,14 +619,11 @@ export class NotificationService {
           })
           if (listing) {
             userIds.push(listing.authorId)
-            // Hardware-match users are handled separately in handleNotificationEvent
-            // because they need a different notification type (NEW_DEVICE_LISTING)
           }
         }
         break
 
       case 'pcListing.approved':
-        // Get PC listing author — game followers handled separately in handleNotificationEvent
         if (eventData.payload?.pcListingId) {
           const pcListing = await prisma.pcListing.findUnique({
             where: { id: eventData.payload.pcListingId },
@@ -757,7 +636,6 @@ export class NotificationService {
         break
 
       case 'listing.rejected':
-        // Get listing author
         if (eventData.payload?.listingId) {
           const listing = await prisma.listing.findUnique({
             where: { id: eventData.payload.listingId },
@@ -795,7 +673,6 @@ export class NotificationService {
         break
     }
 
-    // Exclude the actor from recipients universally (no self-notifications)
     if (eventData.triggeredBy) {
       const actorId = eventData.triggeredBy
       for (let i = userIds.length - 1; i >= 0; i--) {
@@ -803,10 +680,8 @@ export class NotificationService {
       }
     }
 
-    // Filter out banned users - they should not receive notifications
     const afterBanFilter = await this.filterBannedUsers(userIds)
 
-    // Filter out users who have blocked the triggering user
     return await this.filterBlockedUsers(afterBanFilter, eventData.triggeredBy)
   }
 
@@ -824,15 +699,10 @@ export class NotificationService {
     return prisma.user.findMany({ where, select: { id: true } })
   }
 
-  /**
-   * Filter out banned users from receiving notifications
-   * Banned users should not receive any notifications while their ban is active
-   */
   private async filterBannedUsers(userIds: string[]): Promise<string[]> {
     if (userIds.length === 0) return []
 
     try {
-      // Get all users who have active bans
       const bannedUserIds = await prisma.userBan.findMany({
         where: {
           userId: { in: userIds },
@@ -844,7 +714,6 @@ export class NotificationService {
 
       const bannedUserIdsSet = new Set(bannedUserIds.map((ban) => ban.userId))
 
-      // Filter out banned users
       const filteredUserIds = userIds.filter((userId) => !bannedUserIdsSet.has(userId))
 
       if (bannedUserIds.length > 0) {
@@ -854,8 +723,6 @@ export class NotificationService {
       return filteredUserIds
     } catch (error) {
       console.error('Error filtering banned users from notifications:', error)
-      // If we can't filter banned users, return all userIds to avoid breaking notifications entirely
-      // This is a fallback - in production, you might want to handle this differently
       return userIds
     }
   }
@@ -896,16 +763,11 @@ export class NotificationService {
     }
   }
 
-  /**
-   * Check for duplicate notifications to prevent spam
-   * Prevents the same notification from being sent multiple times for the same event
-   */
   private async checkForDuplicateNotification(
     userId: string,
     notificationType: NotificationType,
   ): Promise<boolean> {
     try {
-      // Define deduplication window based on notification type
       const deduplicationWindows: Partial<Record<NotificationType, number>> = {
         [NotificationType.LISTING_APPROVED]: ms.hours(1),
         [NotificationType.LISTING_REJECTED]: ms.hours(1),
@@ -931,9 +793,6 @@ export class NotificationService {
       const windowMs = deduplicationWindows[notificationType] || ms.minutes(30)
       const windowStart = new Date(Date.now() - windowMs)
 
-      // Check for existing similar notifications within the deduplication window
-      // For simplicity, we check by userId, type, and time window only
-      // This prevents rapid-fire duplicate notifications for the same user and type
       const existingNotification = await prisma.notification.findFirst({
         where: {
           userId,
@@ -954,7 +813,6 @@ export class NotificationService {
       return false
     } catch (error) {
       console.error('Error checking for duplicate notifications:', error)
-      // If we can't check for duplicates, allow the notification to prevent breaking functionality
       return false
     }
   }
@@ -967,7 +825,6 @@ export class NotificationService {
     const payload = eventData.payload || {}
 
     try {
-      // Get triggering user info
       if (eventData.triggeredBy) {
         const user = await prisma.user.findUnique({
           where: { id: eventData.triggeredBy },
@@ -976,7 +833,6 @@ export class NotificationService {
         context.userName = user?.name || undefined
       }
 
-      // Enrich based on notification type and available data
       if (payload.listingId) {
         const listing = await prisma.listing.findUnique({
           where: { id: payload.listingId },
@@ -1005,7 +861,6 @@ export class NotificationService {
         }
       }
 
-      // Enrich PC listing data
       if (payload.pcListingId && !context.listingId) {
         const pcListing = await prisma.pcListing.findUnique({
           where: { id: payload.pcListingId },
@@ -1022,7 +877,6 @@ export class NotificationService {
         }
       }
 
-      // Handle comment-specific data
       if (
         payload.commentId &&
         (notificationType === NotificationType.LISTING_COMMENT ||
@@ -1049,7 +903,6 @@ export class NotificationService {
           context.listingId = comment.listingId
           context.parentCommentId = comment.parentId || undefined
 
-          // If we don't have listing data yet, fetch it
           if (!context.listingTitle && comment.listingId) {
             const listing = await prisma.listing.findUnique({
               where: { id: comment.listingId },
@@ -1065,7 +918,6 @@ export class NotificationService {
         }
       }
 
-      // Handle game-specific data
       if (payload.gameId) {
         const game = await prisma.game.findUnique({
           where: { id: payload.gameId },
@@ -1077,7 +929,6 @@ export class NotificationService {
         }
       }
 
-      // Handle device-specific data for NEW_DEVICE_LISTING
       if (payload.deviceId && notificationType === NotificationType.NEW_DEVICE_LISTING) {
         const device = await prisma.device.findUnique({
           where: { id: payload.deviceId },
@@ -1091,7 +942,6 @@ export class NotificationService {
         }
       }
 
-      // Handle SOC-specific data for NEW_SOC_LISTING
       if (payload.socId && notificationType === NotificationType.NEW_SOC_LISTING) {
         const soc = await prisma.soC.findUnique({
           where: { id: payload.socId },
@@ -1103,7 +953,6 @@ export class NotificationService {
         }
       }
 
-      // Handle emulator-specific data
       if (payload.emulatorId) {
         const emulator = await prisma.emulator.findUnique({
           where: { id: payload.emulatorId },
@@ -1115,7 +964,6 @@ export class NotificationService {
         }
       }
 
-      // Handle role change specific data
       if (notificationType === NotificationType.ROLE_CHANGED) {
         context.oldRole = payload.oldRole as string
         context.newRole = payload.newRole as string
@@ -1130,7 +978,6 @@ export class NotificationService {
         }
       }
 
-      // Handle moderation-specific data
       if (
         notificationType === NotificationType.LISTING_APPROVED ||
         notificationType === NotificationType.LISTING_REJECTED
@@ -1154,7 +1001,6 @@ export class NotificationService {
         context.rejectedAt = payload.rejectedAt as string
       }
 
-      // Handle user ban/unban data
       if (
         notificationType === NotificationType.USER_BANNED ||
         notificationType === NotificationType.USER_UNBANNED
@@ -1171,7 +1017,6 @@ export class NotificationService {
         }
       }
 
-      // Handle report data
       if (
         notificationType === NotificationType.REPORT_CREATED ||
         notificationType === NotificationType.REPORT_STATUS_CHANGED
@@ -1185,7 +1030,6 @@ export class NotificationService {
           (payload.listingId ? `/listings/${payload.listingId}` : undefined)
       }
 
-      // Handle developer verified
       if (notificationType === NotificationType.VERIFIED_DEVELOPER && payload.emulatorId) {
         const emulator = await prisma.emulator.findUnique({
           where: { id: payload.emulatorId as string },
@@ -1197,7 +1041,6 @@ export class NotificationService {
         }
       }
 
-      // Refine listing vote events to up/down based on payload
       if (
         (notificationType === NotificationType.LISTING_UPVOTED ||
           notificationType === NotificationType.LISTING_VOTE_UP ||
@@ -1208,7 +1051,6 @@ export class NotificationService {
         context.voteValue = payload.voteValue
       }
 
-      // Copy over any additional metadata
       Object.keys(payload).forEach((key) => {
         if (!context[key]) {
           context[key] = payload[key]
@@ -1221,34 +1063,6 @@ export class NotificationService {
     return context
   }
 
-  /**
-   * Schedule a notification for future delivery (e.g., weekly digests, maintenance notices)
-   */
-  async scheduleNotification(
-    data: NotificationData,
-    scheduledFor: Date,
-    maxAttempts?: number,
-  ): Promise<string> {
-    return notificationBatchingService.scheduleNotification(data, scheduledFor, maxAttempts)
-  }
-
-  /**
-   * Schedule weekly digest notifications for a user
-   */
-  scheduleWeeklyDigest(userId: string): void {
-    notificationBatchingService.scheduleWeeklyDigest(userId)
-  }
-
-  /**
-   * Schedule maintenance notifications for all users
-   */
-  scheduleMaintenanceNotification(scheduledFor: Date, title: string, message: string): void {
-    notificationBatchingService.scheduleMaintenanceNotification(scheduledFor, title, message)
-  }
-
-  /**
-   * Get current batching queue status
-   */
   getBatchingQueueStatus() {
     return notificationBatchingService.getQueueStatus()
   }
diff --git a/src/server/notifications/types.ts b/src/server/notifications/types.ts
index c3832ed9a..8c46ee00a 100644
--- a/src/server/notifications/types.ts
+++ b/src/server/notifications/types.ts
@@ -5,17 +5,6 @@ import type {
   NotificationDeliveryStatus,
 } from '@orm/client'
 
-export interface NotificationEvent {
-  id: string
-  eventType: string
-  entityType: string
-  entityId: string
-  triggeredBy?: string
-  payload?: Record<string, unknown>
-  processedAt?: Date
-  createdAt: Date
-}
-
 export interface NotificationData {
   userId: string
   type: NotificationType
@@ -27,19 +16,6 @@ export interface NotificationData {
   deliveryChannel?: DeliveryChannel
 }
 
-export interface NotificationPreferenceData {
-  userId: string
-  type: NotificationType
-  inAppEnabled: boolean
-  emailEnabled: boolean
-}
-
-export interface ListingNotificationPreferenceData {
-  userId: string
-  listingId: string
-  isEnabled: boolean
-}
-
 export interface NotificationTemplate {
   title: string
   message: string
@@ -72,9 +48,4 @@ export interface NotificationEventPayload {
 
 export interface NotificationServiceConfig {
   enableEmailDelivery: boolean
-  enableRealTimeDelivery: boolean
-  maxRetries: number
-  retryDelayMs: number
-  batchSize: number
-  rateLimitPerMinute: number
 }
diff --git a/src/types/static-images.d.ts b/src/types/static-images.d.ts
new file mode 100644
index 000000000..323cd166d
--- /dev/null
+++ b/src/types/static-images.d.ts
@@ -0,0 +1,6 @@
+declare module '*.png' {
+  import type { StaticImageData } from 'next/image'
+
+  const image: StaticImageData
+  export default image
+}