AWS Builder Center

Building NER Landslide Guard: An AWS-Powered Early Warning Platform for Northeast India

A technical walkthrough of how our team built NER Landslide Guard, combining GIS-based hazard monitoring, offline-first field reporting, geospatial analysis, and AWS-oriented tools for disaster response in Northeast India.

Building NER Landslide Guard: An AWS-Powered Early Warning Platform for Northeast India

Introduction

Northeast India is highly vulnerable to landslides and rainfall-related disruptions because of its mountainous terrain, heavy rainfall, and geographically remote communities. When a road is blocked or infrastructure is damaged, nearby communities can become difficult to reach, making timely response much harder.
During the First Commit hackathon, our team built NER Landslide Guard, an early-warning and disaster-response platform designed to help authorities and field teams understand hazards, affected infrastructure, and potentially isolated communities.
The idea was simple: instead of looking at a hazard as an isolated event, we wanted to connect the hazard with the surrounding road and settlement network so that responders could better understand its potential impact.

The Problem We Wanted to Solve

Disaster response can become difficult when information is scattered across different sources.
A landslide may block a road, but the important question is what happens next.
  • Which settlements depend on that road?
  • Could communities become isolated?
  • Which affected areas should responders examine first?
  • How can field teams report new hazards from locations with unreliable connectivity?
  • How can authorities visualize the situation geographically?
NER Landslide Guard was designed around these questions.
Our goal was to create a platform that connects hazard information, geographic data, road connectivity, settlements, field reports, and response prioritization in one system.

Our Solution

NER Landslide Guard combines several components into a single disaster-management workflow.
The platform includes:
  • GIS-based visualization of hazard and risk information
  • Road and settlement connectivity analysis
  • Field hazard reporting
  • Offline-first reporting for areas with unreliable connectivity
  • Role-based access for different users
  • Risk and response prioritization
  • AI-assisted disaster triage architecture
  • Multilingual alert support
The platform is designed around three primary user roles:
  • Citizen — report hazards and warning signs from the field
  • Field Inspector — investigate and update reported hazards
  • District Officer — monitor affected areas and prioritize response
The central idea is that a blocked road is not only a road problem. It can also become a connectivity problem for the settlements that depend on that road.

How the Platform Works

The main workflow begins with hazard and geographic information.
The system can represent hazards, roads, settlements, and risk information on a GIS interface. Users can examine vulnerable areas and understand how infrastructure connects different settlements.
When a hazard affects a road or corridor, the platform can analyze the surrounding road and settlement relationships to identify communities that may become isolated.
This allows the response workflow to move beyond simply asking:
"Where did the hazard happen?"
and toward:
"What could this hazard affect?"
That distinction is one of the main ideas behind NER Landslide Guard.

GIS-Based Risk Monitoring

The platform uses MapLibre GL to provide an interactive map interface.
The GIS dashboard is designed to visualize:
  • Risk areas
  • Roads and corridors
  • Settlements
  • Hazard reports
  • Potentially affected areas
  • Response-related information
The project includes representative Northeast India locations and road corridors to demonstrate how geographic relationships can be used during disaster response.
The goal is not simply to display a map, but to make geographic relationships useful for decision-making.

Road and Settlement Connectivity

One of the important parts of our project is the relationship between roads and settlements.
We use a graph-based approach to represent connectivity between locations. This allows the system to reason about how disruption to a road can affect connected settlements.
We use NetworkX for this graph-based analysis.
For example, if a road segment becomes unavailable, the system can examine connected locations and calculate an isolation-related priority value.
This creates a more useful response question:
Which communities could be affected if this route becomes unavailable?
This is particularly relevant in remote and mountainous regions where alternative routes may be limited.

Offline-First Field Reporting

Connectivity is one of the major challenges for applications designed for remote disaster-prone regions.
A field inspector may not always have a stable internet connection when reporting a hazard.
To address this, our frontend follows an offline-first approach.
Reports can be stored locally using browser-based storage and placed into a synchronization queue. When connectivity becomes available again, the application can synchronize the queued information with the backend.
This approach allows the application to remain useful even when network connectivity is temporarily unavailable.

Backend Architecture

The backend is built using Python and FastAPI.
The backend provides the API layer connecting the frontend with the project's risk, hazard, authorization, and response workflows.
The overall architecture can be summarized as:
React Frontend → FastAPI Backend → Risk / Hazard / Authorization / AI Components
The application is containerized using Docker so that the different components can be developed and tested together.

Using AWS-Oriented Tools

Because First Commit included the Build It track, we focused on AWS's open-source and local development ecosystem.

LocalStack

We used LocalStack to create a local AWS-oriented development environment.
This allowed us to work with AWS-compatible infrastructure locally instead of requiring every component to be deployed to the cloud during development.
It was particularly useful for testing the overall application stack in a reproducible local environment.

OpenSearch

We incorporated OpenSearch into the architecture for working with hazard and risk information.
OpenSearch provides search and indexing capabilities that are useful for a system where geographic and disaster-related information needs to be queried efficiently.
For the hackathon prototype, we focused on demonstrating the integration and architecture locally rather than presenting it as a production-scale deployment.

Cedar

We used Cedar for policy-based authorization.
Instead of placing all authorization decisions directly inside application logic, Cedar allows access rules to be expressed through policies.
This supports different permissions for users such as citizens, field inspectors, and district officers.
It also helped us understand how authorization can be treated as a separate policy layer within an application.

Strands Agents SDK

We also incorporated the Strands Agents SDK into the AI-assisted disaster triage architecture.
The idea is to provide an agent-based workflow that can work with hazard and risk information and support the triage process.
For this hackathon prototype, the agent integration is part of the architecture and experimentation rather than being presented as a fully autonomous production disaster-response system.

Why We Chose a Local AWS Development Approach

For a hackathon project, setting up an entire production cloud infrastructure can consume significant development time.
Using LocalStack allowed us to experiment with an AWS-oriented architecture locally while keeping the project reproducible across our development environments.
This also helped us understand the relationship between application code, infrastructure, search, authorization, and AI components.
Rather than treating AWS technologies as isolated services, we wanted to understand how they could fit together as part of one larger system.

Challenges We Faced

One of our biggest technical challenges was the local development environment.
Our team was working on Windows with Docker Desktop and WSL2. During development, we encountered container execution problems even though Docker itself appeared to be running correctly.
After investigating the Docker configuration, we found that the containerd image store configuration was causing compatibility issues in our environment.
We switched to the classic Docker image store and verified that standard Linux containers could execute correctly. After that, we were able to build and start our backend, frontend, LocalStack, and OpenSearch components together using Docker Compose.
This experience taught us that building a cloud-oriented application locally is not only about writing application code. The development environment and infrastructure configuration can be equally important.

What We Learned

The biggest lesson from this project was that disaster management is not only about detecting a hazard.
Detection is only the beginning.
A useful disaster-response platform also needs to consider:
  • Where the hazard occurred
  • Which infrastructure may be affected
  • Which settlements depend on that infrastructure
  • How field teams can report new information
  • What happens when connectivity is unavailable
  • Who should have access to specific information
  • How responders can prioritize their actions
Connecting these pieces gave us a better understanding of how software can support disaster-response workflows.
We also learned how tools such as LocalStack, OpenSearch, Cedar, and Strands can contribute to different layers of a larger application architecture.

What We Would Build Next

NER Landslide Guard is a hackathon prototype, and there are several areas we would improve for a production-ready system.
Future development could include:
  • Live weather and rainfall data integration
  • Real satellite-derived indicators
  • IoT-based soil and environmental sensors
  • Larger historical landslide datasets
  • More advanced machine-learning models
  • Real-time data ingestion pipelines
  • Production AWS infrastructure
  • More extensive multilingual support
  • Improved field synchronization and conflict handling
  • Automated notification workflows for relevant authorities
These improvements would allow the prototype to move from a demonstration platform toward a more comprehensive disaster-monitoring system.

Conclusion

NER Landslide Guard was built around one central question:
Can we move disaster response from simply reacting to an incident toward understanding its potential impact earlier?
By combining GIS visualization, road and settlement connectivity analysis, field reporting, offline-first design, policy-based authorization, and AWS-oriented development tools, we created a prototype that explores this approach.
The most important part of the project for us was not any individual technology. It was learning how different technologies can work together to address a real-world problem.
For disaster-prone regions, knowing that a road is blocked is useful.
Understanding which communities could become isolated because of that blocked road can be even more useful.
That is the idea behind NER Landslide Guard.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article