DEV Community: Mohit Upadhyay

Building DSIE — AI-Powered Disaster Signal Intelligence & Emergency Escalation System with Kestra 🚨

Mohit Upadhyay — Wed, 13 May 2026 11:43:21 +0000

When disasters strike, response time becomes critical.

Floods, earthquakes, cyclones, wildfires, and humanitarian emergencies generate massive amounts of fragmented information across different global platforms. Emergency teams and authorities often struggle with:

scattered disaster signals
delayed intelligence
lack of prioritization
incomplete geo-location data
slow operational escalation

I wanted to explore how workflow orchestration + AI could help bridge that gap.

So I built DSIE (Disaster Signal Intelligence & Emergency Escalation) — AI-powered orchestration workflow using Kestra that continuously monitors real-time disaster feeds, extracts structured intelligence, prioritizes severity, and generates emergency escalation dashboards automatically.

🚨 What DSIE Does

DSIE is a real-time disaster intelligence pipeline that:

✅ Monitors live disaster feeds
✅ Detects active emergency incidents
✅ Extracts geo-intelligence
✅ Prioritizes disaster severity
✅ Generates AI-powered operational insights
✅ Creates Google Maps escalation links
✅ Sends emergency dashboards instantly via email

The system is designed to help operational teams and emergency authorities respond faster during critical situations where response time directly impacts lives and infrastructure.

🌍 Real-Time Disaster Intelligence Sources

To build a reliable emergency intelligence pipeline, DSIE continuously ingests and correlates disaster signals from multiple trusted global and regional monitoring systems.

These sources provide real-time operational data related to earthquakes, floods, cyclones, wildfires, environmental hazards, and humanitarian emergencies.

🌐 GDACS — Global Disaster Alert and Coordination System

GDACS provides worldwide disaster alerts and early coordination intelligence for major emergency events.

DSIE uses GDACS for:

Earthquake alerts
Flood monitoring
Cyclone tracking
Wildfire detection
Large-scale disaster escalation signals

🌎 USGS — United States Geological Survey

USGS delivers highly reliable real-time earthquake intelligence through structured GeoJSON feeds.

DSIE uses USGS for:

Real-time earthquake monitoring
Magnitude analysis
Epicenter geo-coordinates
Seismic activity tracking

🆘 ReliefWeb — Humanitarian Information Platform

ReliefWeb aggregates emergency updates and humanitarian operational intelligence from international organizations.

DSIE uses ReliefWeb for:

Active humanitarian crisis monitoring
Emergency operational updates
Escalation-related disaster signals
Global relief situation awareness

By combining multiple intelligence sources into a single orchestrated pipeline, DSIE creates a more comprehensive and operationally useful disaster monitoring system.

⚙️ Workflow Architecture

DSIE is orchestrated entirely using Kestra, enabling automated real-time disaster intelligence processing through a structured multi-stage execution pipeline.

The workflow continuously executes the following stages:

Schedule Trigger
      ↓
Collect Real-Time Disaster Signals
      ↓
Normalize & Prioritize Incidents
      ↓
AI Emergency Intelligence Enrichment
      ↓
Generate Operational Dashboard Cards
      ↓
Send Emergency Escalation Dashboard via email

Each stage is independently orchestrated inside Kestra, making the system modular, observable, and production-oriented.

⏰ Real-Time Monitoring with Kestra

DSIE continuously runs on a scheduled interval using Kestra triggers.

The workflow automatically executes every 15 minutes:

triggers:

  - id: realtime_monitor
    type: io.kestra.plugin.core.trigger.Schedule

    cron: "*/15 * * * *"

This enables continuous disaster intelligence monitoring without manual intervention.

📡 Multi-Source Disaster Signal Collection

One of the core components of DSIE is its disaster signal ingestion layer.

The workflow dynamically collects real-time disaster intelligence from:

RSS feeds
GeoJSON APIs
public emergency monitoring systems

Example GDACS ingestion:

gdacs = feedparser.parse(
    "https://www.gdacs.org/xml/rss.xml"
)

Example USGS earthquake monitoring:

usgs = requests.get(
    "https://earthquake.usgs.gov/earthquakes/feed/v1.0/summary/significant_day.geojson"
).json()

All incoming incidents are normalized into a structured operational format before downstream processing.

🧠 Deterministic Severity Prioritization

Before invoking AI, DSIE first applies deterministic severity scoring logic.

Each incident is prioritized based on:

disaster category
earthquake magnitude
operational criticality
escalation risk

Example scoring logic:

if category == "Earthquake":
    score += 10

elif category == "Cyclone":
    score += 9

Additional escalation scoring is applied for high-magnitude seismic events:

if magnitude >= 7:
    score += 10

This hybrid deterministic + AI approach improves reliability and reduces hallucination risks.

🤖 AI-Powered Emergency Intelligence

After deterministic prioritization, incidents are enriched using GitHub Models (GPT-4o).

The AI layer generates:

operational impact assessments
emergency action recommendations
escalation readiness analysis
geo-intelligence enrichment
structured incident summaries

Example extraction schema:

Extract:
- incident_type
- category
- city
- country
- priority
- severity_score
- impact_assessment
- required_action

The AI layer acts as an operational intelligence enrichment system — not the primary decision engine.

📍 Geo-Intelligence & Google Maps Escalation

DSIE automatically generates escalation-ready geo-intelligence for operational teams.

When latitude and longitude are available:

map_link = f"https://www.google.com/maps?q={latitude},{longitude}"

Otherwise, the workflow dynamically generates Google Maps escalation links using inferred location intelligence.

This enables faster situational awareness and quicker emergency coordination during critical incidents.

📧 Operational Dashboard Generation

One of the most impactful parts of building DSIE was designing a fully automated operational intelligence dashboard pipeline orchestrated end-to-end using Kestra.

Once disaster incidents are collected, normalized, prioritized, and enriched with AI-generated intelligence, Kestra orchestrates the downstream execution pipeline to dynamically generate structured HTML escalation dashboards using Python tasks.

Each incident card includes:

severity-based escalation color coding
operational priority indicators
AI-generated emergency intelligence
impact assessments
recommended response actions
escalation readiness status
geo-intelligence with Google Maps escalation links

The final output is automatically delivered as a production-style emergency dashboard email optimized for rapid operational readability during critical situations.

This was one of the moments where the orchestration power of Kestra became extremely visible — transforming multiple independent processing stages into a single automated operational pipeline.

Example Emergency Dashboard

🎨 Incident Priority Visualization

To improve operational visibility and escalation readiness, each disaster incident is classified using deterministic severity scoring and visual escalation indicators.

Priority	Operational Meaning
🔴 CRITICAL	Immediate emergency response required
🟠 HIGH	High operational risk
🟡 MEDIUM	Active monitoring required
🟢 LOW	Routine operational monitoring

This enables emergency teams and operational responders to quickly identify incidents requiring immediate attention.

🔐 Production-Ready Secret Management with Kestra

Since DSIE executes automatically on scheduled intervals, securely managing credentials becomes essential for production reliability.

Instead of hardcoding sensitive values directly into workflows, DSIE uses Kestra Secrets for secure runtime credential management.

Examples include:

GitHub PAT tokens
SMTP credentials
recipient escalation emails

Example:

variables:
  github_pat: "{{ secret('GITHUB_PAT') }}"

This provides several major advantages:

✅ Secure credential handling
✅ Safer production deployments
✅ Reduced exposure risk
✅ Cleaner orchestration architecture
✅ Reliable scheduled execution without runtime input failures

Kestra’s built-in secret management made it significantly easier to build a production-oriented workflow without introducing additional infrastructure complexity.

🏗 Core Workflow Modules

DSIE is organized into modular orchestration stages fully managed by Kestra.

1. Disaster Signal Collection

Continuously ingests disaster intelligence from multiple real-time monitoring systems.

2. Incident Normalization

Standardizes incoming disaster metadata into a unified operational structure.

3. Deterministic Prioritization

Assigns severity scores and escalation levels using rule-based operational logic.

4. AI Intelligence Enrichment

Enhances incidents with operational intelligence using GPT-4o.

5. Dashboard Generation

Dynamically generates structured HTML escalation dashboards using Python execution tasks.

6. Emergency Notification

Automatically delivers operational dashboards through email escalation workflows.

Because each stage is independently orchestrated inside Kestra, the workflow becomes significantly easier to:

extend
debug
monitor
retry
maintain
scale

This modular orchestration model is one of the biggest strengths of workflow-first system design.

🚀 Why Kestra Was a Great Fit

One of the biggest advantages of building DSIE with Kestra was how naturally it handled orchestration complexity.

Instead of manually building backend infrastructure for:

scheduling
retries
task execution
secret management
execution observability
workflow chaining
automation coordination

Kestra provided these capabilities natively.

What made Kestra especially powerful for this project:

✅ Event-driven orchestration
✅ Built-in scheduling triggers
✅ Python script execution
✅ HTTP API integrations
✅ Secret management
✅ Workflow observability
✅ Multi-stage execution pipelines
✅ Production-ready automation architecture

Another aspect I particularly liked was Kestra’s ecosystem and extensibility.

Kestra provides:

flows
triggers
inputs/outputs
expressions
flowable tasks
execution tracking
secrets handling
plugins and blueprints

along with a massive integration ecosystem supporting APIs, cloud systems, databases, AI services, messaging systems, DevOps tooling, and infrastructure automation.

This dramatically accelerates workflow development.

Instead of spending time building orchestration infrastructure manually, developers can focus directly on solving operational problems and designing intelligent automation systems.

That shift in abstraction is extremely powerful.

💡 Key Learning

One of the biggest realizations while building DSIE was this:

AI alone is not enough for real operational systems.

Production-grade intelligence pipelines require:

orchestration
deterministic validation
structured execution flows
external integrations
observability
escalation pipelines
operational reliability

AI becomes significantly more powerful when combined with orchestration systems capable of transforming fragmented signals into actionable operational intelligence.

That is where orchestration platforms like Kestra become incredibly valuable.

⚡ Final Thoughts

DSIE started as an experiment around disaster intelligence orchestration.

But during development, the project evolved into something much more interesting:

a real-time operational intelligence pipeline capable of transforming distributed disaster signals into structured emergency escalation workflows.

The real value was not simply generating AI summaries.

The real value was:

transforming fragmented disaster intelligence into actionable operational workflows capable of accelerating emergency response.

And orchestration is what made that possible.

Built with:

Kestra
GitHub Models
Python
Real-time disaster intelligence feeds
Kestra Academy

Because every minute matters during emergencies. 🚨

Start building workflows that solve real operational problems — not just isolated automations.

🚀 Building OSSI — An AI-Powered Open Source Intelligence System with Kestra

Mohit Upadhyay — Thu, 07 May 2026 19:06:46 +0000

Transforming GitHub issues into contributor intelligence using AI + Workflow Orchestration

Open source projects are growing faster than ever.

Every day repositories receive:

Bug reports
Feature requests
Contributor discussions
Engineering questions
Documentation improvements
Infrastructure problems

But there’s a major challenge:

Maintainers are overwhelmed.

Important issues get buried.
Contributors struggle to find meaningful tasks.
Stale issues pile up.
Project health slowly declines.

So I built:

OSSI — Open Source Signal Intelligence System

An AI-powered orchestration platform built using Kestra that transforms GitHub repositories into actionable contributor intelligence.

🔗 GitHub Repository:
https://github.com/Mohit5Upadhyay/ossi-intel-orchestrator

🧠 What is OSSI?

OSSI stands for:

Open Source Signal Intelligence System

It’s an autonomous workflow orchestration platform that:

✅ Monitors GitHub repositories
✅ Fetches live GitHub issues
✅ Detects stale issues
✅ Uses AI to analyze engineering complexity
✅ Prioritizes issues automatically
✅ Recommends contributor actions
✅ Generates intelligence reports
✅ Sends automated engineering summaries via email
✅ Runs continuously on schedules using Kestra

Instead of manually reading hundreds of issues, OSSI creates an intelligent engineering layer over open-source repositories.

🤔 Why Does OSSI Matter?

Open source maintainers deal with a serious scaling problem.

As repositories grow:

Issue backlogs explode
Contributors become confused
Duplicate issues increase
Stale tickets accumulate
Prioritization becomes difficult

And contributors face problems too:

Contributors struggle with:

Finding beginner-friendly issues
Understanding issue complexity
Knowing project priorities
Discovering impactful tasks
Understanding technical context

OSSI solves this by turning repositories into structured engineering intelligence systems.

⚡ What OSSI Actually Does

The workflow continuously scans repositories and transforms raw GitHub data into actionable insights.

Example Intelligence Generated

OSSI automatically identifies:

High-priority issues
Beginner-friendly tasks
Advanced engineering problems
Potential stale issues
Contributor recommendations
Root cause analysis
Suggested implementation steps

Example AI-generated output:

Priority: High

Difficulty: Intermediate

Good First Issue: Yes

Root Cause:
Missing validation layer causing inconsistent API responses.

Quick Fix Approach:
1. Add schema validation
2. Implement middleware checks
3. Add automated tests

This turns raw GitHub issues into contributor-ready engineering tasks.

🚀 Why Kestra Was the Perfect Choice

This entire system is powered by Kestra.

And honestly — Kestra completely changed how I think about automation.

Most automation tools feel like:

Task runners
Cron jobs
Simple scripting systems

But Kestra feels like:

Infrastructure orchestration
Workflow operating systems
AI pipeline orchestration
Distributed automation architecture

🔥 What Makes Kestra Powerful

1️⃣ Everything is Declarative

The entire orchestration pipeline is written in YAML.

2️⃣ Built-in Scheduling

OSSI runs every 6 hours automatically.

triggers:
  - id: scheduled_ossi_scan
    type: io.kestra.plugin.core.trigger.Schedule

    cron: "0 */6 * * *"

    timezone: "Asia/Kolkata"

No external schedulers needed.

3️⃣ Parallel Processing

OSSI processes repositories dynamically using ForEach.

- id: process_repositories
  type: io.kestra.plugin.core.flow.ForEach

  values: "{{ inputs.repositories }}"

This allows multi-repository intelligence generation.

4️⃣ Native API Integrations

Kestra makes API orchestration incredibly easy.

Example GitHub issue fetching:

- id: fetch_open_issues
  type: io.kestra.plugin.core.http.Request

  method: GET

  uri: "{{ vars.github_api }}?q=repo:{{ taskrun.value }}+is:issue+is:open"

  headers:
    Authorization: "Bearer {{ inputs.github_pat }}"

This is extremely clean compared to building everything manually.

5️⃣ AI Workflow Orchestration

One of the most powerful parts:

Kestra orchestrates AI systems beautifully.

OSSI sends repository issue data into AI models for:

Engineering analysis
Contributor recommendations
Priority ranking
Root cause reasoning
Issue classification

This is where orchestration becomes much more than automation.

🏗️ OSSI Workflow Architecture

Here’s the full orchestration pipeline:

graph TD
    A[Schedule Trigger] --> B[Process Repositories]
    B --> C[Fetch GitHub Issues]
    C --> D[Process Issue Data]
    D --> E[AI Contributor Analysis]
    E --> F[Generate Intelligence Report]
    F --> G[Send Email Report]
    G --> H[Workflow Completed]

🔍 Deep Dive Into the Workflow

1️⃣ Workflow Trigger

The workflow starts automatically every 6 hours.

triggers:
  - id: scheduled_ossi_scan
    type: io.kestra.plugin.core.trigger.Schedule

    cron: "0 */6 * * *"

    timezone: "Asia/Kolkata"

This transforms OSSI into a continuously running intelligence system.

2️⃣ Processing Multiple Repositories

OSSI supports multiple repositories dynamically.

inputs:

  - id: repositories
    type: ARRAY
    itemType: STRING

Example repositories:

defaults:
  - "kestra-io/kestra"
  - "open-metadata/OpenMetadata"

3️⃣ GitHub Issue Intelligence

The workflow fetches live issues directly from GitHub APIs.

- id: fetch_open_issues
  type: io.kestra.plugin.core.http.Request

  method: GET

  uri: "{{ vars.github_api }}?q=repo:{{ taskrun.value }}+is:issue+is:open"

This creates a real-time engineering data stream.

4️⃣ Data Processing Using Shell + jq

After fetching issues, OSSI processes repository data.

commands:
  - |
    cat repo_issues.json | jq -r '
      .items[]
      | "
      Issue:
      #\(.number)

      Title:
      \(.title)
      "
    '

This stage transforms raw API responses into structured engineering summaries.

5️⃣ Stale Issue Detection

OSSI automatically identifies neglected issues.

select(.comments < 2)

This helps maintainers:

Reduce backlog clutter
Improve issue hygiene
Re-engage contributors

Small automation.
Massive operational value.

6️⃣ AI Contributor Analysis

This is the brain of OSSI.

The workflow sends issue summaries into an AI model.

- id: ai_contributor_analysis
  type: io.kestra.plugin.core.http.Request

The AI then generates:

Contributor recommendations
Priority analysis
Root cause insights
Engineering reasoning
Suggested implementation steps

This turns GitHub into an intelligent engineering platform.

7️⃣ 📧 SMTP Email Configuration

After generating intelligence reports, OSSI automatically delivers them using SMTP email orchestration.

Kestra makes email automation extremely clean.

Workflow email task:

- id: contributor_intelligence_email
  type: io.kestra.plugin.email.MailSend

  host: smtp.gmail.com

  port: 465

  username: "YOUR_USER_EMAIL_HERE"

  password: "YOUR_APP_PASSWORD_HERE"

  from: "YOUR_USER_EMAIL_HERE"

  to: "RECIPIENT_EMAIL_HERE"

  subject: "🚀 OSSI Intelligence Report"

  transportStrategy: SMTPS

The workflow automatically sends:

AI contributor insights
Engineering summaries
Issue prioritization
Repository intelligence
Stale issue detection reports

directly into your inbox.

8️⃣ 🤖 GitHub Models Configuration

OSSI uses GitHub Models to generate contributor intelligence automatically.

The workflow sends processed GitHub issue summaries into gpt-4o using Kestra's HTTP orchestration capabilities.

Actual workflow configuration:

- id: ai_contributor_analysis
  type: io.kestra.plugin.core.http.Request

  method: POST

  uri: "https://models.inference.ai.azure.com/chat/completions"

  headers:
    Content-Type: application/json
    Authorization: "Bearer {{ inputs.github_pat }}"

Model configuration:

{
  "model": "gpt-4o",
  "temperature": 0.2,
  "top_p": 1.0
}

The AI model performs:

Issue prioritization
Contributor recommendations
Root cause analysis
Engineering impact analysis
Difficulty classification
Beginner issue detection

This transforms OSSI into an autonomous engineering intelligence system instead of just a monitoring workflow.

9️⃣ Automated Email Intelligence Reports

🔐 Gmail SMTP Setup

To enable email delivery:

Enable 2-Factor Authentication on your Google account
Generate a Google App Password:
https://myaccount.google.com/apppasswords

Then replace:

username: "YOUR_USER_EMAIL_HERE"

password: "YOUR_APP_PASSWORD_HERE"

with your actual credentials.

This allows OSSI to autonomously deliver engineering intelligence reports after every workflow execution.

Finally, OSSI sends beautifully structured engineering reports directly to maintainers.

The report contains:

Repository intelligence
Contributor insights
Engineering priorities
Issue recommendations
AI-generated analysis

All automatically orchestrated through Kestra.

🖥️ Setting Up OSSI Locally

Now let’s actually run it.

🐳 Step 1 — Run Kestra with Docker

Download the official Kestra Docker Compose file.

Linux/macOS

curl -o docker-compose.yml \
https://raw.githubusercontent.com/kestra-io/kestra/develop/docker-compose.yml

Windows
Invoke-WebRequest -Uri "https://raw.githubusercontent.com/kestra-io/kestra/develop/docker-compose.yml" -OutFile "docker-compose.yml"

Once the file is downloaded, start Kestra using:

docker compose up -d

🧩 Step 2 — Import the OSSI Workflow

Clone the repository:

git clone https://github.com/Mohit5Upadhyay/ossi-intel-orchestrator

Open Kestra UI.

Go to:

Flows
Create Flow
Paste YAML workflow

Save the workflow.

Done.

🔐 Step 3 — Configure GitHub Token & Email Config

Generate GitHub PAT:
https://github.com/settings/tokens

Required permissions:

repo

Then configure:

github_pat
recipient_email

inside workflow inputs.

▶️ Step 4 — Execute Workflow

Run the workflow manually OR wait for the schedule trigger.

Kestra will now:

Fetch issues
Analyze repositories
Generate intelligence
Send reports

autonomously.

📊 Kestra’s Visualization is Incredible

One thing I absolutely loved:

Workflow Topology View

Kestra visualizes:

Task relationships
Dependencies
Execution structure
Processing stages

This becomes extremely useful for complex orchestration systems.

⏱️ Live Execution Tracking

Kestra also provides:

Gantt execution charts
Runtime visibility
Retry monitoring
Failure tracking
Execution logs

This makes debugging workflows much easier.

🧠 What I Learned Building OSSI

This project taught me something important:

AI becomes MUCH more powerful when combined with orchestration.

Without orchestration:

AI is isolated

With orchestration:

AI becomes infrastructure

That realization completely changed my engineering mindset.

🚀 Why Developers Should Learn Workflow Orchestration

If you're interested in:

AI Engineering
DevOps
Automation
ETL Systems
AI Agents
Distributed Systems
Event-driven architectures
Data pipelines

then orchestration is a critical skill.

And Kestra is one of the best tools I’ve used for learning it.

💡 Projects You Can Build Using Kestra

After building OSSI, I realized Kestra can orchestrate almost anything.

Some ideas:

AI code review systems
Autonomous CI/CD intelligence
DevOps monitoring pipelines
AI documentation generators
Security analysis workflows
Multi-agent AI systems

Once you start thinking in orchestration pipelines —
you begin engineering systems differently.

🔥 Why OSSI Matters for Open Source

OSSI is not just automation.

It’s:

Contributor enablement
Engineering intelligence
Repository analytics
AI-powered prioritization
Open source acceleration

It helps:

Maintainers scale better
Contributors onboard faster
Communities stay healthier
Engineering efforts become focused

And I think systems like this will become increasingly important for the future of open source.

🛠️ Technologies Used

Core Stack

Kestra
GitHub API
GitHub Models
YAML
Shell Scripting
jq
SMTP Automation

Concepts

Workflow orchestration
AI pipelines
ETL processing
Contributor intelligence
Scheduled automation
Engineering analytics

🔗 Project Links

🎯 Final Thoughts

Before this project, I thought automation meant:
“running scripts automatically”

Now I think of orchestration as:
“building autonomous engineering systems”

OSSI started as a workflow experiment.

But it evolved into:

AI infrastructure
contributor intelligence
engineering automation
orchestration architecture

And honestly...

This feels like just the beginning of AI-powered workflow systems.

If you’re learning:

AI Engineering
Automation
DevOps
Workflow Systems
Open Source Infrastructure

Build orchestration projects.

They teach you how real engineering systems operate.

And Kestra is an incredible place to start.

🚀