Living in the Ring of Fire
Living in Indonesia means sharing a home with nature’s most volatile forces. Statistically, my country ranks second globally in disaster vulnerability, with a staggering hazard index score of over forty-three percent. We live with the constant, quiet anxiety of sudden earthquakes, flash floods, and rain-induced landslides. During my time preparing for the IDCamp Hackathon 2026, I realized a glaring discrepancy in how we handle these crises. While our government agencies like BMKG and BNPB publish vast oceans of public telemetry, there is a massive bridge missing between raw geological datasets and the panicking citizen on the street.
When a disaster strikes, people do not need complex geological charts; they need to know if their current street is safe, where the nearest shelter is, and if they can get there before cell towers collapse. This realization was the genesis of PantauBumi. I set out to build an individual personal project that would act as a smart, localized, and resilient guardian. My objective was to construct an Android application that not only predicts multi-disaster risks using local machine learning models but also remains fully functional when the physical infrastructure around it falls silent.
The Core Problem: Information Isolation When the Grid Goes Down
The ultimate paradox of modern disaster warning apps is their heavy reliance on high-speed internet connectivity. In a severe landslide or earthquake, power grids are severed and cell towers go dark. Traditional apps fail exactly when they are needed most, leaving users staring at loading spinners. Furthermore, existing warning tools are purely reactive, alerting citizens only after the river has already breached its banks.
To break this cycle, I had to solve two interconnected engineering challenges. First, I needed to transform real-time weather and geological indicators into localized, predictive risk scores hours before an event occurs. Second, I had to engineer a reliable offline-first mobile environment that caches geographic maps and local evacuation coordinates directly onto the device. I wanted the interface to speak a language of calm. Instead of using jarring, panic-inducing alarm tones and aggressive neon red interfaces, I designed the entire product around a soothing sage green palette that I called the "Embun" theme. This visual language was designed to instill a sense of clear-headed focus during high-stress situations.
The Technical Architecture: Orchestrating AI and Offline-First Maps
To breathe life into PantauBumi, I chose to construct a highly decoupled, modern system architecture. The backend is powered by Python and FastAPI, deployed on Railway.app. I selected Neon PostgreSQL as my primary database due to its excellent connection pooling and developer-friendly serverless scaling. This backend functions as an active ingestion pipeline, executing scheduled cron-like background tasks via APScheduler every five minutes. These tasks pull live data from BMKG, BNPB, USGS, and Open-Meteo, storing raw telemetry such as local precipitation levels, river depth sensors, soil moisture data, and tectonic activity coordinates.
The true intelligence of PantauBumi resides in its predictive machine learning layer. Rather than relying on simple static thresholds, I trained two dedicated predictive models. For flood risk estimation, I utilized an XGBoost model that processes real-time rainfall volume and upstream river levels to generate a probability score. For landslide prediction, I developed a Random Forest model that evaluates precipitation levels alongside soil saturation metrics.
Earthquake risks are processed through a deterministic, rule-based USGS alert parsing system that dynamically calculates potential local shaking based on the user's distance from the epicenter. The outputs of these calculations are packaged into a unified risk API payload. When the overall risk rating exceeds seventy-five percent, the backend automatically flags the situation as critical, triggering instant alerts via Firebase Cloud Messaging.
On the mobile frontend, I built the entire application using Kotlin within Android Studio, targeting Android API level twenty-six and above. I adopted Jetpack Compose and Material 3 to build a fully declarative, fluid user interface. Rather than relying on traditional XML layouts, Compose allowed me to write clean UI code that reacts dynamically to underlying state changes. To keep the app highly modular and testable, I utilized Hilt for dependency injection and Kotlin Symbol Processing (KSP).
// A glimpse into how PantauBumi manages localized risk state computation on the client side
enum class RiskLevel(val colorHex: String) {
CRITICAL("#D32F2F"),
HIGH("#F57C00"),
MEDIUM("#FBC02D"),
LOW("#388E3C")
}
data class LocalRiskState(
val floodScore: Float,
val landslideScore: Float,
val earthquakeScore: Float
) {
val overallRisk: RiskLevel
get() = when {
floodScore >= 0.75f || landslideScore >= 0.75f || earthquakeScore >= 0.75f -> RiskLevel.CRITICAL
floodScore >= 0.50f || landslideScore >= 0.50f -> RiskLevel.HIGH
floodScore >= 0.25f || landslideScore >= 0.25f -> RiskLevel.MEDIUM
else -> RiskLevel.LOW
}
}
The offline-first map rendering engine presented a major technical hurdle. Standard mapping solutions require an active internet connection to stream vector tiles. To bypass this limitation, I integrated the MapLibre Android SDK. On the first launch, the application checks if the user is on a Wi-Fi connection and triggers an background download job using WorkManager to pull localized MBTiles mapping files. These MBTiles are saved in the device's internal storage, covering a thirty-kilometer radius from the user's home coordinate.
When the device drops off the grid, MapLibre dynamically switches its source to these local vector tiles, displaying a fully interactive map of local topography, complete with gold-coded evacuation markers retrieved directly from the local Room database cache.
Defeating Spam in the Middle of Chaos: The IndoBERT Guard
A critical component of PantauBumi is its community crowdsourcing screen, which allows users on the ground to submit live reports regarding road blockages, rising water levels, or structural collapses. However, crowdsourcing during crises is highly vulnerable to rumor spreading and spam reports, which can misdirect rescue teams. To maintain data integrity without requiring manual administrative moderation, I implemented a double-layered defense system.
On the backend, every submitted report is processed through an IndoBERT natural language processing model trained specifically on conversational Indonesian text. The model analyzes the semantic context of the submission to determine if it is a genuine, actionable crisis update or irrelevant noise. If the confidence score is below sixty percent, the report is silently hidden from the public map.
To complement this AI moderation, I engineered a robust rate-limiting and device identification protocol. Because the app does not force users to sign up for an account, I generate an anonymous, persistent UUID on the device during onboarding, which is securely stored in Jetpack DataStore. Every outgoing community report payload contains this device ID as a silent header. The FastAPI gateway monitors this header, enforcing a strict rate limit of five reports per hour, alongside a mandatory ten-minute cooldown between submissions.
Furthermore, I built a community-driven self-moderation mechanism. If other users flag an inaccurate or false report three times, the backend instantly marks its visibility status to false, preventing it from showing up on anyone's MapLibre canvas until manual administrator approval is granted.
Outcomes & Current State
The result of this intensive project was a highly optimized, production-ready MVP that completely redefined how I approach mobile system design. During end-to-end performance profiling under simulated network outages, PantauBumi exceeded my expectations. The offline rendering engine successfully loads local cached map tiles and physical shelter routing options in less than four hundred milliseconds, providing immediate utility to users with zero cellular connectivity. On a standard 4G connection, the main dashboard retrieves, computes, and renders live hazard risk ratings in under one point two seconds, while the API p95 response time consistently clocks in at a rapid seven hundred and fifty milliseconds.
+-------------------------------------------------------------+
| PANTAUBUMI PERFORMANCE BENCHMARKS (MVP) |
+-------------------------------------------------------------+
| Metric | Target | Measured Result |
+------------------------------+------------+-----------------+
| Dashboard Render (4G) | < 2.0s | 1.2s |
| Offline Cache Load Time | < 500ms | 400ms |
| API Latency (p95) | < 800ms | 750ms |
| IndoBERT Crowd Verification | < 3.0s | 1.8s |
| Notification Delivery Latency| < 60s | 12s |
+-------------------------------------------------------------+
By leveraging Room as our single source of truth alongside Retrofit, the app remains fully stable without crashes when the network is abruptly disconnected. The integration of WorkManager ensures that critical silent risk evaluations are performed in the background every fifteen minutes, automatically resuming even after a complete device reboot. The project was successfully submitted to the IDCamp Hackathon 2026, showcasing a robust integration of AI and mobile engineering.
Key Takeaways & Lessons
Building PantauBumi as a solo engineer was an invaluable lesson in product discipline and system architecture. In the early stages, I wanted to build complex GeoJSON risk zone polygon overlays, custom routing engines, and full administrative dashboard panels. However, acting as my own Project Manager forced me to ruthlessly prioritize the features that directly impact survival: reliable push notifications, fast-loading predictive data, and highly resilient offline maps.
I learned that in high-stakes environments, empathy-driven UI design is just as critical as technical performance. Using the calming, sage green "Embun" theme was a conscious choice that reminded me that software should support its users emotionally during times of stress. By combining modern Android frameworks like Jetpack Compose and Room with Python-based AI models, I proved that a single developer can design, develop, and deploy a lifesaving digital product. Moving forward, I plan to expand this project by implementing lightweight, decentralized mesh networks to allow users to share local safety updates directly peer-to-peer, even when cellular service is completely gone.