Who is this for?: Local disaster managers, NGO safety teams, community leaders, park staff, and small operations teams working with basic web tools.

Prerequisites: Web browser; one shared communications channel (WhatsApp group, SMS tree, radio contact list); basic spreadsheet skills.

Data & Tools:

• Fire detections: NASA FIRMS alerts and map view. (Sign up for alerts using the "Fire Alerts" menu option on the FIRMS site)
• Optional Global Forest Watch fire alerts/Forest Watcher app for an alternate alert stream
• Fire danger and wind outlook: global Copernicus Climate Data Store Fire Weather Index forecasts, or the Global Wildfire Information System viewer.
• Smoke confirmation and smoke impacts:
  • NOAA Hazard Mapping System Fire and Smoke map (U.S., Canada, Mexico).
  • ECMWF CAMS smoke forecasts (global), plus NOAA HRRR-Smoke (U.S.).
  • Optional visual confirmation: ALERTWildfire cameras (where available - Western US Only).
• A shared incident log (Google Sheet or Excel).

Instructions:

1. Define the AOI and one trigger rule.
   Write the AOI and your alert rule in plain language at the top of your incident log. Keep it stable during a season. A simple rule works: “Log every detection in the AOI. Notify partners when detections are within X km of a settlement or critical site. Escalate when detections persist across multiple checks, cluster grows, or conditions are high-risk.”

2. Set up automated alerts (this is the core of the how-to).
   In NASA FIRMS, subscribe to alerts for your AOI so detections arrive by email automatically. Choose CSV as your default attachment format so it can go straight into your log. FIRMS supports AOI-based alert emails and also provides downloads and an API if you move toward automation later.

3. When an alert arrives, do a 60-second “what happened” read.
   Open the CSV. Record: detection time, number of points, confidence, and FRP if present. FRP is a quick intensity signal, it is useful for comparing points and spotting growth, but it is not a perimeter.
   Then open the FIRMS map and answer two questions only: is it a single point or a cluster, and is it near anything that matters.

4. Add fire danger context using Fire Weather Index in one simple way.
   Your package includes Global Fire Weather Index forecasts. FWI combines temperature, humidity, wind, and recent rain into indices that reflect fuel dryness and potential fire behavior.
   For a non-technical workflow, do not chase the exact numbers. Use FWI as a “risk dial” and focus on trend:

   • Look at today and the next 2 to 3 days for your AOI.
   • Write one line in the log: “FWI rising,” “FWI steady,” or “FWI falling,” plus the day it peaks.
   • Use that line to justify actions like pre-positioning, staffing, or increasing monitoring. This is exactly how FWI is meant to support early warning, not just reaction after ignition.
5. If you want one step more interpretation without becoming technical, use the common FWI “building blocks” as plain-language clues:
   • FFMC relates to how easily fine fuels ignite and how quickly surface fuels dry.
   • ISI relates to likely spread speed, strongly influenced by wind.
   • BUI relates to how much fuel is available, driven by longer-term dryness.
   • FWI combines ISI and BUI into overall potential intensity.
     You do not need to compute anything. You are using these as labels to understand what kind of day it is: ignition-prone, fast-spread, deep-dry, or all three.
6. Run a smoke step that matches your region and your purpose.

   Smoke is often the first impact that reaches people far from the fire.
   Choose one path:

   A) If your AOI is in the U.S., Canada, or Mexico:
   Open the NOAA Hazard Mapping System Fire and Smoke map. It includes analyst-drawn smoke polygons labeled light, medium, heavy.
   How to interpret it in operations terms:

   • Light smoke means haze is present and visibility can degrade. Sensitive groups may feel it.

   • Medium smoke means broad nuisance and likely health impacts for sensitive groups. Plan messaging to clinics and schools.

   • Heavy smoke means serious impacts are likely. This is when you consider protective actions and extra health messaging, especially for shelters and camps.

   B) If your AOI is outside North America, or you need a forecast (not just today’s plume):
   Use CAMS smoke forecasts for surface PM2.5 concentration where possible. Your package points to CAMS and GFAS as global options and notes these come as gridded concentrations.
   Interpretation for non-technical users should be tied to action thresholds. A practical approach is to translate forecast PM2.5 into AQI-style categories. EPA’s updated PM2.5 breakpoints give a clear mapping for 24-hour PM2.5 ranges, which are widely used for public messaging.
   You do not need to compute an AQI number. You can just use the ranges as triggers:

   • “Good”: 0.0 to 9.0 µg/m³
   • “Moderate”: 9.1 to 35.4 µg/m³
   • “Unhealthy for Sensitive Groups”: 35.5 to 55.4 µg/m³
   • “Unhealthy”: 55.5 to 125.4 µg/m³
7. If the forecast crosses “Unhealthy for Sensitive Groups” for a populated downwind area, that is enough to justify a health advisory message and targeted outreach.

8. Send the alert message using a fixed template.
   Keep it short and consistent. Include: location, detection time, verification status, fire danger trend, smoke risk (if relevant), and next update time.
   Example structure (write it in your own voice):
   “Wildfire detection in [place], detected [time] by satellite. Cluster size: [small/moderate/large]. Fire danger: FWI [rising/steady/falling], peak expected [day]. Smoke: [none/light/medium/heavy] expected toward [downwind area] in next [24h]. Next update at [time].”

9. Log outcomes and tune, do not guess.
   Record whether it was real, false, or unknown. Over a few weeks you will learn what your AOI treats as “normal heat sources” and you can tighten rules without losing true fires.

Outputs: AOI-based automatic alerts, an incident log, consistent messages, and simple risk context (fire danger and smoke).

Validation & QA: Track false alarms and missed incidents. If trust suffers due to false alarms, require persistence across two alert cycles before escalating. If you miss important fires, increase monitoring during high and rising FWI periods.

Maintenance: Update contact lists monthly during fire season. Keep the AOI and trigger rule stable, refine only based on the log.

Risks & Considerations: FWI is a model-based indicator and best used as relative risk unless calibrated locally. Smoke forecasts depend on fire detection inputs and can under-predict early in an event.

Who is this for? : Small GIS teams, analysts, information management staff, and researchers supporting operations.

Prerequisites: A detection location from How-To 1 and one mapping tool (QGIS, ArcPro, Felt, Google Earth, etc.).

Data & Tools:

• Buildings and facilities: OpenStreetMap building footprints and key POIs (Download using the HotOSM exporter tool. You can specify an AOI or shapefile for download. You will need to first create a free account).
• Population: WorldPop raster for exposure estimates.
• Fuels and land cover: ESA WorldCover for a quick fuels proxy.
• Conditions: Global FWI forecasts for near-term risk context.
• Smoke impacts: NOAA HMS (North America) or CAMS forecasts (global).

Instructions:

1. Define the incident analysis area in an operational way.
   Use two buffers and one downwind corridor. Buffers answer “what is close.” The corridor answers “where concern should focus next.” Keep corridor length tied to conditions.

2. Use FWI to decide how aggressive your corridor should be.
   Do not use FWI as a prediction of spread. Use it to decide whether you should be conservative or urgent.

   • If FWI is low and falling, keep the corridor shorter and update less often.

   • If FWI is high and rising, make the corridor longer, increase update frequency, and widen the list of assets you flag.
     If you have access to ISI, treat high ISI days as “fast-spread days,” because ISI is the part of the system that responds strongly to wind and fine-fuel dryness.

3. Pull buildings and critical facilities and check completeness.
   Download OpenStreetMap buildings for the analysis area and spot-check against imagery for one known settlement. If buildings are sparse where you know people live, label the layer as incomplete and rely more heavily on WorldPop.

4. Generate an exposure table that can be read aloud.
   Count buildings inside your near and mid buffers (Most GIS software will allow you to quickly generate an AOI by drawing a polygon or buffering a point. You can then load the OSM features and use a "Select by Intersection" tool to select and count all features within your AOI). List any clinics, schools, camps, and power or water infrastructure inside the near buffer. Then sum population from WorldPop inside the same buffers and report rounded numbers.

5. Add a fuels read using WorldCover that stays simple.
   Classify land cover into “burnable vegetation” and “mostly non-burnable.” You are not making a scientific fuels model. You are answering one question: is there continuous vegetation connecting the detection area to exposed assets, or is fuels continuity broken. That single sentence is usually more useful than a map legend.

6. Add smoke impact the same way you added fire danger.
   Smoke is often the fastest cross-border hazard. Your package includes a global fire and smoke product description that explicitly calls out CAMS and HRRR-Smoke.
   Produce one short output:

   • A downwind “smoke concern zone” for the next 24 hours.

   • A flag for whether the smoke is likely nuisance, sensitive-groups concern, or broad concern.
     Use NOAA HMS light, medium, heavy categories in North America.
     Use CAMS surface PM2.5 bands as triggers elsewhere, with the simple AQI-range mapping from EPA breakpoints.

7. Publish two things only: one map and one table.
   Map: detections, buffers, corridor, key assets, and a smoke concern overlay if relevant.
   Table: buildings and critical facilities in buffers, population in buffers, top downwind assets, and a one-line note on FWI trend and smoke concern.

Outputs: A rapid exposure and assets summary, a fuels continuity note, a direction-of-concern corridor, and a smoke impact flag that can be communicated quickly.

Validation & QA: Confirm CRS units so buffers are correct. Confirm your wind direction convention is consistent. Spot-check OSM completeness per region. Keep language consistent so non-technical readers do not misinterpret the corridor as a forecast perimeter.

Maintenance: Keep a QGIS template and a short AOI note that records known data gaps and the preferred smoke product for that region.

Risks & Considerations: Exposure layers can be incomplete. Fuels proxies are not fire behavior models. Smoke models are sensitive to detection inputs and can lag real growth early in an event.

Audience: Technical GIS teams, analysts, researchers, and software-adjacent responders who want a repeatable pipeline that produces the same outputs every time.

Prerequisites: Google account for Colab; basic Python; comfort with CSV and GeoJSON; ability to create and store API keys securely.

Data & Tools:

• NASA FIRMS API for active fire detections (VIIRS and MODIS) and FIRMS email alerts (optional baseline)
• OpenStreetMap buildings and key POIs (via HotOSM Exporter or Overpass queries through OSMnx)
• WorldPop gridded population (pre-downloaded GeoTIFFs stored in Google Drive)
• ESA WorldCover land cover (pre-downloaded tiles stored in Google Drive)
• Optional: Copernicus FWI forecasts (via CDS or CEMS services)
• Optional: Smoke and winds via ECMWF CAMS and related Copernicus services; NOAA HRRR-Smoke for the U.S.
• One alert channel: email (SMTP), Slack webhook, Teams webhook, or an SMS provider account if SMS is required

Steps:

1. Create a new Colab notebook and install the minimum packages.
   In Colab, create a new notebook and install only what the workflow uses: GeoPandas for vector work, rasterio/rioxarray for rasters, OSMnx for OSM pulls, plus one mapping or output library if needed. Keep the first cell as “install and imports” so failures are obvious early.

2. Build a single configuration cell that controls the run.
   Put all incident inputs in one place: AOI (GeoJSON polygon or bounding box), lookback window (hours), confidence filter, buffer distances, file paths to WorldPop and WorldCover rasters in Drive, and the output folder name. This prevents editing logic cells during an incident.

3. Store credentials safely and fail early if they are missing.
   FIRMS requires a map key for API access and it should be stored as an environment variable, not pasted into the notebook body. Copernicus services typically require an API config file for cdsapi when used. Add a “credential check” cell that stops with a clear message if anything is missing.

4. Pull detections from FIRMS for the AOI and time window.
   Use the FIRMS API (the “area” workflow is common) to request VIIRS near-real-time detections for the AOI and load the CSV into pandas. Convert to a GeoDataFrame, filter by timestamp and confidence, and keep FRP fields for later prioritization. FIRMS also supports email alerts, which can be used as a backup channel even if the notebook is the primary workflow.

5. Turn detections into operational “impact zones.”
   Create buffer rings (2 km, 5 km, 10 km) around detections, dissolve into cluster zones, and output a clean GeoJSON for each ring. This becomes the common geometry used to intersect buildings, population, land cover, and any downwind corridor layer.

6. Add buildings and critical POIs from OpenStreetMap.
   Pull building footprints and selected POIs for the AOI (or just the 10 km union buffer if AOIs are large). Intersect with the buffer rings to compute counts by ring and generate a short list of nearest critical facilities. If Overpass times out, reduce the query area to the smallest geometry that still answers the operational question.

7. Add population exposure from WorldPop.
   Open the pre-downloaded WorldPop GeoTIFF in Drive, run zonal sums for each buffer ring, and store the results in a simple table. This is the fastest way to produce “people within 2/5/10 km” without waiting on downloads during an incident.

8. Add fuels proxy from ESA WorldCover.
   Clip WorldCover to each ring and compute a breakdown of class percentages. In the outputs, translate class codes into plain language, such as forest-heavy ring versus cropland-heavy ring, so responders understand why spread risk may differ across directions.

9. Optional context layers: FWI and smoke.
   For FWI, pull grids (FWI plus ISI and BUI if available), clip to AOI, and report simple summaries per ring: “FWI rising”, “peak in 48 hours”, plus whether the driver is wind-spread (ISI) or deep dryness (BUI). For smoke, use CAMS surface PM2.5 forecasts globally and HRRR-Smoke in the U.S. when needed, then translate concentrations into simple health concern levels for messaging.

10. Generate both decision outputs and public-safe alert text.
    Create three artifacts: detections GeoJSON, impact zones GeoJSON, and a one-page briefing summary in markdown or PDF. Then generate an alert message from a template that includes location, time window, nearest assets, population bands, and a short “FWI trend and smoke concern” line when used.

11. Automate alert delivery, not just the analysis.
    Pick one delivery method and implement it as a final notebook cell that runs only when triggers are met (for example, any high-confidence detection within 5 km of a facility, or population within 10 km above a threshold).

• • For email, send via an SMTP account to a distribution list and include the one-page summary plus a link to the map output.
  • For Slack or Teams, post the message and attach the key numbers, then link to the outputs stored in Drive or a shared folder.
  • For SMS, use an SMS provider API and keep the message under a strict character limit.
    Keep a second path: if using FIRMS email alerts as the baseline, the notebook can still run “on demand” to enrich those alerts with exposure and fuels context.

12. Schedule it in a way that actually runs.
    Colab sessions are not a dependable scheduler. When continuous monitoring is required, export the notebook logic into a Python script and schedule it with a reliable runner (a GitHub Actions cron job, a small cloud function, or a lightweight VM). The same config cell becomes a config file so the job can run unattended.

Outputs: Repeatable GeoJSON layers, a briefing-ready one-pager, and an automated alert message pushed to a real channel.

Validation & QA: Compare one known incident against a manual GIS run, confirm buffering units, confirm UTC versus local timestamps, and sanity-check smoke outputs against visible smoke products where available.

Maintenance: Version the notebook or script, refresh WorldPop and WorldCover on a planned cadence, and keep a “credential check” that fails loudly.

Risks & Considerations: API endpoints and terms can change; OSM completeness varies by region; model-based context layers (FWI, smoke) should be labeled as forecast or context, not truth.

Audience: GIS technicians or generalists with QGIS/ArcGIS skills; suitable for small teams that need quick maps when a fire breaks out, but don’t have specialized fire modeling software.

Prerequisites: QGIS (free) or ArcGIS; internet for data download; basic GIS operations knowledge (buffer, clip, join tables).

Data & tools:

• Active fire data (VIIRS/MODIS hotspots from FIRMS – can be added as live WMS or downloaded CSV)
• Satellite imagery for background or burn assessment (optional: recent Sentinel-2 or Landsat images via a plugin like SCP or Google Earth background)
• Administrative boundaries of your area (districts, villages – get from HDX or your government GIS).
• Population data (WorldPop raster or census data at admin level).
• Infrastructure layers if available (roads, towns, powerlines to annotate map).
• A QGIS project pre-loaded with above layers and styled.

Instructions:

1. Prepare a template project: In QGIS, load your base layers: admin boundaries (with names and populations if you have), a basemap (use QuickMapServices plugin for satellite or street basemap), and have a placeholder for fire data. Set up some styling in advance: e.g., fire hotspots as bright red dots with flame icon, label them with detection time; admin areas with transparent fill and labels of names. Save this as “WildfireBriefingTemplate.qgz.”
2. When a fire emerges, add current fire data: Options:
   • Easiest: download the latest FIRMS fire points around the area. On FIRMS website, you can draw a box or use their CSV/KML download for the last 24 hours in your country/region. Import that into QGIS.
   • Alternatively, use QGIS’s WMS/WMTS: FIRMS provides a tiled web map of fires, but you want the actual data to do analysis. So stick to download for analysis steps.
   • If the fire is large and has an official perimeter available (e.g., from InciWeb or Copernicus EMS), grab that (as GeoJSON/SHP) and add to QGIS – that’s even better for mapping extent. If not, you can create a provisional extent:
     • Use the hotspots: apply a convex hull or buffer around the cluster of fire points to approximate the affected area. For example, buffer each point by 1 km and merge, or take the convex hull of all points to get a polygon outline.
     • This is a crude fire perimeter proxy for early briefing. Clearly label it “estimated extent.”
3. Overlay context layers: Identify what’s inside or near that fire polygon:
   • Use Select by Location: select villages/settlements (from your admin layer or a gazetteer) within say 5 km of the fire polygon. Those are potentially impacted communities.
   • Use Zonal Statistics: if you have a population raster, calculate the sum of population within the fire polygon (or within a 5 km buffer of it). Alternatively, sum the population of the selected admin units from above – but be careful, if only part of a large admin is affected, don’t count all; perhaps report “X people in immediate area (within 5 km), Y total in affected county.”
   • Note key infrastructure in the polygon: are any major roads crossing it? If you have a roads layer, intersect it with the fire area to see length of road affected or if a particular highway name intersects (“Highway 8 runs through fire”). Do the same for power lines, etc.
4. Quick severity estimation (if imagery available): If the fire has been burning a few days, you might download a Sentinel-2 image (within QGIS use the Semi-Automatic Classification Plugin or EO Browser). Look for burn scar (charred ground is dark) – you can digitize a quick approximate burn area if obvious. If time is short or cloudy, skip this – reliance on hotspots and official perimeters is fine.
5. Produce the map: Design a clean layout:
   • Show the fire extent (polygon or points) in bright red/orange.
   • Mark nearby towns with labeled dots.
   • Include a north arrow, scale, and if possible, an inset map showing where in the country this is (for context).
   • Add a title, e.g., “Fire near [LocationName] – Situation Map [Date].”
   • If you computed exposure stats, include a small text box on the map: e.g., “~500 ha burned so far. ~1,200 people in 3 communities within 5 km. Highway 8 closed.” to summarize.
   • Export as PNG for slides/emails and PDF for high-quality prints.
6. Generate an impact summary table: Using the selections and stats:
   • List the names of communities likely affected, population, and distance to fire.
   • List any infrastructure impacted (“Power line X (33 kV) runs through fire zone”, “Park rangers station burnt”).
   • If possible, include any available containment info or response actions (this you get from news/agency update, not GIS). It gives full context (e.g., “Fire is 0% contained, spreading east towards ABC town.”).
   • Put this in a short Word doc or email to accompany the map.
7. Disseminate: These maps and stats can be used in daily briefings to stakeholders or for public information. Make sure to include source credits (satellite data © NASA, etc. – usually on the map layout or footnote).
8. Archive and iterate: Save the project as a new file (e.g., Fire_[location]_2025-11-03.qgz) so you can update it tomorrow. Update with new hotspot perimeters, etc., and version your maps (Map v1, v2…). This helps track the fire’s progression.

Outputs: A ready-to-share situation map (PNG/PDF) of the wildfire with key context, and a brief report of exposure (communities, population, infrastructure at risk or affected).

Validation & QA: Double-check your data alignment and units. It’s easy to mix up, say, meters vs degrees. Ensure that when you buffered 5 km, it was indeed 5 km on the ground (project CRS accordingly). Sense-check the population numbers – if something seems off (e.g., you report 500,000 people affected for a remote forest fire), investigate – maybe the population raster was counting a city far away that got partially included. If available, cross-verify your fire perimeter estimate with official sources the next day. If your polygon was way off, adjust your method (maybe use a smaller buffer or incorporate wind direction to elongate the estimate polygon).

Also, have someone else on the team review the map for clarity: can they quickly identify where the fire is and what’s threatened? If not, add labels or improve symbology (like adding a fire icon or arrow pointing direction of spread).

Maintenance: Once you have the template, each new fire is just rinse and repeat. Keep your base layers updated (if new census comes out, update population; if new roads built, update that). Outside of fire season, you might not use this often, so when a new season starts, test the workflow on a past fire to refresh your skills and ensure data sources (like FIRMS) still working as expected.

Risks:

• Accuracy vs urgency: In fast briefings, you might use rough data which could later be wrong (e.g., overestimating a burn area). Be transparent: label things like “estimated” or “as of 3 Nov” to manage expectations. Update when better data (like a precise perimeter) is available, and inform stakeholders of changes.
• Information overload: Don’t clutter the map with too many layers. Focus on the essentials needed for the briefing objective (usually location, spread, who/what’s at risk). Save detailed analysis (like a full demographic breakdown) for written report annex, not the core map.
• Software issues: QGIS is stable but large data (like high-res population grids) can slow it down. To avoid lags during a crisis, pre-cut your population raster to your country/region and perhaps aggregate it to 1 km if 100 m isn’t necessary – this will make calculations faster.

Audience: A small geospatial development team (1–3 people) with some coding or web GIS expertise; aimed at organizations wanting an internal or public live dashboard.

Prerequisites: Familiarity with Python or JS for data processing, a server or cloud setup for hosting (or an ArcGIS Online subscription), and baseline GIS layers (admin boundaries, etc.). Optional: experience with MapLibre (open-source) or ArcGIS Online Dashboards.

Data & tools:

• Fire Danger Forecast data (e.g., daily FWI rasters or shapefiles from GWIS or your meteorological service).
• Active Fire feeds (NASA FIRMS API, NOAA GOES fire detections).
• Population and assets data (WorldPop, critical infrastructure layers as used above).
• A spatial database (PostGIS or even just geoJSON files) to store processed data.
• Map rendering library: MapLibre GL JS (if custom) or ArcGIS Online’s WebApp builder.
• Backend scripting: Python (with Cron jobs or Airflow for scheduling) or Node.js for ETL tasks.

Instructions:

1. Define scope and KPIs: Decide the geographic extent (global is too ambitious for detail; maybe country or state level). Identify key metrics you want on the dashboard: e.g., “Top 5 ongoing fires by size,” “Areas with Extreme fire danger today,” “Population in Extreme danger areas,” “Active fires near critical infrastructure,” etc. This will drive your data needs and design.

2. Set up ETL (Extract, Transform, Load) for hazard layers: Write scripts to fetch latest data:

   • Fire Danger: If using GWIS/ECMWF, script an API call every morning to get that day’s FWI forecast map (or slice for your area). Perhaps you’ll get a GeoTIFF or NetCDF. The script should convert it to a web-friendly format: e.g., a vector grid or tiled raster layer. One approach: classify the FWI raster into categories (Low/Med/High/Extreme) and vectorize it into polygons, but that may be heavy. Alternatively, generate raster tiles (PNG or UTFGrid for an intensity map).

   • Active Fires: Decide on frequency (maybe every 10 minutes). Use FIRMS API with “last hour” data for your region. Or for near-real-time, incorporate geostationary fire detections (NOAA GOES) if available. The script pulls new points and either updates a database table or writes to a GeoJSON that your map will read. Include attributes like time, confidence, and perhaps link to external info (like InciWeb ID if matched).

   • Exposure Data: Precompute population per admin unit and store it. For dynamic exposure: for each admin unit or grid cell, you might want to calculate “population currently in high fire danger” (those where today’s FWI is High and population lives there). This can be done by intersecting the FWI layer with population once a day. Store results in a table (admin_id, pop_in_high_danger, pop_in_extreme_danger, etc.). Similarly, if you have a layer of critical infrastructure (like a GeoJSON of all villages or power stations), you can flag which are in high danger zones.

   Automate these – e.g., a Python script that runs at 00:30 UTC daily after model release, does the intersects, updates tables.

3. Set up data hosting: If using ArcGIS Online, you can publish the layers as hosted feature services (upload the GeoJSON or connect to your PostGIS via ArcGIS Enterprise). For an open stack, consider GeoServer or hosting pre-built vector tiles (e.g., tippecanoe for making MBTiles from your data, then host on Amazon S3/CloudFront). Simpler: host GeoJSONs on a GitHub or your server if size is small. Population by admin might be just a few hundred records – can even embed in front-end as JSON.

4. Build the dashboard UI: Key elements:

   • Map: Use MapLibre or Leaflet to display base map and your layers. Include layers for: Fire Danger (as a colored overlay or hatching for Extreme), Active Fires (as animated or blinking dots perhaps), Recent large fire perimeters (you could show outlines from past 7 days).

   • Sidebar with statistics: Summarize numbers like “Extreme Fire Danger today in X districts, affecting Y people” (pull from the DB/table you computed). “Active Fires: Z detected in last 24h (A high confidence, B extreme FRP).”

   • Filters: Allow user to filter by region or date. E.g., a dropdown to view a particular province, which then zooms and updates the stats for that province (you’ll pre-compute stats by province to enable this).

   • Hydrograph or timeline: For any specific large fire, you might integrate a small chart (if you track that fire’s growth or FRP over time). This could be a stretch goal: when user clicks a fire icon, show a pop-up with “Detected at 14:00, last observed FRP 50 MW, approx size 100 ha.” If you have time-series, maybe a tiny chart of FRP vs time.

   • Last update timestamp: Crucial to display when data was last refreshed, to build trust.

   If coding from scratch is tough, consider using something like Kepler.gl or Carto for quick map dashboards, but they may be less customizable with stats. ArcGIS Dashboard is also an option if data is in that ecosystem – it allows charts and maps with no-code, but you need ArcGIS Online.

5. Incorporate alerting logic (optional): You can integrate an alert system into the dashboard – e.g., flash or highlight an area if certain criteria are met (like an admin area that had no fires now has one). But primarily, this is a monitoring tool; alerting is often better via email/SMS as we did earlier.

6. Testing and iteration: Before public/official launch, run the system parallel to your existing methods for at least one fire season month or a few fire events. Does it capture what managers need? Is it fast enough? Test loading it on different devices (it should ideally be lightweight for field use on a tablet). Get feedback: maybe they want a specific layer, like predicted wind direction arrows on the map – you can add from a weather API.

Outputs: A web-based dashboard that anyone with the URL (internal or public) can visit to get an up-to-date picture of wildfire danger and activity, plus data tables supporting decision-making (like lists of high-risk districts each day).

Validation & QA:

• Validate your model data each day – do the “Extreme” areas correspond with known red flag warnings from the weather service? If not, investigate if your input or threshold is off.
• Cross-verify a handful of active fire points with satellite imagery or local reports, to ensure your filter isn’t missing fires or showing false ones. If you see a lot of false dots (e.g., industrial heat sources consistently showing up), you might add a blacklist mask (e.g., mask out known refinery locations).
• Load testing: ensure the dashboard can handle multiple concurrent users and that the data loads within a few seconds. Optimize by simplifying geometries and using tiles for heavy layers.
• Accessibility: check the color choices (colorblind-friendly palette for danger levels). Provide a legend and maybe brief instructions on the dashboard.

Maintenance:

• Set up monitoring for your data pipeline (if a daily script fails, you get notified).
• Every year, update any static layers (population can be updated with new estimates, infrastructure changes can be incorporated).
• Browser tech changes: occasionally MapLibre or API might update, so plan to review the code annually.
• Extend functionality as needed: maybe incorporate a smoke forecast layer down the line or allow user-drawn AOIs to get stats (cool feature but not initial priority).

Risks:

• Data overload for end-user: Too much info might confuse. Mitigate by focusing the UI on the main questions (“Where are the worst fire risks today? Where are fires happening now? Who/what is in those areas?”). Hide more detailed layers behind toggles.
• Reliability: if the system goes down (server issue, API quota exceeded), have a backup way to distribute the key info (maybe a daily email summary as redundancy).
• Misinterpretation: People might see a high danger area on the map and assume a fire is there. Clear labeling is needed: e.g., use distinct symbols for “fire detected” vs. “just high risk, no fire yet.” Include a disclaimer or info button explaining each layer briefly.

Audience: Data science teams, researchers at a fire center or a tech-savvy National Meteorological and Hydrological Service (NMHS); requires knowledge of machine learning, data pipelines, and validation methods.

Prerequisites: Python/R for ML, experience with scikit-learn or similar libraries, historical fire occurrence data, environmental datasets (weather, lightning, vegetation) for training, computing resources for model training (not heavy if using gradient boosting or RF on tabular data, but needs data prep). Basic MLOps practices for operationalizing the model (versioning, scheduled runs).

Data & Tools:

• Historical fire occurrences: e.g., 10+ years of fire start data (points of ignitions or fire perimeters with start dates). For instance, use MODIS active fire archive or national fire reports.
• Environmental predictors (collated per region and time): daily weather (temperature, humidity, wind, etc.), fuel moisture indices (from FWI components like Drought Code, Fine Fuel Moisture Code), soil moisture (from SMAP or ERA5), vegetation state (NDVI anomaly), lightning strikes (number of strikes in area), topography (elevation, slope), land cover type, and human factors (distance to roads or settlements can proxy ignition from humans).
• ML framework: scikit-learn, XGBoost, or even TensorFlow if doing DL (though tree-based models often perform well for tabular data like this).
• Evaluation tools: for reliability curves, ROC, etc., and domain feedback.

Steps:

1. Assemble an event catalog: Define what you’re predicting: likely “fire ignition occurrence” in a given area and timeframe (e.g., 10km grid cell per day). Create a dataset of positive cases (days/locations where a wildfire started) and negative cases (days/locations with no fire). If you have perimeter data with ignition point & date, use that. Otherwise, derive from hotspots (e.g., the first detection in a cluster = ignition). Include only larger fires if tiny ones aren’t of concern (you might set a threshold like fires that grew >100 ha). Geospatially, you might use grids or admin units as the unit of prediction.

2. Gather predictor variables: For each event (and non-event) sample, attach environmental data leading up to the fire:

• • Weather: e.g., from ERA5 reanalysis or local weather stations interpolated – temperature max, humidity min, wind speed, rainfall sum in past X days.
  • Indices: Fire Weather Index components on that day (the FWI system indices like FFMC, DMC, DC which capture fuel dryness)gfmc.online.
  • Lightning: number of lightning strikes in that location on that day (for human-caused fires, this might be zero while human activity proxies might be needed).
  • Human proxy: day of week (weekends might correlate with campfires), distance to WUI or population density.
  • Terrain: slope (fires start more on slopes or not? maybe affects detection rather than ignition).
  • Vegetation: NDVI anomaly (dryness of live fuel), perhaps previous burn (if area burned last year, lower fuel).
  • Encode these features; make sure to align times (e.g., use data from the morning to predict an afternoon ignition, or previous day’s if predicting next day).

1. Train a model: Use a portion of the data (e.g., 70%) to train. A gradient boosted trees model (XGBoost/LightGBM) is a good choice, as it handles non-linearity and feature interactions well and provides feature importance. The output can be a probability of fire ignition. Since fires are rare (many more no-fire days than fire days), use techniques to handle imbalance: downsample negatives or use proper evaluation metrics (ROC/AUC, Precision-Recall).

2. Validate model skill: Use the remaining 30% for testing, ideally with a time-based split (train on older years, test on latest year to simulate forecasting). Check metrics:

• • AUC for overall discrimination.
  • Precision at a certain recall: e.g., of all actual fire days, can we catch 80% while keeping false alarms low?
  • Brier score for probability accuracy.
  • Reliability curve: do “20% probability” days actually burn 20% of the time?
    If model isn’t performing better than trivial (like always predicting no fire), revisit features and spatial/temporal resolution. You might need to aggregate to coarser units or add more informative features (like explicit drought index).

1. Set operational threshold: Decide what probability level triggers an alert. This is a balance: too low and you alert constantly (false alarms), too high and you miss fires. You can use the Precision-Recall curve to pick a point. For instance, perhaps a 5% probability yields 10 false alarms per actual fire – maybe acceptable or not depending on capacity. If consequences of missing a fire are severe, lean towards sensitivity (lower threshold). Possibly set two levels: e.g., Advisory (lower probability, monitor) and Warning (high probability, act). Engage with fire managers in this decision.

2. Workflow for daily use: Each morning (or better, after the latest weather forecast is available), run the model on today’s forecast conditions:

• • Input today’s predicted weather (or use yesterday’s obs if doing a nowcast), and current indices (FFMC, etc.) and any expected lightning (if you have convective forecast or use climatology).
  • The model outputs a probability map (or list of locations with probabilities). Generate a concise output, e.g., “Locations of concern: Grid 123 (0.6 probability ~ high), Grid 456 (0.4 med), ...”
  • Focus on the top N high-risk areas. If using admin units, list subdistricts ranked by risk.
  • Also identify if those areas have high values at stake (overlay population or infrastructure to prioritize “high risk + high exposure”).

1. Integrate with early warning systems: Now tie this back to your workflow:

• • For areas flagged high risk, you might pre-deploy resources (notify fire crews to stage near that area, or aerial patrol in the afternoon).
  • You could feed these as “early alerts” to communities: e.g., “Lightning forecast combined with dryness indicates high chance of fire in XYZ region today – all residents, please be vigilant and report smoke immediately.” This prompts quicker human detection.
  • Connect with How-To 2 automation: perhaps incorporate a rule that if an area had a model probability >50% and lightning occurred, but no fire detected yet, still send an alert to check (this is speculative, but a way to catch “holdover” fires that satellites haven’t seen yet but are likely smoldering).

1. Plan for continuous learning: As more fires occur, feed them back into the training data. Perhaps retrain the model at end of each season to capture new trends (especially with climate change shifting patterns, or if human behavior changes like new settlements). Keep a “model card” documenting the model’s purpose, data used, limitations (e.g., “only applies to forested areas, not grassland fires”).

Outputs: A predictive model (and daily run pipeline) that outputs a map or list of areas with elevated fire start probability. Optionally, a user interface for analysts to review this (could be as simple as a CSV emailed daily or a layer on the dashboard from How-To 4 with a heatmap of ignition risk).

Validation & QA: This advanced step requires careful verification:

• Compare model predictions with actual outcomes over a trial period. Track missed ignitions: what was special about them? Perhaps you need a new feature (e.g., a local illegal burn that model can’t predict). Track false alarms: are they often the same location? (maybe an area where model thinks it’s dry but actually it’s irrigated farmland – incorporate land use to fix).
• Engage end-users (fire managers) in evaluating usefulness: Did the model alert on something they weren’t already aware of via traditional forecasts? If it’s just replicating FWI extremes, its added value might be marginal. Aim for catching subtle cases (like moderate FWI but with lightning cluster in a vulnerable spot).
• Ensure no bias or ethical issue: If using human-related features (like population), be mindful not to misallocate resources away from less populated areas that still matter (just because model focuses on where people are, one doesn’t want to ignore fires in wild ecosystems). Balance human and environmental values in how the model’s outputs are used.

Maintenance:

• Retraining schedule: maybe annually, or if a significant event indicates model gaps.
• Monitor performance metrics continually (you could compute a running Brier score every month to see if calibration drifts).
• Data updates: update land cover or population layers in the model inputs as they change.
• Integrate new science: e.g., if a new lightning forecast model comes that improves prediction of dry strikes, include that.
• Document any changes to the model (versioning) and communicate to users when thresholds or behavior changes.

Risks:

• Overfitting: The model may perform great on past data but miss new conditions (e.g., a type of extreme heat wave outside training range). Mitigate by not over-relying on too complex a model without enough data (sometimes a simpler logistic regression might generalize better here).
• False security: Users might think the model will catch everything (“the AI didn’t warn, so no need to patrol”). Combat this by training users that it’s an aid, not a guarantee. Emphasize “probability” nature – even a low probability area can have a fire, just less likely.
• Complexity in explanation: ML can be a black box. To gain trust, provide some explanations. For instance, identify top 3 factors for each alert the model gives (“High risk in XYZ mainly due to very low humidity and many recent lightning strikes”). This helps users understand and trust the alert, or even contest it with local knowledge (“Actually, that area’s lightning was in wetlands – so maybe it’s fine.”). Using an interpretable model or post-hoc SHAP values can help generate such explanations.
• Data issues: If lightning data is incomplete (common, if relying on a single network), the model might systematically under-predict lightning-caused fires in areas with missing data. Identify and acknowledge such gaps; you might exclude those areas from model application or seek better data.