Skip to content

NASA · 2017–2025

Flood Mapping System

Near real-time flood inundation mapping from satellite data — built so disaster responders get trustworthy products in hours, without overnight engineering heroics.

On this page
  1. Snapshot
  2. Platform
  3. Overview
  4. Problem
  5. Decisions
  6. Outcome
  7. Team & leadership
  8. Operational Context
  9. System Architecture
  10. Engineering Trade-offs
  11. Operational Discipline
  12. Related

Platform

  1. 01 · Source

    Containerized stages

    Each imagery transformation is a containerized task runner, not a snowflake workstation.

    Git Docker

  2. 02 · Verify

    Flood regression gates

    Pipeline changes must pass automated tests against known flood extents before they ship.

    CI

  3. 03 · Deploy

    Same pipeline, every env

    The processing chain is deployable and recoverable across environments, not a local hero path.

    AWS Containers

  4. 04 · Operate

    Ingest to dissemination

    Sensor packets become OGC products for responders without overnight engineering heroics.

    Event-driven

Commit → gates → same pipeline in every environment

Outcome

Near real-time flood inundation maps during active disaster events worldwide — latency measured in hours, not overnight queues.

Role

Architect & lead developer — designed and automated the end-to-end geospatial pipeline on AWS.

Problem

  • Manual processing steps sat on the critical path — flood products lagged during active global disaster events when hours mattered.
  • Sensor acquisition → product generation → dissemination crossed teams and environments with fragile handoffs.
  • Emergency-management users needed repeatable, trustworthy maps — not one-off runs that only the on-call engineer could reproduce.

Decisions

  • Automate end-to-end from raw sensor ingestion through geospatial product generation — remove humans from the latency path under urgency.
  • Containerize processing stages so the same pipeline is deployable and recoverable across environments, not a snowflake workstation.
  • Integrate outputs with emergency-management and research distribution networks so “done” means disseminated, not merely generated.

Outcome

  • Near real-time flood inundation maps during active disaster events worldwide — latency measured in hours, not overnight queues.
  • Fewer manual handoffs under urgency — consistency came from the pipeline, not who was awake.
  • Supported peer-reviewed research on global water and flood mapping (GeoHorizons).

Team & leadership

Leadership mode
Technical lead for a mission-critical geospatial pipeline
Team & partners
~4 engineers and science partners, plus emergency-management users from sensor acquisition through global dissemination
What I unblocked
Removed manual handoffs that forced late-night heroics during active disaster events.
Hard decision
Prioritized automation and fault tolerance over ad-hoc speed — latency dropped because the team system was reliable under urgency.

Operational Context

When a cyclone makes landfall or an inland reservoir breaches, emergency management organizations — including FEMA, the Red Cross, UN-SPIDER, and regional civil protection agencies — require verified surface water extents immediately. Every four-hour operational briefing window without actionable flood extents is a window where evacuation routing and relief logistics operate blind.

Historically, satellite-derived flood mapping was hindered by manual interventions:

  1. Operators waited for polar-orbiting downlinks to land in file directories.
  2. Scientists ran desktop GIS scripts on dedicated workstations with bespoke projection libraries.
  3. Quality checks required visual cloud-mask inspection before an engineer manually uploaded GeoTIFFs to distribution servers.

During major activations, this workflow required around-the-clock staffing and sleepless heroics. If a processing script threw an unhandled exception at 2:00 AM on tile 47 of 120, the entire batch stalled until morning.

My mandate as architect and lead developer was clear: eliminate human intervention from the critical latency path. The system had to ingest raw sensor packets, calibrate imagery, detect surface water at >90% statistical accuracy, and syndicate OGC-compliant GIS products to responder endpoints automatically within hours of satellite downlink.

System Architecture

The platform was architected on AWS as an event-driven, decoupled processing pipeline. Rather than maintaining heavy, long-running monolithic servers, each stage of imagery transformation was isolated into containerized task runners managed by deterministic work queues.

01 · INGESTION Sensor Stream MODIS / VIIRS / Planet Event Trigger S3 Put → SNS Notification Backpressure Queue 02 · CALIBRATION Radiometric Correction Sun angle & atmospheric Terrain Orthorectify SRTM / DEM alignment Cloud & Shadow Mask 03 · DETECTION Water Detection Core >90% Validation Accuracy Hydro Baseline Diff Normal water vs flood extent Polygon Vectorization 04 · DISSEMINATION Cloud-Optimized GeoTIFF S3 Tiering & Range Reads Web Map / Tile Server OGC WMS / WMTS API Responder Feeds (FEMA/UN)
Figure 1: Automated Satellite Ingestion to Multi-Agency Dissemination Architecture

Pipeline Stages

  1. Autonomous Ingestion & Event Demuxing: As downlinked raw files arrive in staging S3 buckets from NASA ground stations and commercial providers, Amazon SNS broadcasts granular tile events to SQS queues. This decoupled message broker absorbs burst downlinks without dropping work or overwhelming downstream processors.
  2. Containerized Geospatial Transformation: Stateless Python worker containers running GDAL, Rasterio, and NumPy scale on demand. Workers pull tasks, apply radiometric correction, orthorectify sensor angles against digital elevation models (SRTM), and generate calibrated multi-spectral reflectance arrays.
  3. Dynamic Water Indexing & Baseline Differencing: The algorithms isolate surface water signatures using spectral band ratios (such as NDWI and MNDWI) paired with automated cloud and terrain-shadow masking. The detected water masks are then compared against permanent water baselines (Global Surface Water / HydroLAKES) to distinguish normal river channels from active flood inundation.
  4. Vectorization & Cloud-Optimized Product Delivery: The resulting raster inundation masks are translated into both Cloud-Optimized GeoTIFFs (COG) for remote GIS range reads and GeoJSON/Shapefile vector polygons for tactical emergency management platforms.

Engineering Trade-offs

Designing a platform that runs without human intervention during natural disasters required choosing boring, resilient architectural primitives over fragile complexity:

1. Isolated Task Containers vs. Monolithic Workflow Engine

  • Trade-off: We avoided large, centralized orchestration engines that maintain complex state machines. Instead, each granule transformation is a single idempotent container execution governed by SQS visibility timeouts.
  • Why it matters: If an uncalibrated satellite granule contains corrupted metadata or atypical optical artifacts, only that specific granule fails and routes to a dead-letter queue (DLQ) with attached telemetry. The remainder of the orbital pass continues processing uninterrupted.

2. Cloud-Optimized GeoTIFFs (COGs) vs. Dynamic Tile Slicing

  • Trade-off: Generating pre-rendered map tile pyramids for every zoom level at scale creates astronomical file counts and storage churn.
  • Why it matters: Standardizing on Cloud-Optimized GeoTIFFs with internal overviews allows client map viewers and responder GIS systems to fetch only the byte ranges needed for their current viewport via HTTP range requests. Storage costs dropped dramatically, and product availability was instantaneous upon file write.

3. Graceful Partial Delivery vs. All-or-Nothing Orbit Mosaics

  • Trade-off: Downlinks occasionally experience optical dropout, sensor scanline gaps, or dense regional cloud cover.
  • Why it matters: Rather than blocking an entire regional release waiting for 100% cloud-free mosaic coverage, the pipeline generates partial inundation tiles immediately, tagging each tile with a machine-readable data-quality confidence index. Responders receive an 80% clear view in hour two rather than waiting eight hours for perfection.

Operational Discipline

Technical architecture is only half the equation; mission-critical software succeeds or fails based on operational discipline:

  • Automated Validation Gates: Water detection algorithms were continuously benchmarked against historical ground-truth flood datasets. Any pipeline modification required automated regression testing against known flood extents to verify that water classification accuracy remained above 90%.
  • Peer-Reviewed Scientific Provenance: The system’s methodology, validation rigor, and operational throughput were published in GeoHorizons (The Geological Society / AGU, May 2026: A web-based high-resolution global water and flood mapping platform), demonstrating that operational software engineering can meet the highest standards of scientific peer review.
  • Culture of Sustainable Delivery: By replacing manual, hero-dependent releases with a resilient, automated CI/CD and telemetry stack, the engineering and science teams transitioned from exhausting all-night emergency shifts to calm, proactive operational oversight.