MMontandon NotebooksReproducible disaster analytics

For users & responders

How it works, end to end

From a reusable analysis template to a published, shareable result — here is the whole journey through the app. Every screen below is an illustrative mockup of the interface.

1 · Author a template 2 · Browse & discover 3 · Select area & parameters 4 · Generation runs 5 · View the result 6 · Get notified
1

Author an analysis template

An analyst defines a reusable Analysis Notebook: a Jupyter notebook that declares the parameters it accepts. Think of it as a form schema attached to code.

  • Typed parameters — hazard, intensity threshold, return period, climate scenario, admin subdivisions, population source, infrastructure layers.
  • Version-controlled in a git repo; the app tracks the template & its parameter schema.
  • One template serves many runs — for any country, area or event.
Dev

Templates are stored as light metadata (slug, title, parameter_schema, source repo, version). See the data model →

Template detail page showing the parameter schema for a Risk Exposure notebook
App UI A template and its declared parameters.
Browse catalogue with a filter rail and a grid of generated analysis notebooks
App UI The discover interface — filter by country, hazard, use case and date.
2

Browse & discover

Every generated analysis is indexed and findable. Filter by country, admin area, hazard, disaster or date and click through to the result — served straight from object storage.

  • See all analyses for an area, or all runs of one template.
  • Each card carries its parameters and the timestamp it was generated.
  • Start simple; grow the discovery experience over time.

Try it

A live taste of discovery

Filter the illustrative catalogue below — the same interaction the real browse page provides.

 

Illustrative data. In the real app, cards link to the published static-HTML notebook; an empty result could offer to queue a new run for that selection.

3

Select an area & parameters

Pick the target admin area on a map — a single district, or “all Admin-2 in a country” — then fill in the analysis parameters. The form is generated from the template’s schema.

  • Select official boundaries (GADM / CODs) or upload your own zones.
  • Choose hazard, threshold, return period, climate scenario, population source and infrastructure layers.
  • Review a plain-language summary before you commit.
Map-based admin area picker with three districts selected
App UI Pick admin areas on the map — one, many, or a whole level.
Parameter form filled in for a run, with a summary and Run analysis button
App UI The parameter form, generated from the template schema.

…then hit Run

Submitting creates a run and hands it to the worker pipeline. You can queue one area or fan out across a whole administrative level in a single request.

Dev

The API creates a NotebookRun (status queued) and enqueues a Celery task. See the sequence →

4

The generation job runs

A worker executes the parameterized notebook with papermill: it pulls the data sources, runs the analysis, and MyST renders the finished notebook to static HTML, which is uploaded to object storage.

  • This is where the heavy lifting happens — once, per run.
  • Progress is visible; you don’t have to wait on the page.
  • The run record (parameters, timestamps, output URL) is saved for discovery.
Note

Runtimes vary with data volume and resolution. Optimising the notebook execution is a known, tunable problem in the Jupyter ecosystem.

Run status page with a progress timeline and a log panel
App UI Live run status: queued → fetching → executing → rendering → publishing.
A rendered notebook showing a choropleth of schools exposed to heatwaves in Nepal
Notebook output The published result — an interactive map, legend and tables, as static HTML.
5

View the result

The finished analysis opens as a self-contained web page: interactive maps (lonboard), charts and widgets (manywidgets/anywidget), and result tables — no server or kernel needed.

  • Served directly from object storage — fast, cacheable, shareable by link.
  • Widgets stay interactive in the static export (sliders, toggles, filters).
  • Download the notebook to reproduce or extend the analysis yourself.

Real, rendered, kernel-free

These widgets are live in static HTML

Captured from the manywidgets project — controls that keep working on a published page with no running kernel. This is the interaction layer inside a generated notebook: a dropdown, a toggle and a slider driving a chart, all client-side.

A rendered chart with a chart-type dropdown, legend toggle and height slider, working without a kernel
Real capture A live chart driven by a dropdown, toggle and slider — interactive, kernel-free, in a static page. The same building blocks power a notebook’s maps, legends and filters.
6

Get notified & share

When a run finishes — whether you requested it or it was triggered automatically — you can be notified with a direct link to the result. No login needed to view a published page.

  • Email or in-app notification with a link straight to the static HTML.
  • Especially useful for automatic, event-triggered runs (see Automation).
  • Share the link with anyone; the page stands on its own.
An email and an in-app toast notifying that an analysis is ready, with a view link
Notification A direct link to the finished analysis.

See what each analysis actually produces

The three use cases — risk exposure, post-disaster impact, and response prioritisation.

Explore the use cases Or the architecture