diff --git a/src/app/admin/components/AdminNavIcon.tsx b/src/app/admin/components/AdminNavIcon.tsx
index 11940caae..495a1d282 100644
--- a/src/app/admin/components/AdminNavIcon.tsx
+++ b/src/app/admin/components/AdminNavIcon.tsx
@@ -17,7 +17,6 @@ import {
   Gavel,
   TrendingUp,
   Key,
-  Activity,
   FileKey,
   Award,
   Microchip,
@@ -41,7 +40,6 @@ const getAdminNavIcon = (href: string, className: string) => {
   if (href.includes(ADMIN_ROUTES.REPORTS)) return <AlertCircle className={className} />
   if (href.includes(ADMIN_ROUTES.USER_BANS)) return <Gavel className={className} />
   if (href.includes(ADMIN_ROUTES.TRUST_LOGS)) return <TrendingUp className={className} />
-  if (href.includes(ADMIN_ROUTES.MONITORING)) return <Activity className={className} />
   if (href.includes(ADMIN_ROUTES.PERMISSION_LOGS)) return <FileKey className={className} />
   if (href.includes(ADMIN_ROUTES.PERMISSIONS)) return <Key className={className} />
   if (href.includes(ADMIN_ROUTES.BADGES)) return <Award className={className} />
diff --git a/src/app/admin/config/routes.ts b/src/app/admin/config/routes.ts
index baf0853ac..82afb1d43 100644
--- a/src/app/admin/config/routes.ts
+++ b/src/app/admin/config/routes.ts
@@ -35,10 +35,9 @@ export const ADMIN_ROUTES = {
   API_ACCESS: '/admin/api-access',
   API_ACCESS_DEV: '/admin/api-access/developer',
 
-  // Reports & Monitoring
+  // Reports
   REPORTS: '/admin/reports',
   TRUST_LOGS: '/admin/trust-logs',
-  MONITORING: '/admin/monitoring',
   PERFORMANCE: '/admin/performance',
   ANDROID_RELEASES: '/admin/releases',
   ENTITLEMENTS: '/admin/entitlements',
diff --git a/src/app/admin/data.ts b/src/app/admin/data.ts
index 8e3f65002..7f07ab163 100644
--- a/src/app/admin/data.ts
+++ b/src/app/admin/data.ts
@@ -170,12 +170,6 @@ export const superAdminNavItems: AdminNavItem[] = [
     exact: false,
     description: 'Manage roles and permissions.',
   },
-  {
-    href: ADMIN_ROUTES.MONITORING,
-    label: 'System Monitoring',
-    exact: true,
-    description: 'Monitor system performance and metrics.',
-  },
   {
     href: ADMIN_ROUTES.PERMISSION_LOGS,
     label: 'Permission Logs',
diff --git a/src/app/admin/monitoring/components/BundleSizeMonitor.tsx b/src/app/admin/monitoring/components/BundleSizeMonitor.tsx
deleted file mode 100644
index dae8bddc8..000000000
--- a/src/app/admin/monitoring/components/BundleSizeMonitor.tsx
+++ /dev/null
@@ -1,156 +0,0 @@
-'use client'
-
-import { Package, FileText, AlertTriangle } from 'lucide-react'
-import { useState, useEffect } from 'react'
-import { Card } from '@/components/ui'
-import { cn } from '@/lib/utils'
-
-interface BundleInfo {
-  name: string
-  size: number
-  gzipSize: number
-  category: 'page' | 'component' | 'library'
-}
-
-export function BundleSizeMonitor() {
-  const [bundles, setBundles] = useState<BundleInfo[]>([])
-  const [loading, setLoading] = useState(true)
-
-  useEffect(() => {
-    // Get  bundle information from Next.js build output
-    const fetchBundleInfo = async () => {
-      try {
-        // TODO: In production, this would connect to the build analytics
-        // For now, we'll use performance.getEntriesByType to get script sizes
-        const resources = performance.getEntriesByType('resource') as PerformanceResourceTiming[]
-
-        const scripts = resources
-          .filter((resource) => resource.name.includes('.js') || resource.name.includes('.css'))
-          .map((resource) => ({
-            name: resource.name.split('/').pop() || 'unknown',
-            size: resource.transferSize || 0,
-            gzipSize: resource.encodedBodySize || 0,
-            category: resource.name.includes('_app')
-              ? 'page'
-              : resource.name.includes('node_modules')
-                ? 'library'
-                : ('component' as 'page' | 'component' | 'library'),
-          }))
-          .filter((bundle) => bundle.size > 0)
-          .sort((a, b) => b.size - a.size)
-          .slice(0, 10) // Top 10 largest bundles
-
-        setBundles(scripts)
-        setLoading(false)
-      } catch (error) {
-        console.error('Failed to fetch bundle info:', error)
-        setLoading(false)
-      }
-    }
-
-    fetchBundleInfo()
-  }, [])
-
-  const formatBytes = (bytes: number) => {
-    if (bytes < 1024) return `${bytes} B`
-    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`
-    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`
-  }
-
-  const getCategoryIcon = (category: string) => {
-    switch (category) {
-      case 'page':
-        return <FileText className="h-4 w-4" />
-      case 'library':
-        return <Package className="h-4 w-4" />
-      default:
-        return <FileText className="h-4 w-4" />
-    }
-  }
-
-  const getCategoryColor = (category: string) => {
-    switch (category) {
-      case 'page':
-        return 'text-blue-500'
-      case 'library':
-        return 'text-purple-500'
-      default:
-        return 'text-gray-500'
-    }
-  }
-
-  const totalSize = bundles.reduce((sum, bundle) => sum + bundle.size, 0)
-  const totalGzipSize = bundles.reduce((sum, bundle) => sum + bundle.gzipSize, 0)
-
-  return (
-    <Card className="p-6">
-      <div className="flex items-center justify-between mb-6">
-        <div>
-          <h3 className="text-lg font-semibold">Bundle Size Monitor</h3>
-          <p className="text-sm text-muted-foreground">Track JavaScript and CSS bundle sizes</p>
-        </div>
-        {totalSize > 0 && (
-          <div className="text-right">
-            <p className="text-sm font-medium">Total Size</p>
-            <p className="text-2xl font-bold">{formatBytes(totalGzipSize)}</p>
-            <p className="text-xs text-muted-foreground">gzipped</p>
-          </div>
-        )}
-      </div>
-      {loading ? (
-        <div className="text-center py-8 text-muted-foreground">Loading bundle information...</div>
-      ) : bundles.length === 0 ? (
-        <div className="text-center py-8 text-muted-foreground">
-          <AlertTriangle className="h-8 w-8 mx-auto mb-2" />
-          <p>No bundle information available</p>
-          <p className="text-xs mt-1">Run a production build to see bundle sizes</p>
-        </div>
-      ) : (
-        <div className="space-y-3">
-          {bundles.map((bundle, index) => (
-            <div key={index} className="rounded-lg border p-3">
-              <div className="flex items-center justify-between mb-2">
-                <div className="flex items-center gap-2">
-                  <span className={cn(getCategoryColor(bundle.category))}>
-                    {getCategoryIcon(bundle.category)}
-                  </span>
-                  <span className="font-medium text-sm truncate max-w-[300px]">{bundle.name}</span>
-                </div>
-                <span className="text-sm font-medium">{formatBytes(bundle.gzipSize)}</span>
-              </div>
-              <div className="flex items-center gap-2">
-                <div className="flex-1">
-                  <div className="h-2 bg-muted rounded-full overflow-hidden">
-                    <div
-                      className={cn(
-                        'h-full transition-all',
-                        bundle.gzipSize > 100 * 1024
-                          ? 'bg-red-500'
-                          : bundle.gzipSize > 50 * 1024
-                            ? 'bg-amber-500'
-                            : 'bg-green-500',
-                      )}
-                      style={{
-                        width: `${(bundle.gzipSize / totalGzipSize) * 100}%`,
-                      }}
-                    />
-                  </div>
-                </div>
-                <span className="text-xs text-muted-foreground w-12 text-right">
-                  {((bundle.gzipSize / totalGzipSize) * 100).toFixed(0)}%
-                </span>
-              </div>
-            </div>
-          ))}
-        </div>
-      )}
-
-      <div className="mt-4 pt-4 border-t">
-        <p className="text-xs text-muted-foreground">
-          Bundle sizes are measured from loaded resources. For detailed analysis, run{' '}
-          <code className="px-1 py-0.5 bg-muted rounded">pnpm analyze</code>
-        </p>
-      </div>
-    </Card>
-  )
-}
diff --git a/src/app/admin/monitoring/components/DatabaseConnectionMonitor.tsx b/src/app/admin/monitoring/components/DatabaseConnectionMonitor.tsx
deleted file mode 100644
index df15e5b46..000000000
--- a/src/app/admin/monitoring/components/DatabaseConnectionMonitor.tsx
+++ /dev/null
@@ -1,323 +0,0 @@
-'use client'
-
-import { AlertTriangle, CheckCircle, Database, Loader2, Server, XCircle } from 'lucide-react'
-import { useState } from 'react'
-import { Badge, Button, Card } from '@/components/ui'
-import { api } from '@/lib/api'
-
-export function DatabaseConnectionMonitor() {
-  const [autoRefresh, setAutoRefresh] = useState(true)
-
-  const {
-    data: connectionStats,
-    isLoading: isLoadingStats,
-    refetch: refetchStats,
-  } = api.system.getConnectionStats.useQuery(undefined, {
-    refetchInterval: autoRefresh ? 5000 : false,
-  })
-
-  const {
-    data: activeConnections,
-    isLoading: isLoadingActive,
-    refetch: refetchActive,
-  } = api.system.getActiveConnections.useQuery(undefined, {
-    refetchInterval: autoRefresh ? 10000 : false,
-  })
-
-  const {
-    data: longRunningQueries,
-    isLoading: isLoadingLong,
-    refetch: refetchLong,
-  } = api.system.getLongRunningQueries.useQuery(undefined, {
-    refetchInterval: autoRefresh ? 10000 : false,
-  })
-
-  const { data: configValidation } = api.system.validateDatabaseConfig.useQuery()
-  const { data: poolConfig } = api.system.getPoolConfig.useQuery()
-
-  const handleRefreshAll = () => {
-    void refetchStats()
-    void refetchActive()
-    void refetchLong()
-  }
-
-  // Calculate connection health
-  const getConnectionHealth = () => {
-    if (!connectionStats) return 'unknown'
-    const activePercent = (connectionStats.active / connectionStats.total) * 100
-    if (connectionStats.idleInTransaction > 10) return 'critical'
-    if (activePercent > 80) return 'warning'
-    return 'healthy'
-  }
-
-  const health = getConnectionHealth()
-
-  return (
-    <div className="space-y-6">
-      <div className="flex items-center justify-between">
-        <div className="mt-4">
-          <h2 className="text-2xl font-bold">Database Connections</h2>
-          <p className="text-muted-foreground text-sm">
-            Monitor PostgreSQL connection pool and query performance
-          </p>
-        </div>
-        <div className="flex gap-2">
-          <Button
-            variant="outline"
-            size="sm"
-            onClick={() => setAutoRefresh(!autoRefresh)}
-            className="gap-2"
-          >
-            {autoRefresh ? (
-              <>
-                <Loader2 className="h-4 w-4 animate-spin" />
-                Auto-refresh On
-              </>
-            ) : (
-              'Auto-refresh Off'
-            )}
-          </Button>
-          <Button variant="outline" size="sm" onClick={handleRefreshAll}>
-            Refresh Now
-          </Button>
-        </div>
-      </div>
-
-      {/* Configuration Status */}
-      {configValidation && (
-        <Card className="p-6">
-          <div className="flex items-start justify-between">
-            <div>
-              <h3 className="mb-2 font-semibold">Configuration Status</h3>
-              {configValidation.isValid ? (
-                <div className="flex items-center gap-2 text-green-600">
-                  <CheckCircle className="h-4 w-4" />
-                  <span className="text-sm">Configuration is valid</span>
-                </div>
-              ) : (
-                <div className="space-y-2">
-                  <div className="flex items-center gap-2 text-amber-600">
-                    <AlertTriangle className="h-4 w-4" />
-                    <span className="text-sm font-medium">Configuration Issues Detected</span>
-                  </div>
-                  <ul className="ml-6 list-disc space-y-1 text-sm text-muted-foreground">
-                    {configValidation.warnings.map((warning, idx) => (
-                      <li key={idx}>{warning}</li>
-                    ))}
-                  </ul>
-                </div>
-              )}
-            </div>
-            {poolConfig && (
-              <div className="text-right text-sm">
-                <div className="text-muted-foreground">
-                  {poolConfig.isLocal ? 'Local Database' : 'Pool Configuration'}
-                </div>
-                <div className="mt-1 space-y-1">
-                  {poolConfig.isLocal ? (
-                    <div>
-                      <Badge variant="info">Local Development</Badge>
-                    </div>
-                  ) : (
-                    <>
-                      <div>
-                        pgBouncer:{' '}
-                        <Badge variant={poolConfig.hasPgBouncer ? 'success' : 'danger'}>
-                          {poolConfig.hasPgBouncer ? 'Enabled' : 'Disabled'}
-                        </Badge>
-                      </div>
-                      {poolConfig.connectionLimit && (
-                        <div>
-                          Limit:{' '}
-                          <Badge
-                            variant={
-                              poolConfig.connectionLimit <= 2
-                                ? 'success'
-                                : poolConfig.connectionLimit <= 5
-                                  ? 'warning'
-                                  : 'danger'
-                            }
-                          >
-                            {poolConfig.connectionLimit}
-                          </Badge>
-                        </div>
-                      )}
-                    </>
-                  )}
-                </div>
-              </div>
-            )}
-          </div>
-        </Card>
-      )}
-
-      {/* Connection Stats Overview */}
-      <div className="grid gap-4 md:grid-cols-2 lg:grid-cols-5">
-        <Card className="p-6">
-          <div className="flex flex-row items-center justify-between space-y-0 pb-2">
-            <h3 className="text-sm font-medium">Total Connections</h3>
-            <Database className="h-4 w-4 text-muted-foreground" />
-          </div>
-          <div className="text-2xl font-bold">
-            {isLoadingStats ? (
-              <Loader2 className="h-6 w-6 animate-spin" />
-            ) : (
-              (connectionStats?.total ?? 0)
-            )}
-          </div>
-          <p className="text-xs text-muted-foreground">All database connections</p>
-        </Card>
-
-        <Card className="p-6">
-          <div className="flex flex-row items-center justify-between space-y-0 pb-2">
-            <h3 className="text-sm font-medium">Active</h3>
-            <Server className="h-4 w-4 text-green-600" />
-          </div>
-          <div className="text-2xl font-bold">
-            {isLoadingStats ? (
-              <Loader2 className="h-6 w-6 animate-spin" />
-            ) : (
-              (connectionStats?.active ?? 0)
-            )}
-          </div>
-          <p className="text-xs text-muted-foreground">Executing queries</p>
-        </Card>
-
-        <Card className="p-6">
-          <div className="flex flex-row items-center justify-between space-y-0 pb-2">
-            <h3 className="text-sm font-medium">Idle</h3>
-            <Server className="h-4 w-4 text-muted-foreground" />
-          </div>
-          <div className="text-2xl font-bold">
-            {isLoadingStats ? (
-              <Loader2 className="h-6 w-6 animate-spin" />
-            ) : (
-              (connectionStats?.idle ?? 0)
-            )}
-          </div>
-          <p className="text-xs text-muted-foreground">Available connections</p>
-        </Card>
-
-        <Card className="p-6">
-          <div className="flex flex-row items-center justify-between space-y-0 pb-2">
-            <h3 className="text-sm font-medium">In Transaction</h3>
-            <Server className="h-4 w-4 text-amber-600" />
-          </div>
-          <div className="text-2xl font-bold">
-            {isLoadingStats ? (
-              <Loader2 className="h-6 w-6 animate-spin" />
-            ) : (
-              (connectionStats?.idleInTransaction ?? 0)
-            )}
-          </div>
-          <p className="text-xs text-muted-foreground">May be stuck</p>
-        </Card>
-
-        <Card className="p-6">
-          <div className="flex flex-row items-center justify-between space-y-0 pb-2">
-            <h3 className="text-sm font-medium">Health Status</h3>
-            {health === 'healthy' && <CheckCircle className="h-4 w-4 text-green-600" />}
-            {health === 'warning' && <AlertTriangle className="h-4 w-4 text-amber-600" />}
-            {health === 'critical' && <XCircle className="h-4 w-4 text-red-600" />}
-          </div>
-          <div className="text-2xl font-bold capitalize">{health}</div>
-          <p className="text-xs text-muted-foreground">Overall connection health</p>
-        </Card>
-      </div>
-
-      {/* Long-Running Queries */}
-      {longRunningQueries && longRunningQueries.length > 0 && (
-        <Card className="p-6">
-          <h3 className="mb-4 font-semibold text-red-600">
-            Long-Running Queries ({longRunningQueries.length})
-          </h3>
-          <div className="overflow-x-auto">
-            <table className="w-full text-sm">
-              <thead className="border-b">
-                <tr className="text-left">
-                  <th className="pb-2">PID</th>
-                  <th className="pb-2">User</th>
-                  <th className="pb-2">Application</th>
-                  <th className="pb-2">State</th>
-                  <th className="pb-2">Started</th>
-                  <th className="pb-2">Query</th>
-                </tr>
-              </thead>
-              <tbody>
-                {longRunningQueries.map((conn) => (
-                  <tr key={conn.pid} className="border-b">
-                    <td className="py-2">{conn.pid}</td>
-                    <td className="py-2">{conn.username}</td>
-                    <td className="py-2 text-muted-foreground">{conn.applicationName}</td>
-                    <td className="py-2">
-                      <Badge variant="danger">{conn.state}</Badge>
-                    </td>
-                    <td className="py-2 text-muted-foreground">
-                      {conn.queryStart ? new Date(conn.queryStart).toLocaleTimeString() : 'Unknown'}
-                    </td>
-                    <td className="max-w-md truncate py-2 font-mono text-xs">
-                      {conn.query ?? 'N/A'}
-                    </td>
-                  </tr>
-                ))}
-              </tbody>
-            </table>
-          </div>
-        </Card>
-      )}
-
-      {/* Active Connections */}
-      {activeConnections && activeConnections.length > 0 && (
-        <Card className="p-6">
-          <h3 className="mb-4 font-semibold">Active Connections ({activeConnections.length})</h3>
-          <div className="overflow-x-auto">
-            <table className="w-full text-sm">
-              <thead className="border-b">
-                <tr className="text-left">
-                  <th className="pb-2">PID</th>
-                  <th className="pb-2">User</th>
-                  <th className="pb-2">Application</th>
-                  <th className="pb-2">State</th>
-                  <th className="pb-2">Wait Event</th>
-                  <th className="pb-2">Query</th>
-                </tr>
-              </thead>
-              <tbody>
-                {activeConnections.map((conn) => (
-                  <tr key={conn.pid} className="border-b">
-                    <td className="py-2">{conn.pid}</td>
-                    <td className="py-2">{conn.username}</td>
-                    <td className="py-2 text-muted-foreground">{conn.applicationName}</td>
-                    <td className="py-2">
-                      <Badge variant={conn.state === 'active' ? 'success' : 'info'}>
-                        {conn.state}
-                      </Badge>
-                    </td>
-                    <td className="py-2 text-muted-foreground">{conn.waitEvent ?? 'None'}</td>
-                    <td className="max-w-md truncate py-2 font-mono text-xs">
-                      {conn.query ?? 'N/A'}
-                    </td>
-                  </tr>
-                ))}
-              </tbody>
-            </table>
-          </div>
-        </Card>
-      )}
-
-      {/* Empty State */}
-      {!isLoadingActive &&
-        !isLoadingLong &&
-        (!activeConnections || activeConnections.length === 0) &&
-        (!longRunningQueries || longRunningQueries.length === 0) && (
-          <Card className="p-12 text-center">
-            <CheckCircle className="mx-auto mb-4 h-12 w-12 text-green-600" />
-            <h3 className="mb-2 text-lg font-semibold">All Clear!</h3>
-            <p className="text-muted-foreground">
-              No active connections or long-running queries detected.
-            </p>
-          </Card>
-        )}
-    </div>
-  )
-}
diff --git a/src/app/admin/monitoring/components/PerformanceMetrics.tsx b/src/app/admin/monitoring/components/PerformanceMetrics.tsx
deleted file mode 100644
index d77d8b915..000000000
--- a/src/app/admin/monitoring/components/PerformanceMetrics.tsx
+++ /dev/null
@@ -1,158 +0,0 @@
-'use client'
-
-import { Activity, Zap, AlertCircle, CheckCircle } from 'lucide-react'
-import { useState, useEffect } from 'react'
-import { Card } from '@/components/ui'
-import { cn } from '@/lib/utils'
-
-interface Metric {
-  name: string
-  value: number
-  unit: string
-  status: 'good' | 'warning' | 'error'
-  description: string
-}
-
-export function PerformanceMetrics() {
-  const [metrics, setMetrics] = useState<Metric[]>([])
-  const [loading, setLoading] = useState(true)
-
-  useEffect(() => {
-    // Fetch real performance metrics from browser Performance API
-    const fetchMetrics = async () => {
-      try {
-        const navigation = performance.getEntriesByType(
-          'navigation',
-        )[0] as PerformanceNavigationTiming
-        const paint = performance.getEntriesByType('paint')
-
-        const fcp = paint.find((entry) => entry.name === 'first-contentful-paint')
-
-        const newMetrics: Metric[] = [
-          {
-            name: 'First Contentful Paint',
-            value: fcp ? fcp.startTime / 1000 : 0,
-            unit: 's',
-            status: 'good',
-            description: 'Time until first content is rendered',
-          },
-          {
-            name: 'DOM Content Loaded',
-            value: navigation.domContentLoadedEventEnd / 1000,
-            unit: 's',
-            status: getStatus('DOM Content Loaded', navigation.domContentLoadedEventEnd / 1000),
-            description: 'Time until DOM is fully loaded',
-          },
-          {
-            name: 'Page Load Time',
-            value: navigation.loadEventEnd / 1000,
-            unit: 's',
-            status: getStatus('Page Load Time', navigation.loadEventEnd / 1000),
-            description: 'Total page load time',
-          },
-          {
-            name: 'Time to First Byte',
-            value: navigation.responseStart - navigation.requestStart,
-            unit: 'ms',
-            status: getStatus(
-              'Time to First Byte',
-              navigation.responseStart - navigation.requestStart,
-            ),
-            description: 'Server response time',
-          },
-        ]
-
-        setMetrics(newMetrics)
-        setLoading(false)
-      } catch (error) {
-        console.error('Failed to fetch performance metrics:', error)
-        setLoading(false)
-      }
-    }
-
-    fetchMetrics()
-    const interval = setInterval(fetchMetrics, 10000)
-    return () => clearInterval(interval)
-  }, [])
-
-  const getStatus = (name: string, value: number): 'good' | 'warning' | 'error' => {
-    const thresholds: Record<string, { good: number; warning: number }> = {
-      'First Contentful Paint': { good: 1.8, warning: 3.0 },
-      'Largest Contentful Paint': { good: 2.5, warning: 4.0 },
-      'Time to Interactive': { good: 3.8, warning: 7.3 },
-      'Total Blocking Time': { good: 150, warning: 350 },
-      'Cumulative Layout Shift': { good: 0.1, warning: 0.25 },
-      'Speed Index': { good: 3.4, warning: 5.8 },
-    }
-
-    const threshold = thresholds[name]
-    if (!threshold) return 'good'
-
-    if (value <= threshold.good) return 'good'
-    if (value <= threshold.warning) return 'warning'
-    return 'error'
-  }
-
-  const getStatusIcon = (status: 'good' | 'warning' | 'error') => {
-    switch (status) {
-      case 'good':
-        return <CheckCircle className="h-4 w-4 text-green-500" />
-      case 'warning':
-        return <AlertCircle className="h-4 w-4 text-amber-500" />
-      case 'error':
-        return <AlertCircle className="h-4 w-4 text-red-500" />
-    }
-  }
-
-  const getStatusColor = (status: 'good' | 'warning' | 'error') => {
-    switch (status) {
-      case 'good':
-        return 'text-green-500'
-      case 'warning':
-        return 'text-amber-500'
-      case 'error':
-        return 'text-red-500'
-    }
-  }
-
-  return (
-    <Card className="p-6">
-      <div className="flex items-center gap-2 mb-6">
-        <Activity className="h-5 w-5" />
-        <div>
-          <h3 className="text-lg font-semibold">Core Web Vitals</h3>
-          <p className="text-sm text-muted-foreground">Real user performance metrics</p>
-        </div>
-      </div>
-      <div className="grid gap-4 md:grid-cols-2 lg:grid-cols-3">
-        {metrics.map((metric) => (
-          <div key={metric.name} className="rounded-lg border p-4 space-y-2">
-            <div className="flex items-center justify-between">
-              <h4 className="text-sm font-medium">{metric.name}</h4>
-              {getStatusIcon(metric.status)}
-            </div>
-            <div className="flex items-baseline gap-1">
-              <span className={cn('text-2xl font-bold', getStatusColor(metric.status))}>
-                {metric.value.toFixed(metric.unit === '' ? 2 : 1)}
-              </span>
-              {metric.unit && <span className="text-sm text-muted-foreground">{metric.unit}</span>}
-            </div>
-            <p className="text-xs text-muted-foreground">{metric.description}</p>
-          </div>
-        ))}
-      </div>
-
-      {!loading && metrics.length > 0 && (
-        <div className="mt-6 rounded-lg bg-muted p-4">
-          <div className="flex items-center gap-2 mb-2">
-            <Zap className="h-4 w-4" />
-            <h4 className="font-medium">Performance Summary</h4>
-          </div>
-          <p className="text-sm text-muted-foreground">
-            Based on real browser performance data. Metrics update every 10 seconds.
-          </p>
-        </div>
-      )}
-    </Card>
-  )
-}
diff --git a/src/app/admin/monitoring/page.tsx b/src/app/admin/monitoring/page.tsx
deleted file mode 100644
index 740da45fc..000000000
--- a/src/app/admin/monitoring/page.tsx
+++ /dev/null
@@ -1,25 +0,0 @@
-import { type Metadata } from 'next'
-import { AdminPageLayout } from '@/components/admin'
-import { BundleSizeMonitor } from './components/BundleSizeMonitor'
-import { DatabaseConnectionMonitor } from './components/DatabaseConnectionMonitor'
-import { PerformanceMetrics } from './components/PerformanceMetrics'
-
-export const metadata: Metadata = {
-  title: 'System Monitoring - Admin Dashboard',
-  description: 'Monitor system performance and bundle sizes',
-}
-
-export default function MonitoringDashboard() {
-  return (
-    <AdminPageLayout
-      title="System Monitoring"
-      description="Monitor system performance and bundle sizes"
-    >
-      <DatabaseConnectionMonitor />
-
-      <PerformanceMetrics />
-
-      <BundleSizeMonitor />
-    </AdminPageLayout>
-  )
-}
diff --git a/src/app/listings/ListingsPage.tsx b/src/app/listings/ListingsPage.tsx
index fd6147aa8..5622121bc 100644
--- a/src/app/listings/ListingsPage.tsx
+++ b/src/app/listings/ListingsPage.tsx
@@ -1,5 +1,6 @@
 'use client'
 
+import { useUser } from '@clerk/nextjs'
 import { Clock, GamepadIcon, CpuIcon } from 'lucide-react'
 import Link from 'next/link'
 import { useRouter } from 'next/navigation'
@@ -60,7 +61,11 @@ const LISTINGS_COLUMNS: ColumnDefinition[] = [
   { key: 'actions', label: 'Actions', alwaysVisible: true },
 ]
 
+const LOOKUP_DATA_STALE_TIME = ms.minutes(30)
+const LOOKUP_DATA_GC_TIME = ms.hours(1)
+
 function ListingsPage() {
+  const { isSignedIn } = useUser()
   const router = useRouter()
   const listingsState = useListingsState()
 
@@ -82,9 +87,11 @@ function ListingsPage() {
     storageKey: storageKeys.columnVisibility.listings,
   })
 
-  const userQuery = api.users.me.useQuery()
+  const userQuery = api.users.me.useQuery(undefined, {
+    enabled: isSignedIn === true,
+  })
   const userPreferencesQuery = api.userPreferences.get.useQuery(undefined, {
-    enabled: !!userQuery.data,
+    enabled: isSignedIn === true && !!userQuery.data,
     staleTime: ms.seconds(30),
     gcTime: ms.minutes(5),
   })
@@ -99,13 +106,37 @@ function ListingsPage() {
     socIds: listingsState.socIds,
   })
 
-  const systemsQuery = api.systems.get.useQuery()
+  const systemsQuery = api.systems.get.useQuery(undefined, {
+    staleTime: LOOKUP_DATA_STALE_TIME,
+    gcTime: LOOKUP_DATA_GC_TIME,
+  })
   // TODO: find a better alternative to hardcoding 10000 for devices (AsyncMultiselect)
-  const devicesQuery = api.devices.get.useQuery({ limit: 10000 })
+  const devicesQuery = api.devices.get.useQuery(
+    { limit: 10000 },
+    {
+      staleTime: LOOKUP_DATA_STALE_TIME,
+      gcTime: LOOKUP_DATA_GC_TIME,
+    },
+  )
   // TODO: find a better alternative to hardcoding 10000 for SoCs (AsyncMultiselect)
-  const socsQuery = api.socs.get.useQuery({ limit: 10000 })
-  const emulatorsQuery = api.emulators.get.useQuery({ limit: 100 })
-  const performanceScalesQuery = api.listings.performanceScales.useQuery()
+  const socsQuery = api.socs.get.useQuery(
+    { limit: 10000 },
+    {
+      staleTime: LOOKUP_DATA_STALE_TIME,
+      gcTime: LOOKUP_DATA_GC_TIME,
+    },
+  )
+  const emulatorsQuery = api.emulators.get.useQuery(
+    { limit: 100 },
+    {
+      staleTime: LOOKUP_DATA_STALE_TIME,
+      gcTime: LOOKUP_DATA_GC_TIME,
+    },
+  )
+  const performanceScalesQuery = api.listings.performanceScales.useQuery(undefined, {
+    staleTime: LOOKUP_DATA_STALE_TIME,
+    gcTime: LOOKUP_DATA_GC_TIME,
+  })
 
   const filterParams: RouterInput['listings']['get'] = {
     page: listingsState.page,
diff --git a/src/components/notifications/NotificationCenter.tsx b/src/components/notifications/NotificationCenter.tsx
index 1dd2f8d30..5304169a3 100644
--- a/src/components/notifications/NotificationCenter.tsx
+++ b/src/components/notifications/NotificationCenter.tsx
@@ -26,10 +26,15 @@ function NotificationCenter(props: Props) {
 
   const notificationsQuery = api.notifications.get.useQuery(
     { limit: 10, offset: 0 },
-    { enabled: !!user, refetchInterval: POLLING_INTERVALS.NOTIFICATIONS },
+    {
+      enabled: !!user,
+      refetchOnWindowFocus: true,
+      refetchInterval: POLLING_INTERVALS.NOTIFICATIONS,
+    },
   )
   const unreadCountQuery = api.notifications.getUnreadCount.useQuery(undefined, {
     enabled: !!user,
+    refetchOnWindowFocus: true,
     refetchInterval: POLLING_INTERVALS.NOTIFICATIONS,
   })
 
diff --git a/src/lib/api.tsx b/src/lib/api.tsx
index 1ec06dded..6e337b3d8 100644
--- a/src/lib/api.tsx
+++ b/src/lib/api.tsx
@@ -19,8 +19,8 @@ export function TRPCProvider(props: PropsWithChildren) {
           queries: {
             staleTime: ms.seconds(30),
             gcTime: ms.minutes(5),
-            refetchOnWindowFocus: true,
-            refetchOnReconnect: true,
+            refetchOnWindowFocus: false,
+            refetchOnReconnect: false,
             retry: shouldRetryTRPCQuery,
             retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 30000),
           },
diff --git a/src/lib/dynamic-imports.tsx b/src/lib/dynamic-imports.tsx
index 19ecbe9b8..4759089c0 100644
--- a/src/lib/dynamic-imports.tsx
+++ b/src/lib/dynamic-imports.tsx
@@ -1,7 +1,6 @@
 import dynamic from 'next/dynamic'
 import { LoadingSpinner } from '@/components/ui'
 
-// Loading component for dynamic imports
 const LoadingFallback = () => (
   <div className="flex items-center justify-center p-4">
     <LoadingSpinner />
@@ -36,11 +35,6 @@ export const TranslatableMarkdown = dynamic(
 )
 
 // Admin components
-export const CustomFieldList = dynamic(
-  () => import('@/app/admin/emulators/[emulatorId]/custom-fields/components/CustomFieldList'),
-  { loading: LoadingFallback },
-)
-
 export const RolePermissionMatrix = dynamic(
   () => import('@/app/admin/permissions/components/RolePermissionMatrix'),
   { loading: LoadingFallback },
diff --git a/src/server/api/root.ts b/src/server/api/root.ts
index 923774dbe..a9949f3e7 100644
--- a/src/server/api/root.ts
+++ b/src/server/api/root.ts
@@ -33,7 +33,6 @@ import { rawgRouter } from './routers/rawg'
 import { releasesRouter } from './routers/releases'
 import { socialRouter } from './routers/social'
 import { socsRouter } from './routers/socs'
-import { systemRouter } from './routers/system'
 import { systemsRouter } from './routers/systems'
 import { tgdbRouter } from './routers/tgdb'
 import { trustRouter } from './routers/trust'
@@ -55,7 +54,6 @@ export const appRouter = createTRPCRouter({
   deviceBrands: deviceBrandsRouter,
   socs: socsRouter,
   games: gamesRouter,
-  system: systemRouter,
   systems: systemsRouter,
   emulators: emulatorsRouter,
   users: usersRouter,
diff --git a/src/server/api/routers/listingReports.ts b/src/server/api/routers/listingReports.ts
index 1b1526fd5..04a079e5b 100644
--- a/src/server/api/routers/listingReports.ts
+++ b/src/server/api/routers/listingReports.ts
@@ -17,14 +17,13 @@ import {
 } from '@/server/api/trpc'
 import { getAuthorReportCounts } from '@/server/services/report-stats.service'
 import { paginate } from '@/server/utils/pagination'
-import { batchQueries } from '@/server/utils/query-performance'
 import { validateEnum, sanitizeInput, validatePagination } from '@/server/utils/security-validation'
 import { PERMISSIONS } from '@/utils/permission-system'
 import { ApprovalStatus, type Prisma, ReportStatus, TrustAction, ReportReason } from '@orm/client'
 
 export const listingReportsRouter = createTRPCRouter({
   stats: permissionProcedure(PERMISSIONS.VIEW_STATISTICS).query(async ({ ctx }) => {
-    const [pending, underReview, resolved, dismissed] = await batchQueries([
+    const [pending, underReview, resolved, dismissed] = await Promise.all([
       ctx.prisma.listingReport.count({ where: { status: ReportStatus.PENDING } }),
       ctx.prisma.listingReport.count({ where: { status: ReportStatus.UNDER_REVIEW } }),
       ctx.prisma.listingReport.count({ where: { status: ReportStatus.RESOLVED } }),
@@ -77,7 +76,7 @@ export const listingReportsRouter = createTRPCRouter({
       const orderBy: Prisma.ListingReportOrderByWithRelationInput = {}
       if (sortField && sortDirection) orderBy[sortField] = sortDirection
 
-      const [reports, total] = await batchQueries([
+      const [reports, total] = await Promise.all([
         ctx.prisma.listingReport.findMany({
           where,
           orderBy,
@@ -303,7 +302,7 @@ export const listingReportsRouter = createTRPCRouter({
         ...(status ? { status } : {}),
       }
 
-      const [handheldReports, pcReports, handheldCount, pcCount] = await batchQueries([
+      const [handheldReports, pcReports, handheldCount, pcCount] = await Promise.all([
         ctx.prisma.listingReport.findMany({
           where: handheldWhere,
           orderBy: { createdAt: 'desc' },
diff --git a/src/server/api/routers/mobile/admin.ts b/src/server/api/routers/mobile/admin.ts
index 5f7c8021d..1d9d28374 100644
--- a/src/server/api/routers/mobile/admin.ts
+++ b/src/server/api/routers/mobile/admin.ts
@@ -26,7 +26,6 @@ import { logAudit } from '@/server/services/audit.service'
 import { listingStatsCache } from '@/server/utils/cache/instances'
 import { paginate } from '@/server/utils/pagination'
 import { buildSearchFilter } from '@/server/utils/query-builders'
-import { createCountQuery } from '@/server/utils/query-performance'
 import { canBanUser } from '@/utils/permission-system'
 import {
   ApprovalStatus,
@@ -59,26 +58,16 @@ export const mobileAdminRouter = createMobileTRPCRouter({
         activeUsers,
         bannedUsers,
       ] = await Promise.all([
-        createCountQuery(ctx.prisma.listing, {
-          status: ApprovalStatus.PENDING,
-        }),
-        createCountQuery(ctx.prisma.listing, {
-          status: ApprovalStatus.APPROVED,
-        }),
-        createCountQuery(ctx.prisma.listing, {
-          status: ApprovalStatus.REJECTED,
-        }),
-        createCountQuery(ctx.prisma.game, { status: ApprovalStatus.PENDING }),
-        createCountQuery(ctx.prisma.game, { status: ApprovalStatus.APPROVED }),
-        createCountQuery(ctx.prisma.game, { status: ApprovalStatus.REJECTED }),
-        createCountQuery(ctx.prisma.listingReport, {
-          status: ReportStatus.PENDING,
-        }),
-        createCountQuery(ctx.prisma.listingReport, {
-          status: ReportStatus.RESOLVED,
-        }),
-        createCountQuery(ctx.prisma.user, {}),
-        createCountQuery(ctx.prisma.userBan, { isActive: true }),
+        ctx.prisma.listing.count({ where: { status: ApprovalStatus.PENDING } }),
+        ctx.prisma.listing.count({ where: { status: ApprovalStatus.APPROVED } }),
+        ctx.prisma.listing.count({ where: { status: ApprovalStatus.REJECTED } }),
+        ctx.prisma.game.count({ where: { status: ApprovalStatus.PENDING } }),
+        ctx.prisma.game.count({ where: { status: ApprovalStatus.APPROVED } }),
+        ctx.prisma.game.count({ where: { status: ApprovalStatus.REJECTED } }),
+        ctx.prisma.listingReport.count({ where: { status: ReportStatus.PENDING } }),
+        ctx.prisma.listingReport.count({ where: { status: ReportStatus.RESOLVED } }),
+        ctx.prisma.user.count(),
+        ctx.prisma.userBan.count({ where: { isActive: true } }),
       ])
 
       return {
@@ -291,7 +280,7 @@ export const mobileAdminRouter = createMobileTRPCRouter({
       if (searchConditions) where.OR = searchConditions
 
       const [total, games] = await Promise.all([
-        createCountQuery(ctx.prisma.game, where),
+        ctx.prisma.game.count({ where }),
         ctx.prisma.game.findMany({
           where,
           select: {
@@ -387,7 +376,7 @@ export const mobileAdminRouter = createMobileTRPCRouter({
       const where: Prisma.ListingReportWhereInput = { ...(status && { status }) }
 
       const [total, reports] = await Promise.all([
-        createCountQuery(ctx.prisma.listingReport, where),
+        ctx.prisma.listingReport.count({ where }),
         ctx.prisma.listingReport.findMany({
           where,
           include: {
@@ -459,7 +448,7 @@ export const mobileAdminRouter = createMobileTRPCRouter({
       }
 
       const [total, bans] = await Promise.all([
-        createCountQuery(ctx.prisma.userBan, where),
+        ctx.prisma.userBan.count({ where }),
         ctx.prisma.userBan.findMany({
           where,
           include: {
diff --git a/src/server/api/routers/socs.ts b/src/server/api/routers/socs.ts
index e1a415249..749f840a6 100644
--- a/src/server/api/routers/socs.ts
+++ b/src/server/api/routers/socs.ts
@@ -15,7 +15,6 @@ import {
 } from '@/server/api/trpc'
 import { SoCsRepository } from '@/server/repositories/socs.repository'
 import { paginate } from '@/server/utils/pagination'
-import { batchQueries } from '@/server/utils/query-performance'
 
 export const socsRouter = createTRPCRouter({
   get: publicProcedure.input(GetSoCsSchema).query(async ({ ctx, input }) => {
@@ -76,7 +75,7 @@ export const socsRouter = createTRPCRouter({
   }),
 
   stats: viewStatisticsProcedure.query(async ({ ctx }) => {
-    const [withDevices, withoutDevices] = await batchQueries([
+    const [withDevices, withoutDevices] = await Promise.all([
       ctx.prisma.soC.count({ where: { devices: { some: {} } } }),
       ctx.prisma.soC.count({ where: { devices: { none: {} } } }),
     ])
diff --git a/src/server/api/routers/system.ts b/src/server/api/routers/system.ts
deleted file mode 100644
index 85ef6a1de..000000000
--- a/src/server/api/routers/system.ts
+++ /dev/null
@@ -1,51 +0,0 @@
-import { adminProcedure, createTRPCRouter } from '@/server/api/trpc'
-import { ConnectionMonitor } from '@/server/utils/connection-monitor'
-
-/**
- * System monitoring and diagnostics router
- * Admin-only endpoints for database and application health monitoring
- */
-export const systemRouter = createTRPCRouter({
-  /**
-   * Get current database connection statistics
-   */
-  getConnectionStats: adminProcedure.query(async () => {
-    return await ConnectionMonitor.getConnectionStats()
-  }),
-
-  /**
-   * Get detailed information about active database connections
-   */
-  getActiveConnections: adminProcedure.query(async () => {
-    return await ConnectionMonitor.getActiveConnections()
-  }),
-
-  /**
-   * Get long-running queries (> 5 seconds)
-   */
-  getLongRunningQueries: adminProcedure.query(async () => {
-    return await ConnectionMonitor.getLongRunningQueries()
-  }),
-
-  /**
-   * Get database configuration validation
-   */
-  validateDatabaseConfig: adminProcedure.query(() => {
-    return ConnectionMonitor.validateConfig()
-  }),
-
-  /**
-   * Get connection pool configuration
-   */
-  getPoolConfig: adminProcedure.query(() => {
-    return ConnectionMonitor.getPoolConfig()
-  }),
-
-  /**
-   * Manually trigger connection stats logging
-   */
-  logConnectionStats: adminProcedure.mutation(async () => {
-    await ConnectionMonitor.logConnectionStats()
-    return { success: true }
-  }),
-})
diff --git a/src/server/api/routers/users.ts b/src/server/api/routers/users.ts
index 920852e91..d781f1872 100644
--- a/src/server/api/routers/users.ts
+++ b/src/server/api/routers/users.ts
@@ -37,7 +37,6 @@ import {
 } from '@/server/services/user-profile.service'
 import { buildOrderBy, paginate } from '@/server/utils/pagination'
 import { buildSearchFilter } from '@/server/utils/query-builders'
-import { createCountQuery } from '@/server/utils/query-performance'
 import { updateUserRole } from '@/server/utils/roleSync'
 import {
   hasPermissionInContext,
@@ -713,7 +712,7 @@ export const usersRouter = createTRPCRouter({
           skip,
           take: limit,
         }),
-        createCountQuery(ctx.prisma.user, where),
+        ctx.prisma.user.count({ where }),
       ])
 
       return {
@@ -752,17 +751,19 @@ export const usersRouter = createTRPCRouter({
       superAdminCount,
       bannedUsersCount,
     ] = await Promise.all([
-      createCountQuery(ctx.prisma.user, { role: Role.USER }),
-      createCountQuery(ctx.prisma.user, { role: Role.AUTHOR }),
-      createCountQuery(ctx.prisma.user, { role: Role.DEVELOPER }),
-      createCountQuery(ctx.prisma.user, { role: Role.MODERATOR }),
-      createCountQuery(ctx.prisma.user, { role: Role.ADMIN }),
-      createCountQuery(ctx.prisma.user, { role: Role.SUPER_ADMIN }),
-      createCountQuery(ctx.prisma.user, {
-        userBans: {
-          some: {
-            isActive: true,
-            OR: [{ expiresAt: null }, { expiresAt: { gt: new Date() } }],
+      ctx.prisma.user.count({ where: { role: Role.USER } }),
+      ctx.prisma.user.count({ where: { role: Role.AUTHOR } }),
+      ctx.prisma.user.count({ where: { role: Role.DEVELOPER } }),
+      ctx.prisma.user.count({ where: { role: Role.MODERATOR } }),
+      ctx.prisma.user.count({ where: { role: Role.ADMIN } }),
+      ctx.prisma.user.count({ where: { role: Role.SUPER_ADMIN } }),
+      ctx.prisma.user.count({
+        where: {
+          userBans: {
+            some: {
+              isActive: true,
+              OR: [{ expiresAt: null }, { expiresAt: { gt: new Date() } }],
+            },
           },
         },
       }),
diff --git a/src/server/init.ts b/src/server/init.ts
index 6ea749302..a055a33af 100644
--- a/src/server/init.ts
+++ b/src/server/init.ts
@@ -9,7 +9,6 @@
 import { logger } from '@/lib/logger'
 import { ms } from '@/utils/time'
 import { initializeNotificationService } from './notifications/init'
-import { ConnectionMonitor } from './utils/connection-monitor'
 import { initializeSwitchGameService } from './utils/switchGameInit'
 import { initializeThreeDsGameService } from './utils/threeDsGameInit'
 
@@ -177,29 +176,6 @@ export async function initializeServer(): Promise<void> {
   } else {
     logger.warn('⚠️ Some services failed to initialize. They will be retried on next access.')
   }
-
-  // Initialize connection monitoring (production only)
-  if (process.env.NODE_ENV === 'production') {
-    // Validate database configuration
-    const configValidation = ConnectionMonitor.validateConfig()
-    if (!configValidation.isValid) {
-      logger.warn('⚠️ Database configuration issues detected', {
-        warnings: configValidation.warnings,
-      })
-    }
-
-    // Start monitoring every 2 minutes in production
-    ConnectionMonitor.startMonitoring(2 * 60 * 1000)
-    logger.info('✅ Connection monitoring started')
-  } else {
-    // In development, just validate config once
-    const configValidation = ConnectionMonitor.validateConfig()
-    if (!configValidation.isValid) {
-      logger.warn('⚠️ Database configuration issues detected', {
-        warnings: configValidation.warnings,
-      })
-    }
-  }
 }
 
 /**
diff --git a/src/server/prisma-client.ts b/src/server/prisma-client.ts
index edc82f8be..90eeae8ee 100644
--- a/src/server/prisma-client.ts
+++ b/src/server/prisma-client.ts
@@ -3,6 +3,7 @@ import { PrismaClient } from '@orm/client'
 
 type PrismaClientOptions = NonNullable<ConstructorParameters<typeof PrismaClient>[0]>
 type PrismaClientConfig = Omit<PrismaClientOptions, 'adapter' | 'accelerateUrl'>
+const LOCAL_DATABASE_HOSTS = new Set(['localhost', '127.0.0.1', '0.0.0.0', '::1', '[::1]'])
 
 function getDatabaseUrl() {
   const connectionString = process.env.DATABASE_URL
@@ -14,8 +15,31 @@ function getDatabaseUrl() {
   return connectionString
 }
 
+function getPoolMax(connectionString: string): number | undefined {
+  try {
+    const url = new URL(connectionString)
+    const raw = url.searchParams.get('connection_limit')
+    if (raw) {
+      const parsed = Number(raw)
+      if (Number.isInteger(parsed) && parsed > 0) return parsed
+    }
+
+    return LOCAL_DATABASE_HOSTS.has(url.hostname.toLowerCase()) ? undefined : 1
+  } catch {
+    return 1
+  }
+}
+
 export function createPrismaClient(options?: PrismaClientConfig) {
-  const adapter = new PrismaPg({ connectionString: getDatabaseUrl() })
+  const connectionString = getDatabaseUrl()
+  const poolMax = getPoolMax(connectionString)
+
+  const adapter = new PrismaPg({
+    connectionString,
+    ...(poolMax ? { max: poolMax } : {}),
+    connectionTimeoutMillis: 5_000,
+    idleTimeoutMillis: 10_000,
+  })
 
   return new PrismaClient({
     ...options,
diff --git a/src/server/services/report-stats.service.ts b/src/server/services/report-stats.service.ts
index 6206a366f..ff694e6f2 100644
--- a/src/server/services/report-stats.service.ts
+++ b/src/server/services/report-stats.service.ts
@@ -1,4 +1,3 @@
-import { batchQueries } from '@/server/utils/query-performance'
 import type { PrismaClient } from '@orm/client'
 
 interface AuthorReportCounts {
@@ -16,7 +15,7 @@ export async function getAuthorReportCounts(
   userId: string,
 ): Promise<AuthorReportCounts> {
   const [handheldReports, pcReports, handheldListingsReported, pcListingsReported] =
-    await batchQueries([
+    await Promise.all([
       prisma.listingReport.count({ where: { listing: { authorId: userId } } }),
       prisma.pcListingReport.count({ where: { pcListing: { authorId: userId } } }),
       prisma.listing.count({ where: { authorId: userId, reports: { some: {} } } }),
diff --git a/src/server/utils/connection-monitor.ts b/src/server/utils/connection-monitor.ts
deleted file mode 100644
index cec386f79..000000000
--- a/src/server/utils/connection-monitor.ts
+++ /dev/null
@@ -1,401 +0,0 @@
-import { logger } from '@/lib/logger'
-import { prisma } from '@/server/db'
-
-interface ConnectionStats {
-  total: number
-  active: number
-  idle: number
-  idleInTransaction: number
-  waiting: number
-}
-
-interface DetailedConnection {
-  pid: number
-  username: string
-  applicationName: string
-  clientAddr: string | null
-  state: string
-  queryStart: Date | null
-  stateChange: Date | null
-  waitEventType: string | null
-  waitEvent: string | null
-  query: string | null
-}
-
-/**
- * Connection monitoring utility for tracking PostgreSQL connection health
- *
- * Use this to:
- * - Monitor active connections
- * - Identify connection leaks
- * - Track query performance
- * - Alert on connection exhaustion
- */
-export class ConnectionMonitor {
-  private static isMonitoring = false
-  private static monitoringInterval: NodeJS.Timeout | null = null
-
-  /**
-   * Get current connection statistics
-   */
-  static async getConnectionStats(): Promise<ConnectionStats> {
-    try {
-      const result = await prisma.$queryRaw<
-        {
-          state: string
-          count: bigint
-        }[]
-      >`
-        SELECT
-          state,
-          COUNT(*) as count
-        FROM pg_stat_activity
-        WHERE datname = current_database()
-        GROUP BY state
-      `
-
-      const stats: ConnectionStats = {
-        total: 0,
-        active: 0,
-        idle: 0,
-        idleInTransaction: 0,
-        waiting: 0,
-      }
-
-      for (const row of result) {
-        const count = Number(row.count)
-        stats.total += count
-
-        switch (row.state) {
-          case 'active':
-            stats.active = count
-            break
-          case 'idle':
-            stats.idle = count
-            break
-          case 'idle in transaction':
-            stats.idleInTransaction = count
-            break
-          case 'idle in transaction (aborted)':
-            stats.idleInTransaction += count
-            break
-          default:
-            stats.waiting += count
-        }
-      }
-
-      return stats
-    } catch (error) {
-      logger.error('Failed to get connection stats', { error })
-      throw error
-    }
-  }
-
-  /**
-   * Get detailed information about active connections
-   */
-  static async getActiveConnections(): Promise<DetailedConnection[]> {
-    try {
-      const result = await prisma.$queryRaw<
-        {
-          pid: number
-          usename: string
-          application_name: string
-          client_addr: string | null
-          state: string
-          query_start: Date | null
-          state_change: Date | null
-          wait_event_type: string | null
-          wait_event: string | null
-          query: string | null
-        }[]
-      >`
-        SELECT
-          pid,
-          usename,
-          application_name,
-          client_addr::text,
-          state,
-          query_start,
-          state_change,
-          wait_event_type,
-          wait_event,
-          query
-        FROM pg_stat_activity
-        WHERE datname = current_database()
-          AND state != 'idle'
-          AND pid != pg_backend_pid()
-        ORDER BY query_start DESC
-        LIMIT 50
-      `
-
-      return result.map((row) => ({
-        pid: row.pid,
-        username: row.usename,
-        applicationName: row.application_name,
-        clientAddr: row.client_addr,
-        state: row.state,
-        queryStart: row.query_start,
-        stateChange: row.state_change,
-        waitEventType: row.wait_event_type,
-        waitEvent: row.wait_event,
-        query: row.query,
-      }))
-    } catch (error) {
-      logger.error('Failed to get active connections', { error })
-      throw error
-    }
-  }
-
-  /**
-   * Get long-running queries (> 5 seconds)
-   */
-  static async getLongRunningQueries(): Promise<DetailedConnection[]> {
-    try {
-      const result = await prisma.$queryRaw<
-        {
-          pid: number
-          usename: string
-          application_name: string
-          client_addr: string | null
-          state: string
-          query_start: Date | null
-          state_change: Date | null
-          wait_event_type: string | null
-          wait_event: string | null
-          query: string | null
-          duration_seconds: number
-        }[]
-      >`
-        SELECT
-          pid,
-          usename,
-          application_name,
-          client_addr::text,
-          state,
-          query_start,
-          state_change,
-          wait_event_type,
-          wait_event,
-          query,
-          EXTRACT(EPOCH FROM (NOW() - query_start))::integer as duration_seconds
-        FROM pg_stat_activity
-        WHERE datname = current_database()
-          AND state = 'active'
-          AND query_start < NOW() - INTERVAL '5 seconds'
-          AND pid != pg_backend_pid()
-        ORDER BY query_start ASC
-        LIMIT 20
-      `
-
-      const connections = result.map((row) => ({
-        pid: row.pid,
-        username: row.usename,
-        applicationName: row.application_name,
-        clientAddr: row.client_addr,
-        state: row.state,
-        queryStart: row.query_start,
-        stateChange: row.state_change,
-        waitEventType: row.wait_event_type,
-        waitEvent: row.wait_event,
-        query: row.query,
-      }))
-
-      if (connections.length > 0) {
-        logger.warn('Long-running queries detected', {
-          count: connections.length,
-          queries: result.map((r) => ({
-            pid: r.pid,
-            duration: r.duration_seconds,
-            query: r.query?.substring(0, 100),
-          })),
-        })
-      }
-
-      return connections
-    } catch (error) {
-      logger.error('Failed to get long-running queries', { error })
-      throw error
-    }
-  }
-
-  /**
-   * Log current connection statistics
-   */
-  static async logConnectionStats(): Promise<void> {
-    try {
-      const stats = await this.getConnectionStats()
-
-      logger.info('Database connection stats', {
-        total: stats.total,
-        active: stats.active,
-        idle: stats.idle,
-        idleInTransaction: stats.idleInTransaction,
-        waiting: stats.waiting,
-      })
-
-      // Alert if too many active connections
-      if (stats.active > 50) {
-        logger.warn('High active connection count', {
-          active: stats.active,
-          threshold: 50,
-        })
-      }
-
-      // Alert if connections stuck in transaction
-      if (stats.idleInTransaction > 10) {
-        logger.warn('High idle-in-transaction count', {
-          idleInTransaction: stats.idleInTransaction,
-          threshold: 10,
-        })
-      }
-
-      // Check for long-running queries
-      await this.getLongRunningQueries()
-    } catch (error) {
-      logger.error('Failed to log connection stats', { error })
-    }
-  }
-
-  /**
-   * Start monitoring connections at regular intervals
-   *
-   * @param intervalMs - Monitoring interval in milliseconds (default: 60000 = 1 minute)
-   */
-  static startMonitoring(intervalMs = 60000): void {
-    if (this.isMonitoring) {
-      logger.warn('Connection monitoring already started')
-      return
-    }
-
-    logger.info('Starting connection monitoring', { intervalMs })
-
-    // Log immediately
-    void this.logConnectionStats()
-
-    // Then log at intervals
-    this.monitoringInterval = setInterval(() => {
-      void this.logConnectionStats()
-    }, intervalMs)
-
-    this.isMonitoring = true
-  }
-
-  /**
-   * Stop monitoring connections
-   */
-  static stopMonitoring(): void {
-    if (!this.isMonitoring) {
-      logger.warn('Connection monitoring not running')
-      return
-    }
-
-    if (this.monitoringInterval) {
-      clearInterval(this.monitoringInterval)
-      this.monitoringInterval = null
-    }
-
-    this.isMonitoring = false
-    logger.info('Connection monitoring stopped')
-  }
-
-  /**
-   * Check if database is a local development database
-   */
-  static isLocalDatabase(): boolean {
-    const url = process.env.DATABASE_URL
-    if (!url) return false
-
-    try {
-      const urlObj = new URL(url)
-      const hostname = urlObj.hostname.toLowerCase()
-
-      return (
-        hostname === 'localhost' ||
-        hostname === '127.0.0.1' ||
-        hostname === '0.0.0.0' ||
-        hostname === '::1'
-      )
-    } catch {
-      return false
-    }
-  }
-
-  /**
-   * Get connection pool configuration from DATABASE_URL
-   */
-  static getPoolConfig(): {
-    hasConnectionLimit: boolean
-    hasPgBouncer: boolean
-    connectionLimit?: number
-    isLocal: boolean
-  } {
-    const url = process.env.DATABASE_URL
-    if (!url) {
-      return { hasConnectionLimit: false, hasPgBouncer: false, isLocal: false }
-    }
-
-    try {
-      const urlObj = new URL(url)
-      const connectionLimit = urlObj.searchParams.get('connection_limit')
-      const pgbouncer = urlObj.searchParams.get('pgbouncer')
-      const isLocal = this.isLocalDatabase()
-
-      return {
-        hasConnectionLimit: connectionLimit !== null,
-        hasPgBouncer: pgbouncer === 'true',
-        connectionLimit: connectionLimit ? parseInt(connectionLimit, 10) : undefined,
-        isLocal,
-      }
-    } catch {
-      return { hasConnectionLimit: false, hasPgBouncer: false, isLocal: false }
-    }
-  }
-
-  /**
-   * Validate connection configuration
-   */
-  static validateConfig(): {
-    isValid: boolean
-    warnings: string[]
-  } {
-    const warnings: string[] = []
-    const config = this.getPoolConfig()
-
-    // Skip validation for local databases
-    if (config.isLocal) {
-      return { isValid: true, warnings: [] }
-    }
-
-    // Production/staging validation (Supabase, remote databases)
-    if (!config.hasPgBouncer) {
-      warnings.push(
-        'DATABASE_URL missing pgbouncer=true parameter. Add it to prevent prepared statement issues.',
-      )
-    }
-
-    // NOTE: We don't warn about missing connection_limit anymore since it's added automatically
-    // by getOptimizedDatabaseUrl() in src/server/db.ts
-
-    // Only warn if connection_limit is set but too high
-    if (config.connectionLimit && config.connectionLimit > 5) {
-      warnings.push(
-        `connection_limit=${config.connectionLimit} is too high for serverless. Recommended: 1-2`,
-      )
-    }
-
-    if (!process.env.DATABASE_DIRECT_URL) {
-      warnings.push(
-        'DATABASE_DIRECT_URL not set. Required for complex transactions and migrations.',
-      )
-    }
-
-    const isValid = warnings.length === 0
-
-    if (!isValid) {
-      logger.warn('Database configuration issues detected', { warnings })
-    }
-
-    return { isValid, warnings }
-  }
-}
diff --git a/src/server/utils/query-performance.ts b/src/server/utils/query-performance.ts
deleted file mode 100644
index 33861ff92..000000000
--- a/src/server/utils/query-performance.ts
+++ /dev/null
@@ -1,391 +0,0 @@
-import { logger } from '@/lib/logger'
-
-/**
- * Performance monitoring for database queries
- */
-export class QueryPerformanceMonitor {
-  private static queries: Map<string, QueryMetrics> = new Map()
-  private static enabled = process.env.NODE_ENV === 'development'
-
-  static startQuery(name: string): () => void {
-    if (!this.enabled) return () => {}
-
-    const startTime = performance.now()
-
-    return () => {
-      const duration = performance.now() - startTime
-      this.recordQuery(name, duration)
-    }
-  }
-
-  static recordQuery(name: string, duration: number): void {
-    const existing = this.queries.get(name) || {
-      count: 0,
-      totalTime: 0,
-      minTime: Infinity,
-      maxTime: 0,
-      avgTime: 0,
-    }
-
-    existing.count++
-    existing.totalTime += duration
-    existing.minTime = Math.min(existing.minTime, duration)
-    existing.maxTime = Math.max(existing.maxTime, duration)
-    existing.avgTime = existing.totalTime / existing.count
-
-    this.queries.set(name, existing)
-
-    // Log slow queries
-    if (duration > 1000) {
-      logger.warn(`Slow query detected: ${name} took ${duration.toFixed(2)}ms`)
-    }
-  }
-
-  static getMetrics(): Record<string, QueryMetrics> {
-    return Object.fromEntries(this.queries)
-  }
-
-  static reset(): void {
-    this.queries.clear()
-  }
-}
-
-interface QueryMetrics {
-  count: number
-  totalTime: number
-  minTime: number
-  maxTime: number
-  avgTime: number
-}
-
-/**
- * Optimize select fields to reduce data transfer
- */
-export function optimizeSelect<T>(
-  requiredFields: (keyof T)[],
-  conditionalFields?: Partial<Record<keyof T, boolean>>,
-): Record<string, boolean> {
-  const select: Record<string, boolean> = {}
-
-  // Always include required fields
-  requiredFields.forEach((field) => {
-    select[String(field)] = true
-  })
-
-  // Add conditional fields
-  if (conditionalFields) {
-    Object.entries(conditionalFields).forEach(([field, include]) => {
-      if (include) {
-        select[field] = true
-      }
-    })
-  }
-
-  return select
-}
-
-/**
- * Create efficient count queries that skip unnecessary joins
- */
-export function createCountQuery<T>(
-  model: { count: (args: { where: T }) => Promise<number>; _name?: string },
-  where: T,
-): Promise<number> {
-  const end = QueryPerformanceMonitor.startQuery(`count:${model._name || 'unknown'}`)
-
-  const query = model.count({ where })
-
-  return query.finally(end)
-}
-
-/**
- * Batch multiple queries for better performance
- */
-export async function batchQueries<T extends readonly unknown[]>(
-  queries: [...{ [K in keyof T]: Promise<T[K]> }],
-): Promise<T> {
-  const end = QueryPerformanceMonitor.startQuery('batch:queries')
-
-  try {
-    return Promise.all(queries) as Promise<T>
-  } finally {
-    end()
-  }
-}
-
-/**
- * Create indexes suggestion based on query patterns
- */
-export function suggestIndexes(
-  model: string,
-  whereConditions: Record<string, unknown>,
-  orderBy?: Record<string, unknown>,
-): string[] {
-  const suggestions: string[] = []
-  const fields = Object.keys(whereConditions)
-
-  // Single field indexes for equality checks
-  fields.forEach((field) => {
-    const condition = whereConditions[field]
-    if (typeof condition !== 'object' || condition === null || (condition && 'in' in condition)) {
-      suggestions.push(`CREATE INDEX idx_${model}_${field} ON ${model}(${field});`)
-    }
-  })
-
-  // Composite indexes for multiple conditions
-  if (fields.length > 1) {
-    suggestions.push(
-      `CREATE INDEX idx_${model}_${fields.join('_')} ON ${model}(${fields.join(', ')});`,
-    )
-  }
-
-  // Index for sorting
-  if (orderBy) {
-    const sortFields = Object.keys(orderBy)
-    sortFields.forEach((field) => {
-      if (!fields.includes(field)) {
-        suggestions.push(`CREATE INDEX idx_${model}_${field} ON ${model}(${field});`)
-      }
-    })
-  }
-
-  return [...new Set(suggestions)]
-}
-
-/**
- * Optimize includes to prevent N+1 queries
- */
-export function optimizeIncludes(
-  baseInclude: Record<string, unknown>,
-  maxDepth = 3,
-  currentDepth = 0,
-): Record<string, unknown> {
-  if (currentDepth >= maxDepth) {
-    // Convert deep includes to select with minimal fields
-    const optimized: Record<string, unknown> = {}
-
-    Object.entries(baseInclude).forEach(([key, value]) => {
-      if (value === true) {
-        optimized[key] = { select: { id: true, name: true } }
-      } else if (
-        typeof value === 'object' &&
-        value !== null &&
-        'include' in value &&
-        value.include
-      ) {
-        optimized[key] = {
-          select: {
-            id: true,
-            ...Object.keys(value.include as Record<string, unknown>).reduce(
-              (acc, k) => {
-                acc[k] = { select: { id: true } }
-                return acc
-              },
-              {} as Record<string, unknown>,
-            ),
-          },
-        }
-      } else {
-        optimized[key] = value
-      }
-    })
-
-    return optimized
-  }
-
-  // Recursively optimize nested includes
-  const optimized: Record<string, unknown> = {}
-
-  Object.entries(baseInclude).forEach(([key, value]) => {
-    if (typeof value === 'object' && value !== null && 'include' in value && value.include) {
-      optimized[key] = {
-        ...value,
-        include: optimizeIncludes(
-          value.include as Record<string, unknown>,
-          maxDepth,
-          currentDepth + 1,
-        ),
-      }
-    } else {
-      optimized[key] = value
-    }
-  })
-
-  return optimized
-}
-
-/**
- * Create a query cache key based on parameters
- */
-export function createQueryCacheKey(
-  model: string,
-  operation: string,
-  params: Record<string, unknown>,
-): string {
-  const sortedParams = Object.keys(params)
-    .sort()
-    .reduce(
-      (acc, key) => {
-        acc[key] = params[key]
-        return acc
-      },
-      {} as Record<string, unknown>,
-    )
-
-  return `${model}:${operation}:${JSON.stringify(sortedParams)}`
-}
-
-/**
- * Analyze query complexity and warn about potential issues
- */
-export function analyzeQueryComplexity(
-  include?: Record<string, unknown>,
-  where?: Record<string, unknown>,
-): QueryComplexityResult {
-  let score = 0
-  const warnings: string[] = []
-
-  // Analyze includes depth
-  if (include) {
-    const depth = getIncludeDepth(include)
-    score += depth * 10
-
-    if (depth > 3) {
-      warnings.push(`Deep nesting detected (${depth} levels). Consider splitting queries.`)
-    }
-
-    // Count total relations
-    const relationCount = countRelations(include)
-    score += relationCount * 5
-
-    if (relationCount > 10) {
-      warnings.push(
-        `Many relations included (${relationCount}). This may cause performance issues.`,
-      )
-    }
-  }
-
-  // Analyze where conditions
-  if (where) {
-    const orConditions = countOrConditions(where)
-    score += orConditions * 15
-
-    if (orConditions > 5) {
-      warnings.push(`Many OR conditions (${orConditions}). Consider using indexed fields.`)
-    }
-  }
-
-  return {
-    score,
-    complexity: score < 50 ? 'low' : score < 100 ? 'medium' : 'high',
-    warnings,
-  }
-}
-
-function getIncludeDepth(include: Record<string, unknown>, currentDepth = 1): number {
-  let maxDepth = currentDepth
-
-  Object.values(include).forEach((value) => {
-    if (typeof value === 'object' && value !== null && 'include' in value && value.include) {
-      const depth = getIncludeDepth(value.include as Record<string, unknown>, currentDepth + 1)
-      maxDepth = Math.max(maxDepth, depth)
-    }
-  })
-
-  return maxDepth
-}
-
-function countRelations(include: Record<string, unknown>): number {
-  let count = Object.keys(include).length
-
-  Object.values(include).forEach((value) => {
-    if (typeof value === 'object' && value !== null && 'include' in value && value.include) {
-      count += countRelations(value.include as Record<string, unknown>)
-    }
-  })
-
-  return count
-}
-
-function countOrConditions(where: Record<string, unknown>): number {
-  let count = 0
-
-  if (where.OR && Array.isArray(where.OR)) count += where.OR.length
-
-  Object.values(where).forEach((value) => {
-    if (typeof value === 'object' && value !== null) {
-      count += countOrConditions(value as Record<string, unknown>)
-    }
-  })
-
-  return count
-}
-
-interface QueryComplexityResult {
-  score: number
-  complexity: 'low' | 'medium' | 'high'
-  warnings: string[]
-}
-
-/**
- * Connection pool optimization settings
- */
-export function getOptimizedPoolSettings() {
-  return {
-    // Connection limit for serverless (1 connection per instance)
-    connection_limit: 1,
-
-    // Connection timeout in seconds (how long to wait for initial connection)
-    connect_timeout: 10,
-  }
-}
-
-/**
- * Generate optimized DATABASE_URL with connection pool parameters
- *
- * Automatically adds connection_limit=1 for remote databases to prevent
- * connection exhaustion in serverless environments.
- *
- * IMPORTANT: Does NOT add pgbouncer=true - that must be in the environment variable
- * to avoid breaking interactive transactions.
- */
-export function getOptimizedDatabaseUrl(baseUrl?: string): string {
-  const url = baseUrl || process.env.DATABASE_URL
-  if (!url) {
-    throw new Error('DATABASE_URL is required')
-  }
-
-  try {
-    const urlObj = new URL(url)
-    const hostname = urlObj.hostname.toLowerCase()
-
-    // Skip optimization for local databases
-    const isLocal =
-      hostname === 'localhost' ||
-      hostname === '127.0.0.1' ||
-      hostname === '0.0.0.0' ||
-      hostname === '::1'
-
-    if (isLocal) return url
-
-    // Get optimized settings
-    const settings = getOptimizedPoolSettings()
-
-    // Add connection_limit if not already set
-    if (!urlObj.searchParams.has('connection_limit')) {
-      urlObj.searchParams.set('connection_limit', settings.connection_limit.toString())
-      logger.info('Added connection_limit=1 to DATABASE_URL for optimal serverless performance')
-    }
-
-    // Add connect_timeout if not already set
-    if (!urlObj.searchParams.has('connect_timeout')) {
-      urlObj.searchParams.set('connect_timeout', settings.connect_timeout.toString())
-    }
-
-    return urlObj.toString()
-  } catch (error) {
-    // If URL parsing fails, return as-is
-    logger.error('Failed to parse DATABASE_URL', { error })
-    return url
-  }
-}
