Skip to content

WeatherForge: Minnesota Severe Weather Risk Analytics Dashboard

A data engineering and analytics dashboard project that transforms large NOAA weather datasets into county-level severe-weather risk insights for Minnesota.

Context

Prototype / Academic Project

Current state

Applied dashboard prototype

Role

Sole builder for data pipeline, analytics layers, dashboard, and case-study documentation

Problem

Public weather data is large, messy, and hard to use directly for decision support. NOAA archives contain valuable severe-weather and daily-observation records, but the raw files need filtering, cleaning, unit conversion, county joins, and clear dashboard views before they become useful for Minnesota risk analysis.

Solution / What I Built

I filtered, cleaned, transformed, and packaged NOAA Storm Events and GHCN-Daily data into Minnesota-focused analytics layers, then built dashboard views for statewide trends, county-level impacts, historical time progression, weather context, methods, and live-alert exploration.

Results

Curated 55,384 cleaned Minnesota storm-event records and 9,008,748 station-day observations into reusable Parquet layers and a Python Shiny + Plotly dashboard spanning all 87 Minnesota counties.

Quantified Outcomes

These numbers describe project artifacts and sanity checks. They are not client ROI, deployment adoption, actuarial accuracy, or broad model-accuracy claims.

~35 GB

raw NOAA source archive

used in the working project

55,384

cleaned Minnesota storm-event records

9,008,748

Minnesota station-day weather observations

87

Minnesota counties mapped

1950-06-15 through 2025-12-28

storm-event range

1877-08-05 through 2026-03-22

weather-observation range

Architecture

The pipeline is shown as explicit stages so the system boundary is inspectable.

  1. 1

    Raw NOAA files

    Storm Events and GHCN-Daily source files collected as the raw archive.

  2. 2

    Minnesota filtering

    Records scoped to Minnesota events, counties, and station observations.

  3. 3

    Cleaning and unit conversion

    Fields normalized, weather units converted, and records prepared for analysis.

  4. 4

    Parquet outputs

    Curated analytics layers stored for faster dashboard and analysis use.

  5. 5

    County joins and population normalization

    County boundaries and population anchors support mapped and normalized comparisons.

  6. 6

    Shiny and Plotly dashboard

    Interactive views expose overview, county, temporal, methods, and alert surfaces.

Technical Stack

PythonShinyPlotlyParquetNOAA Storm EventsNOAA GHCN-DailyGeoJSON

Data sources

  • NOAA Storm Events
  • NOAA GHCN-Daily
  • Minnesota county boundary GeoJSON
  • County population anchors

Applied Relevance

Where the pattern matters

  • Severe-weather awareness
  • County-level risk comparison
  • Public-data productization
  • Dashboard reporting
  • Executive summaries

Dashboard Views

WeatherForge is organized as a decision-support dashboard rather than a single chart export.

Overview
County Impacts
Weather Context
Time Progression
Statewide Trends
Methods/Pipeline
Live Alerts

Proof Surfaces

Available artifacts are labeled directly. Missing visuals stay as placeholders until real screenshots are added.

Dashboard Views

Available now

The project contains a dashboard structure with multiple decision-support views rather than a single static chart.

  • Overview, County Impacts, Weather Context, Time Progression, Statewide Trends, Methods/Pipeline, and Live Alerts views.
  • Screenshot placeholders remain on the portfolio page until final dashboard captures are added.

Architecture / Pipeline

Available now

The pipeline runs from raw public archives through filtering, cleaning, Parquet outputs, county joins, and an interactive Shiny/Plotly surface.

  • Raw NOAA files -> Minnesota filtering -> cleaning/unit conversion -> Parquet outputs.
  • County joins and population normalization make county-level comparisons possible.
  • Shiny and Plotly expose the curated analytics layers through dashboard views.

Applied Decision-Support Surfaces

Available now

The project demonstrates how public data can be productized into reporting surfaces without claiming forecasting or actuarial precision.

  • County-level severe-weather comparisons.
  • Historical trend and time-progression views.
  • Methods view that explains the data pipeline and caveats.

Artifacts & Evidence

Available now

The case study uses verified project artifact counts and keeps limitations explicit.

  • ~35 GB raw NOAA source archive used in the working project.
  • 55,384 cleaned Minnesota storm-event records and 9,008,748 station-day observations.
  • Public GitHub repository linked for code review.

Limitations

What this does not claim

  • Pre-1996 NOAA Storm Events data is less complete.
  • Older records are biased toward better-monitored and more populated areas.
  • Same-day statewide weather averages are context, not exact event-local station readings.
  • The current version is Minnesota-focused.
  • This is a decision-support prototype, not a forecasting or actuarial model.

Next Improvements

Reasonable next steps

  • Add polished screenshot evidence from the dashboard views.
  • Document reproducible data refresh steps for the Parquet analytics layers.
  • Expand validation notes around county joins, population anchors, and historical-data caveats.
  • Explore additional states only after the Minnesota workflow is fully documented.

Public Repository

The public code link is provided for review of the prototype and technical approach. This does not represent paid deployment, production adoption, or client ROI unless stated elsewhere on the page.

Related Case Studies

More portfolio context.

Prototype / Academic ProjectLocal RAG prototype

RAGeATM

A small explainable Retrieval-Augmented Generation prototype that retrieves local evidence first, applies a relevance threshold, and refuses unsupported questions when the corpus does not justify an answer.

PythonTF-IDFCosine SimilarityLocal Retrieval
Read case study
R&DActive Build

DGM

Workflow orchestration layer in active development for managing state, decision flow, and human review inside StormIQ.

PythonFastAPIWorkflow GraphsQueue-backed Jobs
Read case study
Back to all case studies