- Project Haven is an AI bushfire platform built to deliver real-time evacuation routing and alerts, even when mobile networks fail.
- This AI bushfire platform combines the official McArthur FFDI formula with an XGBoost model trained on historical Australian fire data.
- The project won GovHack 2024 as a set of Jupyter notebooks — and was then rebuilt from scratch into a working six-service system.
- Offline-first design means the app keeps functioning when connectivity drops, which is almost always during a major bushfire emergency.
- Project Haven is an AI bushfire platform built to deliver real-time evacuation routing and alerts, even when mobile networks fail.
- This AI bushfire platform combines the official McArthur FFDI formula with an XGBoost model trained on historical Australian fire data.
- The project won GovHack 2024 as a set of Jupyter notebooks — and was then rebuilt from scratch into a working six-service system.
- Offline-first design means the app keeps functioning when connectivity drops, which is almost always during a major bushfire emergency.
The Hackathon Win That Sat in a Drawer
Project Haven — an AI bushfire platform designed for Australia’s most dangerous season — started its life the way most hackathon projects do: in a burst of adrenaline, running on bad coffee and a deadline. At GovHack 2024, a 46-hour national hackathon centred on Australian government open data, developer Ujja showed up with a specific and serious problem in mind. Bushfires kill people. And in the chaos of an active fire event, the information gap between what emergency agencies broadcast and what an ordinary resident actually needs — right now, at their location, on their phone — can be lethal.
The submission that came out of those 46 hours wasn’t a polished app. It was a system design diagram, a set of Jupyter notebooks crunching real data from the Geoscience Australia historical bushfire boundaries dataset and ABS community data, and a vision for an event-driven microservices architecture that didn’t yet exist in running code. No UI. No backend. Just the numbers and the blueprint.
It won. And then it sat untouched for months — which is, if we’re honest, the normal fate of hackathon projects everywhere.
Why This AI Bushfire Platform Is Different From What Already Exists
Australia isn’t short on bushfire warning systems. The Bureau of Meteorology publishes fire danger ratings. State emergency services run alert SMS systems. Apps like Fires Near Me from the NSW Rural Fire Service have been around for years. So what’s the gap?
The gap is integration, intelligence, and resilience. Existing tools tend to do one thing: broadcast alerts. They don’t route you to the nearest evacuation centre with an ETA. They don’t tell you which government grants you might be eligible for after your home is damaged. And critically — they assume you have internet access, which is often the first casualty of a major fire event that takes out infrastructure.
Project Haven is an AI bushfire platform that tries to solve all of this in a single system. The risk prediction engine blends the McArthur Forest Fire Danger Index Mark 5 formula — the official standard used by the Bureau of Meteorology — with an XGBoost machine learning model trained on historical GA bushfire boundary data, running as a Python sidecar weighted at an 80/20 split. That’s not a toy model. FFDI Mark 5 is the same formula underpinning Australia’s official fire danger rating system, and layering a trained gradient-boosting model on top of it gives the platform a way to refine predictions beyond what pure meteorological formula can capture.
The result feeds an event-driven pipeline: the prediction service subscribes to weather data, runs the blended engine, and publishes predictions to a RabbitMQ message bus. An alert service picks those up and generates tiered notifications — from low-priority feed items right through to full-screen critical banners. All asynchronous. All decoupled. The kind of architecture you’d expect from a production-grade system, not a hackathon afterthought.
The AI That Stays Online When the Internet Goes Down
The most technically interesting piece of Project Haven isn’t the prediction model. It’s the AI assistant — and specifically how it runs. As an AI bushfire platform built around real-world constraints, Haven is designed from the ground up for the scenario where connectivity simply isn’t available.
Rather than sending queries to a cloud API (which requires connectivity, which you won’t have), Haven runs Ollama locally, serving Nous Hermes 2 as the inference engine. That model handles three jobs: powering the conversational emergency assistant, researching relevant government recovery support like the Disaster Recovery Payment and the Primary Producer Recovery Grant, and generating scheduled fire-season briefings. The system prompt is built to escalate to 000 — Australia’s emergency services number — when the conversation warrants it.
Running an LLM locally inside a Dockerised microservices stack isn’t trivial. It’s also a deliberate architectural choice that reflects a real-world constraint most cloud-first developers ignore: during a category-defining disaster, your AWS endpoint doesn’t matter if the user’s phone is on a patchy 3G signal twenty kilometres from a fire front.
The whole frontend is an offline-first Progressive Web App. Evacuation points, alerts, and recommendations are cached locally. If connectivity drops mid-crisis — and the source is blunt about this: it will — the app keeps working. That design decision alone puts Haven ahead of virtually every existing consumer-facing bushfire app.
Six Microservices, One Command
The rebuilt architecture is worth examining because it shows how much distance there is between a GovHack demo and something that could actually be deployed. This AI bushfire platform runs six microservices in its production-ready stack: a prediction service, an alert service, an API gateway, PostgreSQL for persistence, RabbitMQ for the message bus, and a React PWA frontend — all containerised, all wired together with Docker Compose, with a local Ollama instance baked in.
Spinning it up is genuinely one command: docker compose up –build. From there, you can simulate an extreme weather event — say, 42°C, 80 km/h winds, 10% humidity, and dense vegetation near Sydney’s coordinates — with a single curl request to the weather endpoint. The system runs it through the prediction engine and fires a CRITICAL alert within seconds. That’s a demo that actually demonstrates something.
The community feed adds a layer that no top-down alert system can replicate: on-the-ground updates from people in affected areas. During the 2019–20 Black Summer fires — which burned over 18 million hectares and killed 33 people directly — social media became a de facto real-time information channel precisely because official systems couldn’t keep pace with conditions on the ground. Structured, location-aware community reporting built into an AI bushfire platform itself is a smarter version of that instinct.
What the Finish-Up-A-Thon Actually Proves
GitHub’s Finish-Up-A-Thon challenge — the competition that motivated this rebuild — is ostensibly about completing abandoned projects. But what Ujja’s account of Project Haven actually illustrates is something more specific: the structural problem with hackathons as an innovation format.
Hackathons are excellent at generating ideas and terrible at generating products. The incentive structure rewards a compelling 46-hour demo, not a maintainable codebase or a thought-through deployment model. Winning validates the idea without creating any momentum to actually build it. The project freezes at peak excitement, which is also the moment it’s furthest from being useful to anyone.
What changed with Project Haven wasn’t the idea — the core insight that information is survival during a bushfire was just as true after GovHack 2024 as it was during it. What changed was the mindset. Moving from hackathon mode to platform mode meant building a real backend, a real frontend, a real event pipeline, and real offline capability. It meant asking not “will this impress a judge in a three-minute demo?” but “will this work when someone’s house is on fire?”
That shift in question is harder than it sounds. And the fact that an AI bushfire platform built by a solo developer now spins up a full production-like stack from a single command — with offline LLM inference, tiered alerting, and grant research built in — suggests the original GovHack vision was worth finishing. An AI bushfire platform of this kind matters more every year: climate change is extending and intensifying Australia’s fire season, and the 2023–24 season saw significant fire activity across Western Australia and Queensland well before summer. The gap between what communities need and what exists isn’t closing on its own. Projects like Haven, however incomplete, point in the right direction. Every serious AI bushfire platform that reaches working-deployment stage brings that gap a little closer to being bridged.
Source: https://dev.to/ujja/from-govhack-win-to-something-that-actually-matters-2mmi
