Der Drohnentrupp steht am Einsatzort, dat UAV is startklar - aber bevor irgendwat fliegt, muss dokumentiert werden. Und die Dokumentation? Die liegt im Fahrzeug. Auf Papier. Na super.
Papier bleibt im Gerätewagen
Im Katastrophenschutz fliegen Drohnen nich einfach so los. Bevor ’n UAV abheben darf, geht der Trupp durch ’n strukturierten Prozess: Einsatzdaten erfassen, Wetter bewerten, ’ne SORA-Risikoeinschätzung machen, die Fluganmeldung vorbereiten, Checklisten abarbeiten. Nachm Flug kommt die Nachbereitung. Dat alles wird bis getz auf Papier dokumentiert - im Gerätewagen Aufklärungstrupp Luft, dem GW AufklTruLu.
Dat funktioniert. Irgendwie. Aber et hat Grenzen, und die merkse im Einsatz.
Dat erste Problem is der Ort. Die Papierdokumentation wird im Fahrzeug ausgefüllt. Der Pilot steht aber am UAV - oft dutzende Meter wech. Aktuelle Wetterdaten nachgucken? Zurück zum Fahrzeug. ’ne Checkliste prüfen? Zurück zum Fahrzeug. ’ne Prozedur nachlesen, weil die Lage dat verlangt? Zurück zum Fahrzeug. Oder ausm Kopp. Im Einsatz is beides nich dat Gelbe vom Ei.
Dat zweite Problem sind die Prozeduren. Normal-, Contingency- und Emergency-Verfahren - festgeschrieben als N1 bis N6, C0 bis C6 und E1 bis E3 - liegen als einzelne Dokumente im Fahrzeug. Dat sind die Handlungsanweisungen für alles, wat schiefgehen kann: vom normalen Betrieb über Störungen bis hin zum kompletten Kontrollverlust. Im Stress, am UAV, mit Wind und Lärm, hasse die Dokumente nich dabei. Musse auswendig können. Oder eben: zurück zum Fahrzeug.
Dat dritte Problem is dat Rechnen. Papier kann nich rechnen. Die Windgeschwindigkeit am Boden sagt wenig darüber, wat auf 120 Meter Flughöhe los is - dafür brauchse ’ne Interpolation.
Wat is SORA?
SORA (Specific Operations Risk Assessment) is ’n standardisiertes Verfahren zur Risikobewertung von Drohnenflügen. Dat kombiniert zwei Dimensionen: dat Ground Risk (GRC) - wie gefährlich is ’n Absturz für Menschen am Boden? - und dat Air Risk (ARC) - wie wahrscheinlich is ’ne Kollision im Luftraum? Aus beiden ergibt sich dat SAIL (Specific Assurance and Integrity Level), dat festlegt, welche Sicherheitsmaßnahmen für den Flug nötig sind. Die Berechnung is kein Bauchgefühl, sondern ’ne definierte Matrix mit konkreten Eingangsgrößen.
Die SORA-Bewertung - GRC plus ARC ergibt SAIL - machse auf Papier von Hand, fehleranfällig, und jedes Mal von vorne.
Wat is EGRED?
EGRED steht für Empfehlungen für Gemeinsame Regelungen zum Einsatz von Drohnen im Bevölkerungsschutz. Rausgegeben vom BBK (Bundesamt für Bevölkerungsschutz und Katastrophenhilfe), legt dat Dokument in seiner zweiten Fassung (EGRED 2) unter anderem fest, wat ’ne strukturierte Einsatzdokumentation für Drohnenflüge im BOS-Kontext können muss.
Genau diese strukturierte Dokumentation fordert EGRED 2. Nich als Empfehlung, sondern als Grundlage für den regelkonformen Betrieb von UAVs im Bevölkerungsschutz. Die Dokumentation soll nachvollziehbar, vollständig und standardisiert sein. Papier kann dat leisten - aber et kann nich helfen. Et rechnet nich, et erinnert nich, et is nich da, wo der Pilot steht.
’n Smartphone schon. Dat hasse am Körper, dat funktioniert offline, dat kann rechnen. Wetterdaten anzeigen, Checklisten führen, Prozeduren nachschlagen, SORA-Werte ausrechnen - alles direkt am UAV, nich im Fahrzeug. Nich als Ersatz für den Prozess, sondern als Werkzeug, dat den Prozess dahin bringt, wo er gebraucht wird. ’ne Progressive Web App (PWA) - also ’ne Anwendung, die im Browser läuft, sich wie ’ne normale App anfühlt und auch offline funktioniert.
’ne Papierdokumentation im Gerätewagen kann keine Windgeschwindigkeit auf 120 Meter Höhe interpolieren.
Wat wär, wenn genau dat - Dokumentation, Berechnung, Checklisten, Prozeduren - alles aufm Smartphone laufen würde? Offline-fähig, direkt am Einsatzort?
Vonne Papierliste zur PWA: Wat die App kann
Die App heißt “UAV Einsatzverwaltung”. Keine Tabelle, kein PDF-Formular - ’ne Progressive Web App, die direkt im Browser läuft und auf jedem Einsatz-Tablet funktioniert.
Der Ablauf hält sich an dat, wat im Einsatz wirklich passiert. Vier Phasen, angelehnt an dat EGRED-Schema:
1. Einsatzdaten erfassen
Standort per GPS oder von Hand eingetippt. Drohnenauswahl aus fertigen Profilen - aktuell DJI Matrice 350 RTK und DJI Matrice 200, jeweils mit ihren eigenen Grenzwerten. Crew-Stärke, Einsatzauftrag, und ’ne interaktive Karte mit Zeichenwerkzeugen: Der Standort wird als Kreis-Marker gesetzt, dat Suchgebiet per Polygon eingezeichnet.

2. Vorflugkontrolle - dat Herzstück
Hier passiert dat, wat auf Papier nie funktioniert hat: automatische Umgebungsanalyse in Echtzeit.
Wetter: Die App zieht sich aktuelle Daten von Open-Meteo - Wind, Böen, Temperatur, Niederschlag, Sichtweite, Luftfeuchtigkeit, Druck, Taupunkt. Jeder Wert kricht ’ne Ampelbewertung: grün, gelb, rot - abgeglichen gegen die Grenzwerte vonne gewählten Drohne. Die Windgeschwindigkeit wird auf die echte Flughöhe interpoliert, auf Basis von Messdaten bei 10m, 80m, 120m und 180m. Kein Bauchgefühl mehr, ob “der Wind da oben wohl schlimmer is”.

Geomagnetik: Der K-Index von NOAA SWPC zeigt, ob geomagnetische Störungen den Kompass vonne Drohne durcheinanderbringen könnten. Klingt exotisch, is aber ’n echtes Risiko - besonders bei der Matrice-Serie.
Umgebung: Über OpenStreetMap und Overpass-API prüft die App automatisch, wat im Einsatzgebiet so alles liegt. Lufträume, Straßen, Bahnlinien, Stromleitungen, Krankenhäuser, Naturschutzgebiete. Alles, wat de sonst von Hand auf ’ner Karte suchen müsstest.
SORA-Risikobewertung: Bodenrisiko (GRC) plus Luftraumrisiko (ARC) ergeben zusammen dat SAIL - dat Specific Assurance and Integrity Level. Die App rechnet dat automatisch aus den erfassten Daten aus. Wat vorher ’n Diagramm war, dat ich von Hand durchgehen musste, is getz ein Klick.
Dazu kommen technische Checklisten für die Drohne selber. Propeller, Akkus, Firmware, Kamera - Punkt für Punkt.
3. Flüge und Nachbereitung
Die letzten beiden Phasen machen den Sack zu: Jeder Flug wird einzeln dokumentiert (Startzeit, Landezeit, Besonderheiten), danach baut die App ’n kompletten PDF-Bericht - alle Wetterdaten, Checklisten, Flugzeiten, Karten in einem Dokument. Dat is dat, wat am Ende inne Einsatzakte landet.

Wichtig für die Praxis: ’n Einsatz kann mehrere Standorte haben. Hochwasserlage mit drei Erkundungspunkten? Ein Einsatz, drei Segmente, jedes mit eigener Vorflugkontrolle und eigenen Flügen.
Prozeduren direkt inne App
Alle Normal-, Contingency- und Emergency-Verfahren sind inne App hinterlegt. Nich als PDF-Anhang, sondern als Checklisten, durch die de dich durchklicken kannst.
’n paar Beispiele:
- N1 “Vor dem Start”: “Check Controlled Ground hergestellt” - “Call Out: CLEAR PROP!”
- C4.2 “Bemanntes Luftfahrzeug”: “Call Out: UNBEKANNTES LUFTFAHRZEUG!” → Landung einleiten
- E1 “Terminierung”: “Call Out: ABSTURZ! ABSTURZ! ABSTURZ!”
Wer unter Stress die richtige Prozedur finden muss, scrollt nich durch ’n Handbuch mit 30 Seiten. Die Prozeduren N1 bis N6, C0 bis C6 und E1 bis E3 plus Notfallpläne (ERP) sind alle einen Tap wech.
So weit die Features aus Nutzersicht. Aber ’ne App, die Wetterdaten zieht, GPS nutzt und PDFs baut - braucht die nich ’n fettes Backend? Spoiler: Nee.
Kein Backend, kein Problem: Local-First als Designentscheidung
’ne BOS-Einheit im Ehrenamt hat kein Budget für Server-Infrastruktur. Keinen Admin, der sich um Datenbanken kümmert. Und keinen Bock auf Cookie-Banner, DSGVO-Verfahrensverzeichnisse und Cloud-Abos. Also: kein Backend.
Dat klingt nach Einschränkung. Is et aber nich - dat is ’ne Architekturentscheidung.
Alles wohnt im Browser
Sämtliche Einsatzdaten, Formulareingaben und Karten-Overlays werden in localStorage gespeichert. Kein Server, keine Datenbank, keine Accounts. Der Browser is die Datenbank. ’n Service Worker sorgt dafür, dat die App auch ohne Mobilfunknetz läuft - nachm ersten Laden funktioniert alles offline. Auch im Funkloch hinterm Kiosk.
Für Nicht-Entwickler heißt dat: Link aufmachen, fertig. Keine Anmeldung, kein “Server nicht erreichbar”, kein “bitte aktualisiere die App”. Für Entwickler: Die Caching-Architektur is geschichtet wie die Flöze unter Tage, und jede Schicht hat ihre eigene Strategie.
Tech Stack im Detail
| Technologie | Version | Zweck |
|---|---|---|
| React | 19 | UI-Framework |
| TypeScript | 5.9 (strict) | Typsicherheit |
| Vite | 8 | Build-Tool und Dev-Server |
| Tailwind CSS | 4 | Utility-First Styling |
| React Router | 7 | Client-Side Routing |
| TanStack Query | 5 | Server-State und Caching |
| React Leaflet | 5 | Kartenintegration |
| Leaflet Geoman | - | Zeichenwerkzeuge |
| jsPDF | - | PDF-Generierung |
| React Compiler | - | Auto-Memoization |
| vite-plugin-pwa | - | PWA mit Workbox Service Worker |
| Sentry | - | Error-Tracking |
Caching-Schichten
Nich jede API-Antwort wird gleich behandelt. Wetterdaten sind nach Minuten alt, Kartenkacheln halten monatelang, Umgebungsdaten ändern sich selten. Die Strategie je Datentyp:
| Daten | Strategie | Haltbarkeit |
|---|---|---|
| Wetter (Open-Meteo) | NetworkFirst | 10 Minuten |
| K-Index (NOAA) | NetworkFirst | 1 Stunde |
| Kartenkacheln (OSM) | CacheFirst | 7 Tage |
| Umgebung (Overpass) | localStorage | 8 Stunden |
| Einsatzdaten | localStorage | 56h aktiv / 24h abgeschlossen |
TanStack Query übernimmt dat State-Management für alle API-Calls und schreibt die Query-Caches nach localStorage - so überleben gecachte Wetterdaten sogar ’n Browser-Neustart. Der Service Worker über Workbox fängt Netzwerk-Requests ab und liefert je nach Strategie die gecachte oder die frische Antwort.
Der bewusste Trade-off
Daten leben nur aufm Gerät. Kein Sync zwischen Tablet und Smartphone. Aktive Einsätze werden nach 56 Stunden automatisch gelöscht, abgeschlossene nach 24 Stunden. Dat is kein Versehen - ’n Einsatz is ’n Einsatz, kein Archiv. Der PDF-Bericht is dat Archiv.
Und die App is ’ne PWA: installierbar wie ’ne native App, aber ohne Store am Hals. ’n Link reicht. Kein Apple-Developer-Account, kein Google-Play-Review. Update deployen, und beim nächsten Aufmachen hat jeder die neue Version.
Warum nich einfach ’ne normale App? Weil jede Alternative Nachteile hat, die im Ehrenamt schwer wiegen:
| Native App | Cloud-App | PWA Local-First | |
|---|---|---|---|
| Installation | App Store | Keine | Link / Startbildschirm |
| Offline | Jau | Nee | Jau (nachm ersten Laden) |
| Server nötig | Nee | Jau | Nee |
| Updates | Store-Review | Sofort | Sofort |
| Kosten | Entwicklerlizenz | Server + DB | Hosting (statisch) |
| Datenschutz | Lokal | Cloud | Lokal |
Dat Ehrenamt braucht keine Cloud-Abos. Dat braucht Tools, die funktionieren, wenn dat Mobilfunknetz nich funktioniert.
Aber wie baut man so ’ne App? Mit React, TypeScript, Service Workern, Karten, PDF-Generierung, Offline-Caching - alles auf einmal? Die Antwort: mit AI. Aber nich so, wie de vielleicht denkst.
Wat die KI gebaut hat - und wat nich
Claude Code war mein Kumpel beim Coden für dieses Projekt. Ich wusste, wat am Ende rauskommen soll - die Anforderungen haben wa zusammen ausformuliert, aber dat Zielbild kam von mir. Die Aufgaben waren klar verteilt - und dat war kein Zufall.
Wat die AI geliefert hat
Die AI konnte in Minuten dat technische Gerüst hochziehen - Oberfläche, Karten, Offline-Fähigkeit, PDF-Generierung. Für jede einzelne von diesen Technologien hätt ich Doku lesen, Beispiele suchen und Boilerplate schreiben müssen. Responsive Design? Prompt. Service Worker Registration? Prompt. Offline-fähige Kartenkacheln? Prompt.
Dat die Wetter-API Windwerte auf mehreren Höhen liefert und die AI von sich aus ’ne Interpolation für die echte Flughöhe gebaut hat - dat musst ich nich erklären. Dat is der Teil, den AI-Coding-Tools gut können: technische Umsetzung mit bekannten Patterns.
Welche Technologien die AI umgesetzt hat
Die technische Breite kann sich sehen lassen: React-Komponenten, Tailwind-Layout, API-Integration mit Open-Meteo und Overpass, Caching über TanStack Query und Service Worker, PWA-Setup mit Workbox, PDF-Generierung mit jsPDF, Kartenintegration mit Leaflet. Dat alles gleichzeitig, in einer Codebasis, mit einheitlichen TypeScript-Typen.
Wat die AI nich wusste
Und hier wird et spannend. Die AI hatte keinen Schimmer von:
- EGRED-Phasen und ihrer Reihenfolge - dat ’n Drohneneinsatz von Einsatzdaten über Vorflugkontrolle und Flüge bis zur Nachbereitung ’nem festen Ablauf folgt
- SORA-Methodik - wie Ground Risk Class, Air Risk Class und SAIL zusammenhängen und berechnet werden
- Contingency- und Emergency-Prozeduren - über 15 Verfahren mit eigenen Call-Outs, Rollen (RPIC, RP, Bodenpersonal) und Eskalationspfaden
- Wetter-Grenzwerte pro Drohnenmodell - die hab ich über die Bedienungsanleitung vonne Drohne reingegeben, die AI hat sich die wichtigen Werte selber rausgezogen
- Einsatzstruktur - dat ’n Einsatz mehrere Segmente mit unterschiedlichen Standorten haben kann
- Fachbegriffe - “Controlled Ground”, “Flight Geography”, “Contingency Volume”, der Unterschied zwischen RPIC und RP
Kein Prompt vonne Welt hätte diese Infos ausgespuckt. Die stecken in Betriebshandbüchern, SORA-Dokumenten und Einsatzerfahrung. Die AI kann Prozeduren umsetzen - aber nich erfinden.
Wer wat wirklich macht
Mensch: Domain-Wissen, Architekturentscheidungen (kein Backend, alles offline-fähig), fachliche Anforderungen, Grenzwerte, Prozeduren, Ergebnisse prüfen.
AI: Tempo beim Umsetzen, technische Breite übern ganzen Stack - React, TypeScript, Tailwind, Service Worker, PDF-Generierung, Kartenintegration - alles parallel, alles aus einem Guss.
Dat is keine Arbeitsteilung zwischen “denken” und “tippen”. Beide Seiten liefern Substanz. Aber die AI liefert Substanz nur da, wo et bekannte Lösungen für bekannte Probleme gibt. Die fachliche Domäne - die besonderen Regeln, die besonderen Abläufe, die besonderen Grenzwerte - die muss ’n Mensch mitbringen.
Kein Vibe Coding
2026 wird viel über Vibe Coding gequatscht. “Bau mir eine Drohnen-App” als Prompt liefert ’ne hübsche UI mit ausgedachten Daten. Keine echten Prozeduren. Keine korrekten Grenzwerte. Keine valide SORA-Berechnung. Nix, worauf sich einer in ’nem echten Einsatz verlassen könnte. Dat is Schaufenster ohne Laden.
Wat funktioniert: “Implementiere diese Contingency-Prozedur. Phase C4.2 bedeutet: Bodenpersonal meldet bemanntes Luftfahrzeug, RPIC initiiert Landung nach N6. Die Eskalation zu E1 erfolgt bei Kontrollverlust.” Dat is ’ne Spezifikation. Und Spezifikationen kann die AI umsetzen.

Dieselbe Logik wie inne vorherigen Posts: Die AI is ’n mächtiges Werkzeug - aber Werkzeug ersetzt kein Verstehen. Bei ’ner Drohnen-App im Katastrophenschutz is “falsch” keine schlechte UX, sondern ’n Sicherheitsrisiko.
Vibe Coding hört da auf, wo Domain-Wissen anfängt. Die AI kann Prozeduren umsetzen, aber nich erfinden.
Papier ablösen heißt Prozesse verstehen
Diese App is kein Technologie-Projekt. React, PWA, AI - dat sind Werkzeuge. Die eigentliche Maloche steckt woanders: inne Prozesse, die auf den Papierchecklisten stehen. Die zu verstehen, zu strukturieren und dann digital abzubilden - dat is die Arbeit.
Digitalisierung ohne Prozessverständnis produziert digitales Papier. ’n PDF aufm Tablet is keine Verbesserung gegenüber ’nem Blatt im Gerätewagen. Erst wenn ich versteh, warum ’n Schritt existiert, wer den macht und wat passiert, wenn der schiefgeht - erst dann kann ich den sinnvoll digitalisieren.
Die App wird aktuell von ’ner echten BOS-Einheit im Bevölkerungsschutz eingesetzt. Dat Feedback fließt zurück inne Prozeduren, die Prozeduren fließen zurück in den Code. Und weil andere Einheiten vor denselben Baustellen stehen, is dat Projekt Open Source - jeder kann et nutzen, anpassen und eigene Checklisten beisteuern.
Die Brücke zur Software-Architektur
Wer die vorherigen Posts von diesem Blog kennt, merkt getz wat. Inne Software-Welt gibt et Konzepte, die unter anderem Namen exakt dieselben Probleme lösen - und die Parallelen sind der Hammer:
EGRED-Checklisten sind Contracts - also verbindliche Abmachungen, wat ’n System machen soll und wat nich. Definierte Abläufe mit klaren Bedingungen, Rollen und Eskalationspfaden.
SORA is ’ne Policy Engine - ’n Regelwerk, dat automatisch entscheidet. GRC plus ARC ergibt SAIL - Input rein, Risikolevel raus. Kein Ermessensspielraum, kein “wird schon passen”.
Wetterbewertung is ’ne Eval - ’ne strukturierte Prüfung gegen definierte Kriterien. Messwerte gegen Grenzwerte prüfen, Ampelfarben vergeben, Entscheidungen ableiten.
Notfallprozeduren sind Eskalationspfade - gestufte Reaktionspläne mit klaren Triggern. C0 führt zu E1, E1 kann E3 auslösen. Jede Stufe hat eigene Regeln und Zuständigkeiten.
Die Konzepte sind dieselben. Die Domain is ’ne andere. Und genau dat macht se übertragbar - egal ob im Agent-System oder im Gerätewagen.
Die besten digitalen Tools entstehen nich aus Technologie, sondern aus Prozessverständnis - egal ob im Gerätewagen oder im Agent-System.
