From ef8b368c4c877039aecfb85f88855f4eb81fa1dc Mon Sep 17 00:00:00 2001
From: Geeth Gunnampalli <geeth.gunnampalli@gmail.com>
Date: Mon, 1 Dec 2025 15:59:34 -0600
Subject: [PATCH] feat: Update disaster types and enhance settings page
 functionality

- Expanded available disaster types in the map page to include wildfire, hurricane, tornado, volcano, and heatwave.
- Refactored settings page to replace alert types with watched regions, allowing users to add and manage specific regions for alerts.
- Implemented region search functionality to enhance user experience when adding watched regions.
- Updated user alert preferences to accommodate the new watched regions feature, improving alert customization.
---
 client/app/dashboard/map/page.tsx             |   2 +-
 client/app/dashboard/settings/page.tsx        | 198 +++++++------
 client/app/onboarding/page.tsx                |  41 +--
 ...f34ec_rename_regions_to_watched_regions.py |  38 +++
 ...2264546da1d9_simplify_alert_preferences.py |  40 +++
 server/db_utils/db.py                         |   7 +-
 server/requirements.txt                       |   1 +
 server/routers/alerts.py                      |  73 +++--
 server/routers/data_feed.py                   |  33 ++-
 server/scripts/backfill_coordinates.py        | 150 ++++++++++
 server/services/alert_generator.py            | 102 ++-----
 server/services/analysis.py                   | 178 +++++++++--
 server/services/database_service.py           | 278 +++++++++++++++++-
 server/services/geocoding_service.py          |  81 +++++
 server/services/population_estimator.py       | 244 +++++++++++----
 server/tasks.py                               |  30 +-
 16 files changed, 1153 insertions(+), 343 deletions(-)
 create mode 100644 server/alembic/versions/12935d5f34ec_rename_regions_to_watched_regions.py
 create mode 100644 server/alembic/versions/2264546da1d9_simplify_alert_preferences.py
 create mode 100644 server/scripts/backfill_coordinates.py
 create mode 100644 server/services/geocoding_service.py

diff --git a/client/app/dashboard/map/page.tsx b/client/app/dashboard/map/page.tsx
index 10443b3..0ff595a 100644
--- a/client/app/dashboard/map/page.tsx
+++ b/client/app/dashboard/map/page.tsx
@@ -87,7 +87,7 @@ export default function MapPage() {
     );
   };
 
-  const availableDisasterTypes = ["earthquake", "flood", "fire", "storm", "tsunami", "other"];
+  const availableDisasterTypes = ["earthquake", "flood", "wildfire", "hurricane", "tornado", "tsunami", "volcano", "heatwave"];
   const hasActiveFilters = countryFilter !== "" || disasterTypeFilters.length > 0 || locationFilter !== "all" || severityFilter !== "all";
 
   const availableCountries = useMemo(() => {
diff --git a/client/app/dashboard/settings/page.tsx b/client/app/dashboard/settings/page.tsx
index 877f1e2..2f8986e 100644
--- a/client/app/dashboard/settings/page.tsx
+++ b/client/app/dashboard/settings/page.tsx
@@ -9,7 +9,6 @@ import { Switch } from "@/components/ui/switch"
 import { Button } from "@/components/ui/button"
 import { Avatar, AvatarFallback, AvatarImage } from "@/components/ui/avatar"
 import { Skeleton } from "@/components/ui/skeleton"
-import { Checkbox } from "@/components/ui/checkbox"
 import {
   Select,
   SelectContent,
@@ -17,7 +16,7 @@ import {
   SelectTrigger,
   SelectValue,
 } from "@/components/ui/select"
-import { Search, Check, AlertCircle, Loader2, RefreshCw, Trash2, MapPin, Calendar, User, Edit2, X } from "lucide-react"
+import { Search, Check, AlertCircle, Loader2, RefreshCw, Trash2, MapPin, Calendar, User, Edit2, X, Plus } from "lucide-react"
 import { apiClient } from "@/lib/api-client"
 import { MapStyleSettings } from "@/components/map-style-settings"
 import {
@@ -30,19 +29,29 @@ import {
 } from "@/components/ui/dialog"
 import { useRouter } from "next/navigation"
 
+interface WatchedRegion {
+  name: string
+  lat: number
+  lng: number
+  bounds?: {
+    ne_lat: number
+    ne_lng: number
+    sw_lat: number
+    sw_lng: number
+  }
+  place_id?: string
+}
+
 export default function SettingsPage() {
   const { user, loading, refreshAuth } = useAuth()
   const router = useRouter()
   const [emailNotifications, setEmailNotifications] = useState(false)
-  const [twoFactor, setTwoFactor] = useState(false)
-  const [autoUpdates, setAutoUpdates] = useState(false)
-  const [shareUsageData, setShareUsageData] = useState(true)
 
   // Alert preferences
   const [minSeverity, setMinSeverity] = useState(3)
-  const [emailMinSeverity, setEmailMinSeverity] = useState(3)
-  const [alertTypes, setAlertTypes] = useState(['new_crisis', 'severity_change', 'update'])
-  const [regions, setRegions] = useState('')
+  const [watchedRegions, setWatchedRegions] = useState<WatchedRegion[]>([])
+  const [regionSearch, setRegionSearch] = useState('')
+  const [searchingRegion, setSearchingRegion] = useState(false)
   const [saving, setSaving] = useState(false)
   const [saveSuccess, setSaveSuccess] = useState(false)
   const [updatingLocation, setUpdatingLocation] = useState(false)
@@ -58,9 +67,7 @@ export default function SettingsPage() {
       if (response.ok) {
         const data = await response.json()
         setMinSeverity(data.min_severity || 3)
-        setEmailMinSeverity(data.email_min_severity || 3)
-        setAlertTypes(data.alert_types || ['new_crisis', 'severity_change', 'update'])
-        setRegions(data.regions?.join(', ') || '')
+        setWatchedRegions(data.watched_regions || [])
         setEmailNotifications(data.email_enabled || false)
       }
     } catch (err) {
@@ -84,9 +91,7 @@ export default function SettingsPage() {
         method: 'PUT',
         body: JSON.stringify({
           min_severity: minSeverity,
-          email_min_severity: emailMinSeverity,
-          alert_types: alertTypes,
-          regions: regions ? regions.split(',').map(r => r.trim()).filter(r => r) : null,
+          watched_regions: watchedRegions.length > 0 ? watchedRegions : null,
           email_enabled: overrides?.email_enabled ?? emailNotifications,
         }),
       })
@@ -102,10 +107,31 @@ export default function SettingsPage() {
     }
   }
 
-  const toggleAlertType = (type: string) => {
-    setAlertTypes(prev =>
-      prev.includes(type) ? prev.filter(t => t !== type) : [...prev, type]
-    )
+  const searchAndAddRegion = async () => {
+    if (!regionSearch.trim()) return
+
+    setSearchingRegion(true)
+    try {
+      const response = await apiClient(`/api/alerts/regions/search?query=${encodeURIComponent(regionSearch)}`)
+      if (response.ok) {
+        const region: WatchedRegion = await response.json()
+        if (!watchedRegions.some(r => r.place_id === region.place_id)) {
+          setWatchedRegions([...watchedRegions, region])
+        }
+        setRegionSearch('')
+      } else {
+        alert('Region not found. Try a different search term.')
+      }
+    } catch (err) {
+      console.error('Failed to search region:', err)
+      alert('Failed to search region')
+    } finally {
+      setSearchingRegion(false)
+    }
+  }
+
+  const removeRegion = (index: number) => {
+    setWatchedRegions(watchedRegions.filter((_, i) => i !== index))
   }
 
   const updateLocation = () => {
@@ -510,19 +536,19 @@ export default function SettingsPage() {
               <div className="flex items-start gap-3">
                 <AlertCircle className="w-5 h-5 text-blue-600 flex-shrink-0 mt-0.5" />
                 <div className="text-sm space-y-2">
-                  <p className="font-semibold text-foreground">How notifications work</p>
+                  <p className="font-semibold text-foreground">How alerts work</p>
                   <div className="space-y-1.5 text-muted-foreground">
-                    <p>• <strong>Location-based:</strong> You&apos;ll receive alerts for disasters within 100km of your location</p>
-                    <p>• <strong>Severity filter:</strong> Only alerts at or above your minimum severity will appear</p>
-                    <p>• <strong>Alert types:</strong> Choose which types of alerts you want to see</p>
-                    <p>• <strong>Regions:</strong> Optionally specify regions to receive alerts from anywhere</p>
+                    <p>• <strong>Location-based:</strong> Alerts for disasters within 100km of your location</p>
+                    <p>• <strong>Severity filter:</strong> Only alerts at or above your minimum severity</p>
+                    <p>• <strong>Custom regions:</strong> Optionally add regions to get alerts from anywhere</p>
+                    <p>• <strong>No location:</strong> Receive all global alerts</p>
                   </div>
                 </div>
               </div>
             </div>
 
             <div className="space-y-1">
-              <Label className="text-base font-semibold mb-3 block">Step 1: Dashboard Alert Severity</Label>
+              <Label className="text-base font-semibold mb-3 block">Minimum Severity</Label>
               <Select value={String(minSeverity)} onValueChange={(value) => setMinSeverity(Number(value))}>
                 <SelectTrigger className="w-full">
                   <SelectValue />
@@ -536,82 +562,73 @@ export default function SettingsPage() {
                 </SelectContent>
               </Select>
               <p className="text-xs text-muted-foreground mt-2">
-                Only alerts at this severity level or higher will appear in your dashboard. Lower severity = more alerts.
+                Only disasters at this severity or higher will trigger alerts (both dashboard and email).
               </p>
             </div>
 
-            <div className="space-y-1">
-              <Label className="text-base font-semibold mb-3 block">Step 2: Email Alert Severity</Label>
-              <Select value={String(emailMinSeverity)} onValueChange={(value) => setEmailMinSeverity(Number(value))}>
-                <SelectTrigger className="w-full">
-                  <SelectValue />
-                </SelectTrigger>
-                <SelectContent>
-                  <SelectItem value="1">Low (1) - All alerts</SelectItem>
-                  <SelectItem value="2">Medium (2) - Moderate and above</SelectItem>
-                  <SelectItem value="3">High (3) - Serious alerts only</SelectItem>
-                  <SelectItem value="4">Very High (4) - Critical only</SelectItem>
-                  <SelectItem value="5">Critical (5) - Most severe only</SelectItem>
-                </SelectContent>
-              </Select>
-              <p className="text-xs text-muted-foreground mt-2">
-                Only emails will be sent for alerts at this severity level or higher. This is separate from dashboard alerts.
+            <div className="space-y-3">
+              <Label className="text-base font-semibold block">
+                Watch Additional Regions (Optional)
+              </Label>
+              <p className="text-xs text-muted-foreground">
+                Get alerts from these regions even if they&apos;re outside your 100km radius.
               </p>
-            </div>
+              
+              <div className="flex gap-2">
+                <Input
+                  placeholder="Search for a region (e.g., California, Texas)"
+                  value={regionSearch}
+                  onChange={(e) => setRegionSearch(e.target.value)}
+                  onKeyDown={(e) => {
+                    if (e.key === 'Enter') {
+                      e.preventDefault()
+                      void searchAndAddRegion()
+                    }
+                  }}
+                  className="text-sm"
+                />
+                <Button
+                  onClick={searchAndAddRegion}
+                  disabled={searchingRegion || !regionSearch.trim()}
+                  size="sm"
+                >
+                  {searchingRegion ? (
+                    <Loader2 className="w-4 h-4 animate-spin" />
+                  ) : (
+                    <Plus className="w-4 h-4" />
+                  )}
+                </Button>
+              </div>
 
-            <div className="space-y-1">
-              <Label className="text-base font-semibold mb-3 block">Step 3: Alert Types</Label>
-              <p className="text-xs text-muted-foreground mb-3">Select which types of alerts you want to receive:</p>
-              <div className="space-y-3">
-                {[
-                  { value: 'new_crisis', label: 'New Crisis', desc: 'When a new disaster is first detected' },
-                  { value: 'severity_change', label: 'Severity Changes', desc: 'When an existing disaster becomes more severe' },
-                  { value: 'update', label: 'Updates', desc: 'General updates about ongoing crises' }
-                ].map(type => (
-                  <div key={type.value} className="flex items-start space-x-3 p-3 rounded-lg border hover:bg-muted/50 transition-colors">
-                    <Checkbox
-                      id={type.value}
-                      checked={alertTypes.includes(type.value)}
-                      onCheckedChange={() => toggleAlertType(type.value)}
-                      className="mt-1"
-                    />
-                    <div className="flex-1">
-                      <Label htmlFor={type.value} className="font-medium cursor-pointer text-sm">
-                        {type.label}
-                      </Label>
-                      <p className="text-xs text-muted-foreground mt-0.5">{type.desc}</p>
+              {watchedRegions.length > 0 && (
+                <div className="space-y-2">
+                  {watchedRegions.map((region, index) => (
+                    <div
+                      key={region.place_id || index}
+                      className="flex items-center justify-between p-2 rounded-lg border bg-muted/30"
+                    >
+                      <div className="flex items-center gap-2">
+                        <MapPin className="w-4 h-4 text-muted-foreground" />
+                        <span className="text-sm">{region.name}</span>
+                      </div>
+                      <Button
+                        variant="ghost"
+                        size="sm"
+                        onClick={() => removeRegion(index)}
+                        className="h-6 w-6 p-0"
+                      >
+                        <X className="w-4 h-4" />
+                      </Button>
                     </div>
-                  </div>
-                ))}
-              </div>
-              {alertTypes.length === 0 && (
-                <p className="text-xs text-red-600 dark:text-red-400 mt-2">
-                  ⚠️ You must select at least one alert type
-                </p>
+                  ))}
+                </div>
               )}
             </div>
 
-            <div className="space-y-1">
-              <Label htmlFor="regions" className="text-base font-semibold mb-2 block">
-                Step 4: Regions (Optional)
-              </Label>
-              <Input
-                id="regions"
-                placeholder="e.g., Texas, California, New York"
-                value={regions}
-                onChange={(e) => setRegions(e.target.value)}
-                className="text-sm"
-              />
-              <p className="text-xs text-muted-foreground mt-2">
-                <strong>Optional:</strong> Enter specific regions (comma-separated) to receive alerts from anywhere, even outside your 100km radius. 
-                Leave empty to only receive alerts based on your location radius.
-              </p>
-            </div>
-
             <div className="pt-2 border-t mt-auto">
               <Button
                 onClick={() => savePreferences()}
-                disabled={saving || alertTypes.length === 0}
+                disabled={saving}
                 className="w-full"
               >
                 {saving ? (
@@ -628,11 +645,6 @@ export default function SettingsPage() {
                   'Save Preferences'
                 )}
               </Button>
-              {alertTypes.length === 0 && (
-                <p className="text-xs text-red-600 dark:text-red-400 mt-2 text-center">
-                  Please select at least one alert type to save
-                </p>
-              )}
             </div>
           </CardContent>
         </Card>
diff --git a/client/app/onboarding/page.tsx b/client/app/onboarding/page.tsx
index ef253ac..ca42a7a 100644
--- a/client/app/onboarding/page.tsx
+++ b/client/app/onboarding/page.tsx
@@ -6,7 +6,6 @@ import { MapPin, CheckCircle2, Loader2, Search, Globe, Bell, AlertCircle, Chevro
 import { Button } from '@/components/ui/button';
 import { Card } from '@/components/ui/card';
 import { Input } from '@/components/ui/input';
-import { Checkbox } from '@/components/ui/checkbox';
 import { Label } from '@/components/ui/label';
 import {
   Select,
@@ -40,7 +39,6 @@ function OnboardingPageContent() {
   
   // Alert preferences state
   const [minSeverity, setMinSeverity] = useState(3);
-  const [alertTypes, setAlertTypes] = useState(['new_crisis', 'severity_change', 'update']);
   const [savingAlerts, setSavingAlerts] = useState(false);
   
   const router = useRouter();
@@ -191,12 +189,6 @@ function OnboardingPageContent() {
     }
   };
 
-  const toggleAlertType = (type: string) => {
-    setAlertTypes(prev =>
-      prev.includes(type) ? prev.filter(t => t !== type) : [...prev, type]
-    );
-  };
-
   const saveAlertPreferences = async () => {
     if (!user?.user_id) return;
 
@@ -206,10 +198,7 @@ function OnboardingPageContent() {
         method: 'PUT',
         body: JSON.stringify({
           min_severity: minSeverity,
-          email_min_severity: 3,
-          alert_types: alertTypes,
-          regions: null,
-          disaster_types: null,
+          watched_regions: null,
           email_enabled: true,
         }),
       });
@@ -448,36 +437,10 @@ function OnboardingPageContent() {
                 </p>
               </div>
 
-              <div>
-                <Label className="text-base font-semibold mb-3 block">Alert Types</Label>
-                <div className="space-y-3">
-                  {[
-                    { value: 'new_crisis', label: 'New Crisis', desc: 'When a new disaster is detected' },
-                    { value: 'severity_change', label: 'Severity Changes', desc: 'When disaster severity increases' },
-                    { value: 'update', label: 'Updates', desc: 'General updates about ongoing crises' }
-                  ].map(type => (
-                    <div key={type.value} className="flex items-start space-x-3 p-3 rounded-lg border hover:bg-muted/50 transition-colors">
-                      <Checkbox
-                        id={type.value}
-                        checked={alertTypes.includes(type.value)}
-                        onCheckedChange={() => toggleAlertType(type.value)}
-                        className="mt-1"
-                      />
-                      <div className="flex-1">
-                        <Label htmlFor={type.value} className="font-medium cursor-pointer text-sm">
-                          {type.label}
-                        </Label>
-                        <p className="text-xs text-muted-foreground mt-0.5">{type.desc}</p>
-                      </div>
-                    </div>
-                  ))}
-                </div>
-              </div>
-
               <div className="pt-2 space-y-3">
                 <Button
                   onClick={saveAlertPreferences}
-                  disabled={savingAlerts || alertTypes.length === 0}
+                  disabled={savingAlerts}
                   size="lg"
                   className="w-full h-12 text-base"
                 >
diff --git a/server/alembic/versions/12935d5f34ec_rename_regions_to_watched_regions.py b/server/alembic/versions/12935d5f34ec_rename_regions_to_watched_regions.py
new file mode 100644
index 0000000..11b6966
--- /dev/null
+++ b/server/alembic/versions/12935d5f34ec_rename_regions_to_watched_regions.py
@@ -0,0 +1,38 @@
+"""rename_regions_to_watched_regions
+
+Revision ID: 12935d5f34ec
+Revises: 2264546da1d9
+Create Date: 2025-12-01 20:34:22.804692
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision: str = '12935d5f34ec'
+down_revision: Union[str, Sequence[str], None] = '2264546da1d9'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('user_alert_preferences', schema=None) as batch_op:
+        batch_op.add_column(sa.Column('watched_regions', sa.JSON(), nullable=True))
+        batch_op.drop_column('regions')
+
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('user_alert_preferences', schema=None) as batch_op:
+        batch_op.add_column(sa.Column('regions', postgresql.JSON(astext_type=sa.Text()), autoincrement=False, nullable=True))
+        batch_op.drop_column('watched_regions')
+
+    # ### end Alembic commands ###
diff --git a/server/alembic/versions/2264546da1d9_simplify_alert_preferences.py b/server/alembic/versions/2264546da1d9_simplify_alert_preferences.py
new file mode 100644
index 0000000..f728710
--- /dev/null
+++ b/server/alembic/versions/2264546da1d9_simplify_alert_preferences.py
@@ -0,0 +1,40 @@
+"""simplify_alert_preferences
+
+Revision ID: 2264546da1d9
+Revises: 90529dbdc22f
+Create Date: 2025-12-01 20:20:49.218192
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision: str = '2264546da1d9'
+down_revision: Union[str, Sequence[str], None] = '90529dbdc22f'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('user_alert_preferences', schema=None) as batch_op:
+        batch_op.drop_column('alert_types')
+        batch_op.drop_column('email_min_severity')
+        batch_op.drop_column('disaster_types')
+
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('user_alert_preferences', schema=None) as batch_op:
+        batch_op.add_column(sa.Column('disaster_types', postgresql.JSON(astext_type=sa.Text()), autoincrement=False, nullable=True))
+        batch_op.add_column(sa.Column('email_min_severity', sa.INTEGER(), autoincrement=False, nullable=False))
+        batch_op.add_column(sa.Column('alert_types', postgresql.JSON(astext_type=sa.Text()), autoincrement=False, nullable=False))
+
+    # ### end Alembic commands ###
diff --git a/server/db_utils/db.py b/server/db_utils/db.py
index 45457f7..a312804 100644
--- a/server/db_utils/db.py
+++ b/server/db_utils/db.py
@@ -274,14 +274,9 @@ class UserAlertPreferences(Base):
     user_id = Column(
         String, ForeignKey("users.id", ondelete="CASCADE"), nullable=False, index=True
     )
-    alert_types = Column(
-        JSON, default=["new_crisis", "severity_change", "update"], nullable=False
-    )
     min_severity = Column(Integer, default=3, nullable=False)
     email_enabled = Column(Boolean, default=True, nullable=False)
-    email_min_severity = Column(Integer, default=3, nullable=False)
-    regions = Column(JSON, nullable=True)
-    disaster_types = Column(JSON, nullable=True)
+    watched_regions = Column(JSON, nullable=True)
     created_at = Column(DateTime, default=datetime.utcnow, nullable=False)
     updated_at = Column(
         DateTime, default=datetime.utcnow, onupdate=datetime.utcnow, nullable=False
diff --git a/server/requirements.txt b/server/requirements.txt
index b17b1b8..8ab1b8a 100644
--- a/server/requirements.txt
+++ b/server/requirements.txt
@@ -93,3 +93,4 @@ websockets==13.1
 alembic==1.12.0
 Mako==1.2.4
 argon2-cffi==23.1.0
+Pillow==10.4.0
diff --git a/server/routers/alerts.py b/server/routers/alerts.py
index 895a83b..c1c8fc5 100644
--- a/server/routers/alerts.py
+++ b/server/routers/alerts.py
@@ -1,6 +1,7 @@
 from fastapi import APIRouter, Depends, HTTPException, Query
 from sqlalchemy.orm import Session
 from db_utils.db import Alert, AlertQueue, UserAlertPreferences, User, SessionLocal, get_db_session
+from services.geocoding_service import geocode_region
 from typing import Optional, List
 from pydantic import BaseModel
 from datetime import datetime
@@ -23,24 +24,26 @@ class Config:
         from_attributes = True
 
 
+class WatchedRegion(BaseModel):
+    name: str
+    lat: float
+    lng: float
+    bounds: Optional[dict] = None
+    place_id: Optional[str] = None
+
+
 class UserAlertPreferencesRequest(BaseModel):
-    alert_types: List[str] = ["new_crisis", "severity_change", "update"]
     min_severity: int = 3
     email_enabled: bool = True
-    email_min_severity: int = 3
-    regions: Optional[List[str]] = None
-    disaster_types: Optional[List[str]] = None
+    watched_regions: Optional[List[WatchedRegion]] = None
 
 
 class UserAlertPreferencesResponse(BaseModel):
     id: int
     user_id: str
-    alert_types: List[str]
     min_severity: int
     email_enabled: bool
-    email_min_severity: int
-    regions: Optional[List[str]]
-    disaster_types: Optional[List[str]]
+    watched_regions: Optional[List[dict]]
     created_at: datetime
     updated_at: datetime
 
@@ -48,6 +51,14 @@ class Config:
         from_attributes = True
 
 
+class RegionSearchResult(BaseModel):
+    name: str
+    lat: float
+    lng: float
+    bounds: Optional[dict] = None
+    place_id: Optional[str] = None
+
+
 class UserLocationRequest(BaseModel):
     location: str
     latitude: Optional[float] = None
@@ -200,32 +211,33 @@ def update_alert_preferences(
     """Update user's alert preferences"""
     if not db:
         raise HTTPException(status_code=500, detail="Database connection failed")
-    
+
     try:
         user = db.query(User).filter(User.id == user_id).first()
         if not user:
             raise HTTPException(status_code=404, detail="User not found")
-        
+
         prefs = db.query(UserAlertPreferences).filter(
             UserAlertPreferences.user_id == user_id
         ).first()
-        
+
         if not prefs:
             prefs = UserAlertPreferences(user_id=user_id)
             db.add(prefs)
-        
+
         if prefs_data:
-            prefs.alert_types = prefs_data.alert_types
             prefs.min_severity = prefs_data.min_severity
             prefs.email_enabled = prefs_data.email_enabled
-            prefs.email_min_severity = prefs_data.email_min_severity
-            prefs.regions = prefs_data.regions
-            prefs.disaster_types = prefs_data.disaster_types
+            prefs.watched_regions = (
+                [r.model_dump() for r in prefs_data.watched_regions]
+                if prefs_data.watched_regions
+                else None
+            )
             prefs.updated_at = datetime.utcnow()
-        
+
         db.commit()
         db.refresh(prefs)
-        
+
         return prefs
     except Exception as e:
         db.rollback()
@@ -243,21 +255,21 @@ def update_user_location(
     """Update user's primary location"""
     if not db:
         raise HTTPException(status_code=500, detail="Database connection failed")
-    
+
     try:
         user = db.query(User).filter(User.id == user_id).first()
         if not user:
             raise HTTPException(status_code=404, detail="User not found")
-        
+
         if location_data:
             user.location = location_data.location
             user.latitude = location_data.latitude
             user.longitude = location_data.longitude
             user.updated_at = datetime.utcnow()
-        
+
         db.commit()
         db.refresh(user)
-        
+
         return {
             "status": "success",
             "location": user.location,
@@ -269,3 +281,20 @@ def update_user_location(
         raise HTTPException(status_code=500, detail=str(e))
     finally:
         db.close()
+
+
+@router.get("/regions/search", response_model=RegionSearchResult)
+def search_region(query: str = Query(..., min_length=2)):
+    """Search for a region using Google Geocoding API"""
+    result = geocode_region(query)
+
+    if not result:
+        raise HTTPException(status_code=404, detail="Region not found")
+
+    return RegionSearchResult(
+        name=result["name"],
+        lat=result["lat"],
+        lng=result["lng"],
+        bounds=result.get("bounds"),
+        place_id=result.get("place_id"),
+    )
diff --git a/server/routers/data_feed.py b/server/routers/data_feed.py
index 1e3fac0..6ae3e22 100644
--- a/server/routers/data_feed.py
+++ b/server/routers/data_feed.py
@@ -4,6 +4,8 @@
 from datetime import datetime, timedelta
 from typing import Optional
 from db_utils.db import SessionLocal, DataFeed, Post, Disaster, CollectionRun
+from services.database_service import ensure_data_feed_initialized, calculate_next_run_time
+import os
 
 router = APIRouter(prefix="/api/data-feed", tags=["data-feed"])
 
@@ -19,20 +21,27 @@ def get_db():
 @router.get("/status")
 def get_feed_status(db: Session = Depends(get_db)):
     """Get status of all data collection feeds"""
+    ensure_data_feed_initialized()
+    
     feeds = db.query(DataFeed).all()
     
-    return {
-        "feeds": [
-            {
-                "id": feed.id,
-                "name": feed.name,
-                "status": feed.status,
-                "last_run": feed.last_run_at.isoformat() if feed.last_run_at else None,
-                "next_run": feed.next_run_at.isoformat() if feed.next_run_at else None,
-            }
-            for feed in feeds
-        ]
-    }
+    schedule_hours = int(os.getenv("SCHEDULE_HOURS", "8"))
+    
+    result_feeds = []
+    for feed in feeds:
+        next_run = feed.next_run_at
+        if next_run is None:
+            next_run = calculate_next_run_time(schedule_hours)
+        
+        result_feeds.append({
+            "id": feed.id,
+            "name": feed.name,
+            "status": feed.status,
+            "last_run": feed.last_run_at.isoformat() if feed.last_run_at else None,
+            "next_run": next_run.isoformat() if next_run else None,
+        })
+    
+    return {"feeds": result_feeds}
 
 
 @router.get("/overview")
diff --git a/server/scripts/backfill_coordinates.py b/server/scripts/backfill_coordinates.py
new file mode 100644
index 0000000..9ed4988
--- /dev/null
+++ b/server/scripts/backfill_coordinates.py
@@ -0,0 +1,150 @@
+"""
+Backfill missing coordinates for disasters using Google Geocoding API.
+
+Run directly (connects to port-forwarded prod DB):
+    DATABASE_URL="postgresql://dev:devpassword@localhost:5432/bluerelief" \
+    GOOGLE_API_KEY="your-key" \
+    python scripts/backfill_coordinates.py
+
+Or via docker (uses docker network):
+    docker exec bluerelief-backend python scripts/backfill_coordinates.py
+"""
+
+import os
+import sys
+import time
+import requests
+from sqlalchemy import create_engine, Column, Integer, Float, String, text
+from sqlalchemy.orm import sessionmaker, declarative_base
+
+# Get database URL from env or use default
+DATABASE_URL = os.getenv("DATABASE_URL", "postgresql://dev:devpassword@localhost:5432/bluerelief")
+GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
+
+if not GOOGLE_API_KEY:
+    print("❌ GOOGLE_API_KEY environment variable required")
+    sys.exit(1)
+
+engine = create_engine(DATABASE_URL)
+SessionLocal = sessionmaker(bind=engine)
+Base = declarative_base()
+
+
+def geocode_location(query: str) -> dict:
+    """Geocode a location using Google API."""
+    try:
+        url = "https://maps.googleapis.com/maps/api/geocode/json"
+        params = {"address": query, "key": GOOGLE_API_KEY}
+        response = requests.get(url, params=params, timeout=10)
+        response.raise_for_status()
+        data = response.json()
+        
+        if data.get("status") == "OK" and data.get("results"):
+            location = data["results"][0]["geometry"]["location"]
+            return {"lat": location["lat"], "lng": location["lng"]}
+    except Exception as e:
+        print(f"   Geocoding error: {e}")
+    return None
+
+
+def backfill_coordinates(dry_run: bool = True, limit: int = None):
+    """
+    Find disasters with location_name but missing lat/lng and geocode them.
+    """
+    db = SessionLocal()
+    
+    try:
+        # Find disasters that have location_name but no coordinates
+        query = text("""
+            SELECT id, location_name 
+            FROM disasters 
+            WHERE latitude IS NULL 
+              AND location_name IS NOT NULL 
+              AND location_name != ''
+            ORDER BY id DESC
+        """)
+        
+        if limit:
+            query = text(f"""
+                SELECT id, location_name 
+                FROM disasters 
+                WHERE latitude IS NULL 
+                  AND location_name IS NOT NULL 
+                  AND location_name != ''
+                ORDER BY id DESC
+                LIMIT {limit}
+            """)
+        
+        result = db.execute(query)
+        disasters = result.fetchall()
+        
+        print(f"Found {len(disasters)} disasters to geocode")
+        if dry_run:
+            print("🔍 DRY RUN - no changes will be made\n")
+        else:
+            print("⚠️  APPLYING CHANGES\n")
+        
+        success = 0
+        failed = 0
+        skipped = 0
+        
+        for i, (disaster_id, location) in enumerate(disasters):
+            location = location.strip()
+            
+            # Skip vague locations
+            if any(x in location.lower() for x in ['worldwide', 'global', 'various']):
+                print(f"⏭️  [{disaster_id}] Skipping vague: {location[:50]}")
+                skipped += 1
+                continue
+            
+            # Skip multi-location (multiple countries)
+            if location.count(',') > 3 or ';' in location or ' and ' in location.lower():
+                print(f"⏭️  [{disaster_id}] Skipping multi-location: {location[:50]}")
+                skipped += 1
+                continue
+            
+            result = geocode_location(location)
+            
+            if result:
+                print(f"✅ [{disaster_id}] {location[:40]:<40} → ({result['lat']:.4f}, {result['lng']:.4f})")
+                
+                if not dry_run:
+                    update_query = text("""
+                        UPDATE disasters 
+                        SET latitude = :lat, longitude = :lng 
+                        WHERE id = :id
+                    """)
+                    db.execute(update_query, {"lat": result['lat'], "lng": result['lng'], "id": disaster_id})
+                
+                success += 1
+            else:
+                print(f"❌ [{disaster_id}] Failed: {location[:50]}")
+                failed += 1
+            
+            # Rate limiting
+            if (i + 1) % 50 == 0:
+                print(f"\n⏳ Processed {i + 1}/{len(disasters)}, waiting 1s...\n")
+                time.sleep(1)
+        
+        if not dry_run:
+            db.commit()
+            print(f"\n💾 Changes committed to database")
+        
+        print(f"\n📊 Summary:")
+        print(f"   ✅ Geocoded: {success}")
+        print(f"   ❌ Failed: {failed}")
+        print(f"   ⏭️  Skipped: {skipped}")
+        print(f"   Total processed: {len(disasters)}")
+        
+    finally:
+        db.close()
+
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser(description='Backfill disaster coordinates')
+    parser.add_argument('--apply', action='store_true', help='Actually apply changes (default is dry run)')
+    parser.add_argument('--limit', type=int, help='Limit number of records to process')
+    args = parser.parse_args()
+    
+    backfill_coordinates(dry_run=not args.apply, limit=args.limit)
diff --git a/server/services/alert_generator.py b/server/services/alert_generator.py
index 1956f20..d5ea34f 100644
--- a/server/services/alert_generator.py
+++ b/server/services/alert_generator.py
@@ -1,6 +1,7 @@
 from datetime import datetime, timedelta
 from sqlalchemy.orm import Session
 from db_utils.db import Alert, AlertQueue, Disaster, User, UserAlertPreferences, SessionLocal
+from services.geocoding_service import is_point_in_bounds
 import json
 import logging
 import math
@@ -32,7 +33,7 @@ def get_severity_priority(severity: int) -> int:
 
 def calculate_distance(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
     """Calculate distance between two coordinates in km using Haversine formula"""
-    if not all([lat1, lon1, lat2, lon2]):
+    if any(v is None for v in [lat1, lon1, lat2, lon2]):
         return None
 
     R = 6371  # Earth's radius in km
@@ -51,91 +52,52 @@ def calculate_distance(lat1: float, lon1: float, lat2: float, lon2: float) -> fl
 def should_alert_user_for_disaster(
     user_prefs: UserAlertPreferences, user: User, disaster: Disaster, alert_type: str
 ) -> bool:
-    """Check if user should receive alert for this disaster based on preferences and location
-
-    Checks (in order):
-    1. User has preferences set up
-    2. Alert type is in user's preferred alert types
-    3. Disaster type matches user's preferred disaster types (if specified)
-    4. Severity meets minimum threshold
-    5. GLOBAL ALERTS MODE: If user has no location (null), receive all alerts
-    6. GEO-RADIUS: Distance from user to disaster (PRIMARY)
-    7. REGION FILTER: User's custom region preferences (SECONDARY)
-
-    Note: email_enabled controls EMAIL sending, not alert creation
-
-    Returns:
-        True if user should receive the alert
+    """Check if user should receive alert for this disaster
+
+    Simple logic:
+    1. Must have preferences set up
+    2. Disaster severity must meet user's minimum threshold
+    3. Location check:
+       - No user location = global mode (all alerts)
+       - Has location = must be within 100km OR match a custom region
+       - No disaster coordinates = must match a custom region
     """
     if not user_prefs:
         return False
 
-    # Check if alert type is in user's preferred alert types
-    if user_prefs.alert_types and isinstance(user_prefs.alert_types, list):
-        if alert_type not in user_prefs.alert_types:
-            return False
-
-    # Check if disaster type matches user's preferred disaster types (if specified)
-    if (
-        user_prefs.disaster_types
-        and isinstance(user_prefs.disaster_types, list)
-        and len(user_prefs.disaster_types) > 0
-    ):
-        if disaster.disaster_type:
-            # Handle comma-separated disaster types (e.g., "landslide, flood")
-            disaster_types_list = [
-                dt.strip().lower() for dt in disaster.disaster_type.split(",")
-            ]
-            user_disaster_types = [dt.lower() for dt in user_prefs.disaster_types]
-            if not any(dt in user_disaster_types for dt in disaster_types_list):
-                return False
-
     disaster_severity = disaster.severity or 0
     if disaster_severity < user_prefs.min_severity:
         return False
 
-    # GLOBAL ALERTS MODE: If user has no location (null), receive all alerts
+    # Global mode: no location set = receive all alerts
     if user.latitude is None and user.longitude is None:
         return True
 
-    # PRIMARY FILTER: Geo-radius based on user coordinates
-    if user.latitude is not None and user.longitude is not None and \
-       disaster.latitude is not None and disaster.longitude is not None:
+    # Check if disaster is within radius
+    if disaster.latitude is not None and disaster.longitude is not None:
         distance = calculate_distance(
             user.latitude, user.longitude,
             disaster.latitude, disaster.longitude
         )
+        if distance is not None and distance <= ALERT_RADIUS_KM:
+            return True
 
-        # If distance is calculated and exceeds radius, check regions as fallback
-        if distance is not None and distance > ALERT_RADIUS_KM:
-            # SECONDARY FILTER: Check if user has specific regions (override for distant areas)
-            if user_prefs.regions and isinstance(user_prefs.regions, list):
-                disaster_location = (disaster.location_name or "").lower()
-                matches_region = any(
-                    region.lower() in disaster_location or disaster_location in region.lower()
-                    for region in user_prefs.regions
-                )
-                if not matches_region:
-                    return False
-            else:
-                # No regions specified and outside radius = no alert
-                return False
-    else:
-        # Fallback: If disaster has no coordinates, use region matching only
-        # If user has no regions set, don't send alert (unless in global mode which is checked above)
-        if user_prefs.regions and isinstance(user_prefs.regions, list):
-            disaster_location = (disaster.location_name or "").lower()
-            matches_region = any(
-                region.lower() in disaster_location or disaster_location in region.lower()
-                for region in user_prefs.regions
-            )
-            if not matches_region:
-                return False
-        else:
-            # No coordinates and no regions = no alert
-            return False
-
-    return True
+    # Check watched regions (with proper bounds checking)
+    if (
+        user_prefs.watched_regions
+        and isinstance(user_prefs.watched_regions, list)
+        and len(user_prefs.watched_regions) > 0
+        and disaster.latitude is not None
+        and disaster.longitude is not None
+    ):
+        for region in user_prefs.watched_regions:
+            bounds = region.get("bounds") if isinstance(region, dict) else None
+            if bounds and is_point_in_bounds(
+                disaster.latitude, disaster.longitude, bounds
+            ):
+                return True
+
+    return False
 
 
 def should_alert_for_disaster(disaster) -> tuple[bool, str]:
diff --git a/server/services/analysis.py b/server/services/analysis.py
index f978f16..b58abb9 100644
--- a/server/services/analysis.py
+++ b/server/services/analysis.py
@@ -6,10 +6,54 @@
 from typing import List, Dict, Any, Optional
 import json
 import re
+import requests
+import base64
+from io import BytesIO
+from PIL import Image
+from services.geocoding_service import geocode_region
 
 load_dotenv()
 
 
+def download_image(url: str, max_size: int = 1024) -> Optional[Dict]:
+    """Download and prepare image for Gemini vision API.
+
+    Args:
+        url: Image URL to download
+        max_size: Max dimension to resize to (saves tokens)
+
+    Returns:
+        Dict with mime_type and data for Gemini, or None if failed
+    """
+    try:
+        headers = {"User-Agent": "BlueRelief/1.0 (Crisis Monitoring Service)"}
+        response = requests.get(url, timeout=10, headers=headers)
+        response.raise_for_status()
+
+        # Open and resize image
+        img = Image.open(BytesIO(response.content))
+
+        # Convert to RGB if needed (for PNG with transparency)
+        if img.mode in ("RGBA", "P"):
+            img = img.convert("RGB")
+
+        # Resize if too large
+        if max(img.size) > max_size:
+            ratio = max_size / max(img.size)
+            new_size = (int(img.size[0] * ratio), int(img.size[1] * ratio))
+            img = img.resize(new_size, Image.Resampling.LANCZOS)
+
+        # Convert to base64
+        buffer = BytesIO()
+        img.save(buffer, format="JPEG", quality=85)
+        img_data = base64.b64encode(buffer.getvalue()).decode("utf-8")
+
+        return {"mime_type": "image/jpeg", "data": img_data}
+    except Exception as e:
+        print(f"⚠️  Failed to download image {url[:50]}...: {e}")
+        return None
+
+
 def normalize_event_time(time_str: str) -> Optional[datetime]:
     """Normalize event time from AI analysis to datetime object
 
@@ -155,41 +199,92 @@ def analyze_posts(posts: List[Dict], batch_size: int = 50, batch_delay: int = 1)
 
         print(f"\n📦 Processing batch {batch_num + 1}/{total_batches} ({len(batch_posts)} posts)")
 
-        # Build prompt with post IDs included
-        posts_text = "\n".join(
-            [
-                f"{idx}. [POST_ID: {post.get('db_post_id', 'unknown')}] {post.get('text') or post.get('record', {}).get('text', '')}"
-                for idx, post in enumerate(batch_posts, start_idx + 1)
-            ]
-        )
+        # Build prompt with post IDs and collect images
+        posts_lines = []
+        batch_images = []  # Collect images for vision API
+
+        for idx, post in enumerate(batch_posts, start_idx + 1):
+            text = post.get("text") or post.get("record", {}).get("text", "")
+            post_id = post.get("db_post_id", "unknown")
+
+            # Get image URLs if available
+            media = post.get("media", {})
+            image_urls = media.get("urls", []) if isinstance(media, dict) else []
+
+            line = f"{idx}. [POST_ID: {post_id}] {text}"
+
+            # Download and include images (max 2 per post, max 10 per batch)
+            if image_urls and len(batch_images) < 10:
+                for img_url in image_urls[:2]:
+                    img_data = download_image(img_url)
+                    if img_data:
+                        batch_images.append(
+                            {"post_id": post_id, "post_idx": idx, "image": img_data}
+                        )
+                        line += f"\n   [HAS_IMAGE_{len(batch_images)}]"
+
+            posts_lines.append(line)
+
+        posts_text = "\n".join(posts_lines)
+
+        if batch_images:
+            print(f"📷 Downloaded {len(batch_images)} images for vision analysis")
 
         prompt = (
             f"CURRENT TIME (UTC): {now.isoformat()}Z\n\n"
             "Analyze these social media posts about disasters and extract structured information. "
+            "Some posts have attached images marked as [HAS_IMAGE_N] - I'm also providing these images below. "
+            "Use BOTH the text AND images to extract disaster details. Images often contain headlines, news graphics, or photos showing the disaster. "
             "For each disaster mentioned, return a JSON array with objects containing:\n"
             "- post_id: the database post ID from the [POST_ID: X] marker (MUST be an integer or null)\n"
-            "- location_name: the place name (e.g., 'Tokyo, Japan', 'Manila, Philippines')\n"
-            "- latitude: decimal latitude coordinate (e.g., 35.6762)\n"
-            "- longitude: decimal longitude coordinate (e.g., 139.6503)\n"
+            "- location_name: the SPECIFIC place name (e.g., 'Los Angeles, California, USA', 'Tokyo, Japan', 'Manila, Philippines'). "
+            "Include city/region, state/province, and country. Must be a real, geocodable location.\n"
             "- event_time: **ONLY ISO 8601 format YYYY-MM-DDTHH:MM:SSZ** when the disaster occurred. "
-            "If the exact time is unknown, use the post's timestamp or estimate based on context. "
-            "NEVER use vague terms like 'next week', 'upcoming', 'ongoing', 'recently', etc. "
-            "ALWAYS return a valid ISO 8601 timestamp. If completely unknown, use current time.\n"
-            "- disaster_type: type of disaster (e.g., 'earthquake', 'hurricane', 'flood', 'wildfire', 'tornado')\n"
+            "CRITICAL: Only extract CURRENT/RECENT disasters (within the last 30 days). "
+            "If a post mentions a HISTORICAL disaster (years/decades ago), SKIP IT entirely. "
+            "If the exact time is unknown, use the current time. "
+            "NEVER use vague terms like 'next week', 'upcoming', 'ongoing', 'recently', etc.\n"
+            "- disaster_type: MUST be exactly ONE of these 8 values (lowercase): "
+            "earthquake, flood, wildfire, hurricane, tornado, tsunami, volcano, heatwave. "
+            "Pick ONE. No combinations.\n"
             "- severity: rate 1-5 (1=minor, 5=catastrophic)\n"
             "- magnitude: single numerical value if applicable, null otherwise\n"
-            "- description: brief summary\n"
+            "- description: DETAILED summary (at least 50 characters) with specific facts like casualties, damage, evacuations. "
+            "Do NOT just say 'Flood in Indonesia' - include actual details from the post.\n"
             "- affected_population: estimate number of people affected. "
             "Look for mentions like 'X families evacuated', 'Y people without power'. "
             "Convert to individual counts (1 family ≈ 4 people, 1 home ≈ 3 people). "
             "Provide best-effort estimates: neighborhood=5000, city block=500, building=50, regional=50000. "
             "Return null if completely unknown.\n\n"
+            "CRITICAL LOCATION RULES:\n"
+            "1. NEVER use vague locations like 'Worldwide', 'Global', 'Asia', 'Europe', 'Unknown', 'Undisclosed'\n"
+            "2. If a disaster affects MULTIPLE COUNTRIES, create SEPARATE entries for each country with specific locations\n"
+            "   Example: 'Floods in Thailand and Indonesia' → two entries: 'Bangkok, Thailand' AND 'Jakarta, Indonesia'\n"
+            "3. If no specific location is mentioned, SKIP that disaster entirely - do not include it\n"
+            "4. Use the most specific location possible (city > state > country)\n"
+            "5. For ocean/offshore events, use nearest coastal city (e.g., 'Offshore Ecuador' → 'Salinas, Ecuador')\n\n"
+            "DISASTER TYPE MAPPING:\n"
+            "- bushfire/forest fire → wildfire\n"
+            "- flash flood/flooding → flood\n"
+            "- cyclone/typhoon/tropical storm → hurricane\n"
+            "- twister → tornado\n"
+            "- quake/tremor → earthquake\n"
+            "- eruption → volcano\n"
+            "- heat wave/extreme heat → heatwave\n\n"
             f"Posts:\n{posts_text}\n\n"
-            "Return ONLY valid JSON. CRITICAL: event_time MUST be ISO 8601 format (YYYY-MM-DDTHH:MM:SSZ), never vague text."
+            "Return ONLY valid JSON. DO NOT include latitude/longitude - we will geocode the location_name separately."
         )
 
         try:
-            response = model.generate_content(prompt)
+            # Build content parts for multimodal request
+            content_parts = [prompt]
+
+            # Add images if we have any
+            if batch_images:
+                for img_info in batch_images:
+                    content_parts.append({"inline_data": img_info["image"]})
+
+            response = model.generate_content(content_parts)
             cleaned_response = clean_json_response(response.text)
 
             # Try to merge the disasters from this batch
@@ -208,8 +303,53 @@ def analyze_posts(posts: List[Dict], batch_size: int = 50, batch_delay: int = 1)
             print(f"⚠️ Error processing batch {batch_num + 1}: {str(e)}")
 
     if all_disasters:
-        final_json = json.dumps(all_disasters, indent=2)
-        print(f"\n[{datetime.now()}] AI Analysis Complete - Found {len(all_disasters)} total disasters")
+        # Filter out vague/invalid locations before geocoding
+        vague_terms = [
+            "worldwide",
+            "global",
+            "unknown",
+            "undisclosed",
+            "various",
+            "multiple",
+        ]
+        valid_disasters = []
+        skipped = 0
+
+        for disaster in all_disasters:
+            location = (disaster.get("location_name") or "").strip().lower()
+            if not location or any(term in location for term in vague_terms):
+                skipped += 1
+                continue
+            valid_disasters.append(disaster)
+
+        if skipped:
+            print(f"⏭️  Skipped {skipped} disasters with vague/missing locations")
+
+        # Geocode locations to get accurate coordinates
+        print(f"\n🌍 Geocoding {len(valid_disasters)} disaster locations...")
+        geocoded_disasters = []
+
+        for disaster in valid_disasters:
+            location_name = disaster.get("location_name")
+            geo_result = geocode_region(location_name)
+
+            if geo_result and geo_result.get("lat") and geo_result.get("lng"):
+                disaster["latitude"] = geo_result["lat"]
+                disaster["longitude"] = geo_result["lng"]
+                geocoded_disasters.append(disaster)
+            else:
+                print(f"⚠️  Failed to geocode: {location_name[:50]}")
+
+        print(f"✅ Geocoded {len(geocoded_disasters)}/{len(valid_disasters)} locations")
+
+        if not geocoded_disasters:
+            print("⚠️  No disasters with valid coordinates")
+            return "[]"
+
+        final_json = json.dumps(geocoded_disasters, indent=2)
+        print(
+            f"\n[{datetime.now()}] AI Analysis Complete - Found {len(geocoded_disasters)} disasters with coordinates"
+        )
         return final_json
 
     return "[]"
diff --git a/server/services/database_service.py b/server/services/database_service.py
index 6c753be..1cc56b4 100644
--- a/server/services/database_service.py
+++ b/server/services/database_service.py
@@ -1,10 +1,85 @@
-from datetime import datetime
+from datetime import datetime, timedelta
 from sqlalchemy.orm import Session
-from db_utils.db import CollectionRun, Post, Disaster, SessionLocal
+from db_utils.db import CollectionRun, Post, Disaster, DataFeed, SessionLocal
 import json
 import re
+import os
 from services.population_estimator import PopulationEstimator
 
+# Valid disaster types - matches DISASTER_CONFIG in tasks.py
+VALID_DISASTER_TYPES = {
+    "earthquake",
+    "hurricane",
+    "flood",
+    "wildfire",
+    "tornado",
+    "tsunami",
+    "volcano",
+    "heatwave",
+}
+
+# Map variations to the 8 standard types
+DISASTER_TYPE_MAPPING = {
+    # earthquake variations
+    "quake": "earthquake",
+    "tremor": "earthquake",
+    "seismic": "earthquake",
+    # hurricane variations
+    "cyclone": "hurricane",
+    "typhoon": "hurricane",
+    "tropical storm": "hurricane",
+    "tropical cyclone": "hurricane",
+    # flood variations
+    "flooding": "flood",
+    "flash flood": "flood",
+    "floods": "flood",
+    # wildfire variations
+    "bushfire": "wildfire",
+    "forest fire": "wildfire",
+    "fire": "wildfire",
+    # tornado variations
+    "twister": "tornado",
+    # volcano variations
+    "eruption": "volcano",
+    "volcanic eruption": "volcano",
+    "volcanic": "volcano",
+    # heatwave variations
+    "heat wave": "heatwave",
+    "extreme heat": "heatwave",
+    "heat dome": "heatwave",
+}
+
+
+def normalize_disaster_type(disaster_type: str) -> str:
+    """Normalize disaster type to one of the 5 standard types."""
+    if not disaster_type:
+        return None
+
+    dt = disaster_type.lower().strip()
+
+    # Take first if comma-separated
+    if "," in dt:
+        dt = dt.split(",")[0].strip()
+
+    # Already valid?
+    if dt in VALID_DISASTER_TYPES:
+        return dt
+
+    # Try direct mapping
+    if dt in DISASTER_TYPE_MAPPING:
+        return DISASTER_TYPE_MAPPING[dt]
+
+    # Try partial match
+    for key, value in DISASTER_TYPE_MAPPING.items():
+        if key in dt:
+            return value
+
+    for valid_type in VALID_DISASTER_TYPES:
+        if valid_type in dt:
+            return valid_type
+
+    return None
+
 
 def extract_post_timestamp(post_data: dict) -> datetime:
     """Extract and normalize post timestamp using Bluesky's sortAt logic
@@ -303,8 +378,57 @@ def save_analysis(analysis_text: str, run_id: int, posts: list = None):
             if isinstance(disasters, dict):
                 disasters = [disasters]
 
-            print("Saving disasters to database...")
-            for disaster_data in disasters:
+            # Filter out low-quality disasters
+            valid_disasters = []
+            skipped_coords = 0
+            skipped_quality = 0
+
+            for d in disasters:
+                lat = d.get("latitude")
+                lng = d.get("longitude")
+                description = (d.get("description") or "").strip()
+                location = (d.get("location_name") or "").strip()
+
+                # Must have coordinates
+                if lat is None or lng is None:
+                    skipped_coords += 1
+                    continue
+
+                # Quality checks for description
+                if len(description) < 20:
+                    skipped_quality += 1
+                    continue
+
+                # Check for low-effort descriptions (just repeating location/type)
+                desc_lower = description.lower()
+                loc_lower = location.lower().split(",")[0] if location else ""
+                disaster_type = (d.get("disaster_type") or "").lower()
+
+                # Skip if description is just "[type] in [location]" or similar garbage
+                low_effort_patterns = [
+                    f"{disaster_type} in {loc_lower}",
+                    f"{disaster_type} reported in",
+                    f"a {disaster_type} occurred",
+                    f"{disaster_type} occurred in",
+                    f"general mention of",
+                    f"information about",
+                ]
+                if (
+                    any(pattern in desc_lower for pattern in low_effort_patterns)
+                    and len(description) < 60
+                ):
+                    skipped_quality += 1
+                    continue
+
+                valid_disasters.append(d)
+
+            if skipped_coords:
+                print(f"⏭️  Skipped {skipped_coords} disasters without coordinates")
+            if skipped_quality:
+                print(f"⏭️  Skipped {skipped_quality} low-quality disasters")
+
+            print(f"Saving {len(valid_disasters)} disasters to database...")
+            for disaster_data in valid_disasters:
                 magnitude_value = disaster_data.get("magnitude")
 
                 if magnitude_value is not None:
@@ -337,11 +461,30 @@ def save_analysis(analysis_text: str, run_id: int, posts: list = None):
                     normalize_event_time(event_time) if event_time else None
                 )
 
+                # Skip historical events (older than 30 days)
+                if normalized_event_time:
+                    days_old = (
+                        datetime.utcnow() - normalized_event_time.replace(tzinfo=None)
+                    ).days
+                    if days_old > 30:
+                        print(f"⚠️  Skipping historical event ({days_old} days old)")
+                        continue
+
+                # Normalize disaster type to standard value
+                raw_disaster_type = disaster_data.get("disaster_type")
+                normalized_type = normalize_disaster_type(raw_disaster_type)
+
+                if not normalized_type:
+                    print(
+                        f"⚠️  Skipping disaster with invalid type: {raw_disaster_type}"
+                    )
+                    continue
+
                 affected_population = PopulationEstimator.estimate_population(
                     longitude=disaster_data.get("longitude"),
                     latitude=disaster_data.get("latitude"),
-                    disaster_type=disaster_data.get("disaster_type"),
-                    severity=disaster_data.get("severity")
+                    disaster_type=normalized_type,
+                    severity=disaster_data.get("severity"),
                 )
 
                 disaster = Disaster(
@@ -353,7 +496,7 @@ def save_analysis(analysis_text: str, run_id: int, posts: list = None):
                     magnitude=magnitude_value,
                     description=disaster_data.get("description"),
                     affected_population=affected_population,
-                    disaster_type=disaster_data.get("disaster_type", None),
+                    disaster_type=normalized_type,
                     collection_run_id=run_id,
                     post_id=post_id,
                 )
@@ -361,9 +504,9 @@ def save_analysis(analysis_text: str, run_id: int, posts: list = None):
                 db.add(disaster)
 
             db.commit()
-            linked = sum(1 for d in disasters if d.get("post_id") is not None)
+            linked = sum(1 for d in valid_disasters if d.get("post_id") is not None)
             print(
-                f"Saved {len(disasters)} disasters from AI analysis ({linked} linked to posts)"
+                f"✅ Saved {len(valid_disasters)} disasters ({linked} linked to posts)"
             )
 
         except json.JSONDecodeError as e:
@@ -408,9 +551,9 @@ def get_collection_stats():
         total_runs = db.query(CollectionRun).count()
         total_posts = db.query(Post).count()
         total_disasters = db.query(Disaster).count()
-        
+
         recent_runs = db.query(CollectionRun).order_by(CollectionRun.started_at.desc()).limit(5).all()
-        
+
         return {
             "total_runs": total_runs,
             "total_posts": total_posts,
@@ -431,3 +574,116 @@ def get_collection_stats():
         raise e
     finally:
         db.close()
+
+
+def calculate_next_run_time(schedule_hours: int = None) -> datetime:
+    """Calculate the next scheduled run time based on the schedule
+
+    Args:
+        schedule_hours: Hours between runs (default: from env var SCHEDULE_HOURS or 8)
+
+    Returns:
+        datetime object for the next scheduled run
+    """
+    if schedule_hours is None:
+        schedule_hours = int(os.getenv("SCHEDULE_HOURS", "8"))
+
+    now = datetime.utcnow()
+    current_hour = now.replace(minute=0, second=0, microsecond=0)
+    remainder = now.hour % schedule_hours
+
+    if remainder == 0:
+        next_run = current_hour + timedelta(hours=schedule_hours)
+    else:
+        hours_until_next = schedule_hours - remainder
+        next_run = current_hour + timedelta(hours=hours_until_next)
+
+    if next_run <= now:
+        next_run = next_run + timedelta(hours=schedule_hours)
+
+    return next_run
+
+
+def update_data_feed_status(
+    feed_name: str = "Bluesky Crisis Monitor", feed_type: str = "bluesky"
+):
+    """Update DataFeed record with last_run_at and next_run_at timestamps
+
+    Args:
+        feed_name: Name of the data feed (default: "Bluesky Crisis Monitor")
+        feed_type: Type of feed (default: "bluesky")
+    """
+    db = SessionLocal()
+    try:
+        feed = db.query(DataFeed).filter(DataFeed.name == feed_name).first()
+
+        if not feed:
+            feed = DataFeed(
+                name=feed_name,
+                feed_type=feed_type,
+                status="active",
+                last_run_at=None,
+                next_run_at=None,
+                total_runs=0,
+            )
+            db.add(feed)
+
+        now = datetime.utcnow()
+        feed.last_run_at = now
+        feed.total_runs += 1
+
+        schedule_hours = int(os.getenv("SCHEDULE_HOURS", "8"))
+        feed.next_run_at = calculate_next_run_time(schedule_hours)
+        feed.updated_at = now
+
+        db.commit()
+        db.refresh(feed)
+        print(
+            f"✅ Updated DataFeed: last_run={feed.last_run_at}, next_run={feed.next_run_at}"
+        )
+
+    except Exception as e:
+        db.rollback()
+        print(f"⚠️ Failed to update DataFeed status: {e}")
+        raise e
+    finally:
+        db.close()
+
+
+def ensure_data_feed_initialized(
+    feed_name: str = "Bluesky Crisis Monitor", feed_type: str = "bluesky"
+):
+    """Ensure DataFeed record exists with calculated next_run_at even if task hasn't run yet
+
+    Args:
+        feed_name: Name of the data feed (default: "Bluesky Crisis Monitor")
+        feed_type: Type of feed (default: "bluesky")
+    """
+    db = SessionLocal()
+    try:
+        feed = db.query(DataFeed).filter(DataFeed.name == feed_name).first()
+
+        schedule_hours = int(os.getenv("SCHEDULE_HOURS", "8"))
+
+        if not feed:
+            feed = DataFeed(
+                name=feed_name,
+                feed_type=feed_type,
+                status="active",
+                last_run_at=None,
+                next_run_at=calculate_next_run_time(schedule_hours),
+                total_runs=0,
+            )
+            db.add(feed)
+            db.commit()
+            print(f"✅ Initialized DataFeed: next_run={feed.next_run_at}")
+        elif feed.next_run_at is None:
+            feed.next_run_at = calculate_next_run_time(schedule_hours)
+            db.commit()
+            print(f"✅ Updated DataFeed next_run: {feed.next_run_at}")
+
+    except Exception as e:
+        db.rollback()
+        print(f"⚠️ Failed to initialize DataFeed: {e}")
+    finally:
+        db.close()
diff --git a/server/services/geocoding_service.py b/server/services/geocoding_service.py
new file mode 100644
index 0000000..c4330fe
--- /dev/null
+++ b/server/services/geocoding_service.py
@@ -0,0 +1,81 @@
+import os
+import requests
+import logging
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
+
+
+def geocode_region(query: str) -> Optional[dict]:
+    """
+    Geocode a region name to get its coordinates and bounds.
+    
+    Returns dict with:
+    - name: formatted place name
+    - lat: center latitude
+    - lng: center longitude  
+    - bounds: {ne_lat, ne_lng, sw_lat, sw_lng} for the region
+    - place_id: Google place ID
+    """
+    if not GOOGLE_API_KEY:
+        logger.error("GOOGLE_API_KEY not configured")
+        return None
+    
+    try:
+        url = "https://maps.googleapis.com/maps/api/geocode/json"
+        params = {
+            "address": query,
+            "key": GOOGLE_API_KEY,
+        }
+        
+        response = requests.get(url, params=params, timeout=10)
+        response.raise_for_status()
+        data = response.json()
+        
+        if data.get("status") != "OK" or not data.get("results"):
+            logger.warning(f"Geocoding failed for '{query}': {data.get('status')}")
+            return None
+        
+        result = data["results"][0]
+        geometry = result.get("geometry", {})
+        location = geometry.get("location", {})
+        
+        region_data = {
+            "name": result.get("formatted_address", query),
+            "lat": location.get("lat"),
+            "lng": location.get("lng"),
+            "place_id": result.get("place_id"),
+        }
+        
+        # Get bounds if available (for regions like states/countries)
+        bounds = geometry.get("bounds") or geometry.get("viewport")
+        if bounds:
+            region_data["bounds"] = {
+                "ne_lat": bounds["northeast"]["lat"],
+                "ne_lng": bounds["northeast"]["lng"],
+                "sw_lat": bounds["southwest"]["lat"],
+                "sw_lng": bounds["southwest"]["lng"],
+            }
+        
+        return region_data
+        
+    except requests.RequestException as e:
+        logger.error(f"Geocoding request failed: {e}")
+        return None
+    except (KeyError, TypeError) as e:
+        logger.error(f"Error parsing geocoding response: {e}")
+        return None
+
+
+def is_point_in_bounds(lat: float, lng: float, bounds: dict) -> bool:
+    """Check if a point falls within region bounds."""
+    if not bounds or lat is None or lng is None:
+        return False
+    
+    return (
+        bounds["sw_lat"] <= lat <= bounds["ne_lat"] and
+        bounds["sw_lng"] <= lng <= bounds["ne_lng"]
+    )
+
diff --git a/server/services/population_estimator.py b/server/services/population_estimator.py
index 5d53b11..724bd8f 100644
--- a/server/services/population_estimator.py
+++ b/server/services/population_estimator.py
@@ -1,26 +1,29 @@
 import math
 import os
-from typing import Optional, Tuple
+from typing import Optional
 from sqlalchemy.orm import Session
 from db_utils.db import Disaster
 import requests
 from dotenv import load_dotenv
+
 load_dotenv()
-import os
 
-GEONAMES_USERNAME = os.getenv("GEONAMES_USERNAME")
+GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
 
 
 class PopulationEstimator:
     """Estimate affected population based on various factors"""
 
-    # Base estimates by disaster type and severity
+    # Base estimates by disaster type and severity (matches DISASTER_CONFIG)
     BASE_ESTIMATES = {
         "earthquake": {5: 50000, 4: 10000, 3: 2000, 2: 500, 1: 100},
         "flood": {5: 30000, 4: 8000, 3: 1500, 2: 400, 1: 80},
-        "fire": {5: 20000, 4: 5000, 3: 1000, 2: 200, 1: 50},
+        "wildfire": {5: 20000, 4: 5000, 3: 1000, 2: 200, 1: 50},
         "hurricane": {5: 100000, 4: 25000, 3: 5000, 2: 1000, 1: 200},
         "tornado": {5: 15000, 4: 4000, 3: 800, 2: 150, 1: 30},
+        "tsunami": {5: 100000, 4: 30000, 3: 8000, 2: 1500, 1: 300},
+        "volcano": {5: 50000, 4: 15000, 3: 3000, 2: 600, 1: 100},
+        "heatwave": {5: 500000, 4: 100000, 3: 20000, 2: 5000, 1: 1000},
         "default": {5: 10000, 4: 5000, 3: 1000, 2: 200, 1: 50},
     }
 
@@ -38,50 +41,53 @@ def calculate_impact_radius_km(severity: int, disaster_type: str = None) -> floa
         radius = base_radius.get(severity, 10)
 
         # Adjust by disaster type
-        if disaster_type == "earthquake":
-            radius *= 1.5
-        elif disaster_type == "hurricane":
-            radius *= 2.0
-        elif disaster_type == "fire":
-            radius *= 0.5
+        type_multipliers = {
+            "earthquake": 1.5,
+            "hurricane": 2.0,
+            "wildfire": 0.5,
+            "tsunami": 2.5,
+            "volcano": 1.0,
+            "heatwave": 3.0,  # Heatwaves affect large areas
+            "flood": 1.2,
+            "tornado": 0.3,  # Tornadoes have narrow paths
+        }
 
-        return radius
+        multiplier = type_multipliers.get(disaster_type, 1.0)
+        return radius * multiplier
 
     @staticmethod
     def estimate_population(
-        longitude: int,
-        latitude: int,
+        longitude: float = None,
+        latitude: float = None,
         disaster_type: str = None,
-        severity: int = 3
+        severity: int = 3,
     ) -> Optional[int]:
         """
-        Estimate affected population for a disaster
+        Estimate affected population for a disaster.
+
         Priority:
-        1. Use existing affected_population if available
-        2. Calculate based on coordinates and radius (TODO: integrate with population API)
-        3. Fall back to severity-based estimates
+        1. Query Google Places API for nearby population data
+        2. Fall back to severity-based estimates
         """
-        # If coordinates available and GeoNames configured, query population API
-        if GEONAMES_USERNAME and longitude is not None and latitude is not None and severity is not None and disaster_type is not None:
+        # Normalize inputs
+        disaster_type = (disaster_type or "default").lower()
+        severity = severity if severity and 1 <= severity <= 5 else 3
+
+        # Try Google Places API if configured and we have coordinates
+        if GOOGLE_API_KEY and longitude is not None and latitude is not None:
             try:
                 radius = PopulationEstimator.calculate_impact_radius_km(
                     severity, disaster_type
                 )
-                population = PopulationEstimator.query_population_in_radius(
+                population = PopulationEstimator.query_population_google(
                     latitude, longitude, radius
                 )
                 if population and population > 0:
                     return int(population)
             except Exception as e:
-                # If external lookup fails, fall back to base estimates
-                print(f"⚠️ GeoNames lookup failed: {e}")
-        else:
-            return None
+                print(f"⚠️ Google population lookup failed: {e}")
 
         # Fall back to base estimates
-        disaster_type = (disaster_type or "default").lower()
-        severity = severity or 3
-
         estimates = PopulationEstimator.BASE_ESTIMATES.get(
             disaster_type,
             PopulationEstimator.BASE_ESTIMATES["default"]
@@ -90,45 +96,163 @@ def estimate_population(
         return estimates.get(severity, 1000)
 
     @staticmethod
-    def query_population_in_radius(lat: float, lon: float, radius_km: float) -> Optional[int]:
-        """Query GeoNames for nearby populated places and sum their populations.
+    def query_population_google(
+        lat: float, lon: float, radius_km: float
+    ) -> Optional[int]:
+        """Get population using Google reverse geocoding + Data Commons API.
 
-        Uses GEONAMES_USERNAME from environment. Returns sum of populations (ints) or None on failure.
+        1. Use Google Geocoding to get city/region name from coordinates
+        2. Query Data Commons API (free) for real census population data
         """
-        url = "http://api.geonames.org/findNearbyJSON"
-        params = {
-            "lat": lat,
-            "lng": lon,
-            "radius": int(max(1, round(radius_km))),
-            "featureClass": "P",
-            "maxRows": 100,
-            "username": GEONAMES_USERNAME,
-        }
+        if not GOOGLE_API_KEY:
+            return None
+
+        try:
+            # Step 1: Reverse geocode to get location name
+            geocode_url = "https://maps.googleapis.com/maps/api/geocode/json"
+            params = {
+                "latlng": f"{lat},{lon}",
+                "key": GOOGLE_API_KEY,
+                "result_type": "locality|administrative_area_level_2|administrative_area_level_1",
+            }
+
+            resp = requests.get(geocode_url, params=params, timeout=10)
+            resp.raise_for_status()
+            data = resp.json()
+
+            if data.get("status") != "OK" or not data.get("results"):
+                return None
+
+            # Extract location components
+            result = data["results"][0]
+            components = result.get("address_components", [])
+
+            city = None
+            region = None
+            country = None
+            country_code = None
+
+            for comp in components:
+                types = comp.get("types", [])
+                if "locality" in types:
+                    city = comp.get("long_name")
+                elif "administrative_area_level_1" in types:
+                    region = comp.get("long_name")
+                elif "country" in types:
+                    country = comp.get("long_name")
+                    country_code = comp.get("short_name")
+
+            # Step 2: Query population database
+            # Try city first, then region (for places like Tokyo where locality is a ward)
+            population = None
+
+            if city:
+                population = PopulationEstimator._query_world_cities_population(
+                    city, country_code
+                )
+
+            # If city lookup failed, try region (e.g., "Tokyo" when locality is "Suginami City")
+            if not population and region:
+                population = PopulationEstimator._query_world_cities_population(
+                    region, country_code
+                )
+
+            if population:
+                # Adjust based on impact radius vs city size
+                city_radius_estimate = 15  # Assume avg city is ~15km radius
+                if radius_km < city_radius_estimate:
+                    adjustment = (radius_km / city_radius_estimate) ** 2
+                    population = int(population * adjustment)
+
+                return max(population, 100)
+
+            return None
+
+        except Exception as e:
+            print(f"⚠️ Error in Google population lookup: {e}")
+            return None
+
+    @staticmethod
+    def _query_data_commons(city: str, region: str, country_code: str) -> Optional[int]:
+        """Query Google Data Commons API for real population data (free, no key needed)."""
+        if not city and not region:
+            return None
+
+        try:
+            # Data Commons API endpoint
+            url = "https://api.datacommons.org/v2/observation"
+
+            # Build the place query - try city first, then region
+            search_term = f"{city}, {region}" if city else region
+            if country_code:
+                search_term += f", {country_code}"
+
+            # First, resolve the place name to a DCID
+            resolve_url = "https://api.datacommons.org/v2/resolve"
+            resolve_params = {"nodes": [search_term], "property": "<-description"}
+
+            # Try a simpler approach - use the node search
+            search_url = "https://api.datacommons.org/v2/node"
+
+            # Actually, Data Commons requires specific DCIDs which are hard to get
+            # Let's use a simpler population database approach
+
+            # Use OpenDataSoft's world cities population API (free)
+            pop = PopulationEstimator._query_world_cities_population(city, country_code)
+            if pop:
+                return pop
+
+            return None
+
+        except Exception as e:
+            print(f"⚠️ Data Commons query failed: {e}")
+            return None
+
+    @staticmethod
+    def _query_world_cities_population(
+        city: str, country_code: str = None
+    ) -> Optional[int]:
+        """Query world cities population database (free API)."""
+        if not city:
+            return None
 
         try:
+            # Use OpenDataSoft's geonames cities dataset (free, no key)
+            url = "https://public.opendatasoft.com/api/records/1.0/search/"
+            params = {
+                "dataset": "geonames-all-cities-with-a-population-1000",
+                "q": city,
+                "rows": 5,
+            }
+
+            if country_code:
+                params["refine.country_code"] = country_code
+
             resp = requests.get(url, params=params, timeout=10)
             resp.raise_for_status()
             data = resp.json()
-            geonames = data.get("geonames", [])
-            total_pop = 0
-            for g in geonames:
-                pop = g.get("population")
-                try:
-                    if pop is None:
-                        continue
-                    p = int(pop)
-                except Exception:
-                    # population may be string or non-numeric
-                    try:
-                        p = int(float(pop))
-                    except Exception:
-                        p = 0
-                if p > 0:
-                    total_pop += p
-
-            return total_pop if total_pop > 0 else None
+
+            records = data.get("records", [])
+            if records:
+                # Get the most populated matching city
+                max_pop = 0
+                for record in records:
+                    fields = record.get("fields", {})
+                    pop = fields.get("population", 0)
+                    name = fields.get("name", "").lower()
+
+                    # Check if city name matches
+                    if city.lower() in name or name in city.lower():
+                        if pop > max_pop:
+                            max_pop = pop
+
+                if max_pop > 0:
+                    return max_pop
+
+            return None
+
         except Exception as e:
-            print(f"⚠️ Error querying GeoNames: {e}")
+            print(f"⚠️ World cities query failed: {e}")
             return None
 
     @staticmethod
diff --git a/server/tasks.py b/server/tasks.py
index fb22253..d46416e 100644
--- a/server/tasks.py
+++ b/server/tasks.py
@@ -4,11 +4,12 @@
 from services.bluesky import fetch_posts
 from services.analysis import analyze_posts, analyze_sentiment
 from services.database_service import (
-    create_collection_run, 
-    complete_collection_run, 
-    save_posts, 
+    create_collection_run,
+    complete_collection_run,
+    save_posts,
     save_analysis,
-    get_existing_post_ids
+    get_existing_post_ids,
+    update_data_feed_status,
 )
 from services.archive_service import ArchiveService
 from services.alert_generator import generate_alerts as generate_alerts_service
@@ -26,10 +27,13 @@
 # Disaster type configuration with hashtags
 DISASTER_CONFIG: Dict[str, List[str]] = {
     "earthquake": ["#earthquake", "#quake", "#seismic"],
-    "hurricane": ["#hurricane", "#cyclone", "#tropicalstorm"],
+    "hurricane": ["#hurricane", "#cyclone", "#typhoon", "#tropicalstorm"],
     "flood": ["#flood", "#flooding", "#flashflood"],
     "wildfire": ["#wildfire", "#forestfire", "#bushfire"],
-    "tornado": ["#tornado", "#twister"]
+    "tornado": ["#tornado", "#twister"],
+    "tsunami": ["#tsunami"],
+    "volcano": ["#volcano", "#eruption", "#volcaniceruption"],
+    "heatwave": ["#heatwave", "#extremeheat", "#heatdome"],
 }
 
 
@@ -51,7 +55,7 @@ def collect_and_analyze(include_enhanced: bool = True):
     """
     start_time = time.time()
     task_name = "collect_and_analyze"
-    
+
     print(f"\n{'='*50}")
     print(f"Starting Multi-Disaster BlueSky collection - {datetime.now()}")
     if include_enhanced:
@@ -151,6 +155,8 @@ def collect_and_analyze(include_enhanced: bool = True):
 
         complete_collection_run(run.id, total_saved, "completed")
 
+        update_data_feed_status()
+
         print(f"\n[{datetime.now()}] Multi-Disaster job completed successfully!")
 
         # Return detailed results
@@ -179,7 +185,7 @@ def collect_and_analyze(include_enhanced: bool = True):
                 result=results,
             )
         )
-        
+
         # Log data collection metrics
         loop.run_until_complete(
             logging_service.log_data_collection(
@@ -198,8 +204,12 @@ def collect_and_analyze(include_enhanced: bool = True):
     except Exception as e:
         error_msg = f"Error in multi-disaster collection: {str(e)}"
         complete_collection_run(run.id, 0, "failed", error_msg)
+        try:
+            update_data_feed_status()
+        except Exception as update_error:
+            print(f"⚠️ Failed to update feed status: {update_error}")
         print(f"\n[{datetime.now()}] {error_msg}")
-        
+
         # Log task failure
         duration_ms = int((time.time() - start_time) * 1000)
         loop.run_until_complete(
@@ -210,7 +220,7 @@ def collect_and_analyze(include_enhanced: bool = True):
                 error=str(e),
             )
         )
-        
+
         raise