Autonomous Drone UTM Platform
Autonomous drones need an accurate, real-time understanding of the world around them: terrain, obstacles, restricted airspace, and other aircraft. For a company scaling autonomous drone operations, we built the UTM platform that gave them exactly that — a live, multi-dimensional model of the operational environment that supported flight planning, safety monitoring, and coordination with other operators.
- Designed and implemented core geospatial APIs for airspace, elevation, and flight intents using Clojure, PostGIS, and gRPC
- Solved complex altitude reference conversions (WGS84, MSL, AGL) with precise geometry contouring
- Developed optimized A* and Theta* pathfinding algorithms for fast, constraint-aware 4D route planning
- Built a responsive Mapbox visualization and alerting system that smoothly handled 100+ concurrent flights and hundreds of updates per second during load testing
- Created a self-documenting API portal with live demonstrators, including gRPC testing via WebSocket proxy
- Integrated Redis + PubSub, OpenTelemetry, and feature flags for reliability and observability on Kubernetes
Full Story
A company building autonomous drone operations needed far more than a simple mapping tool. Their drones had to understand the real world in four dimensions (3D space plus time) while staying compliant with regulations and coordinating safely with other operators.
The challenge was significant. Everything used different altitude references (WGS84, MSL, AGL). Temporary no-fly zones could appear with almost no notice. We had to ingest data from multiple sources, normalize it, run flight planning algorithms, broadcast flight intents through the InterUSS platform, and give pilots and operators a single pane of glass to monitor everything in real time.
I was one of the primary developers on the team responsible for turning this vision into reality. We built a suite of Clojure services that delivered airspace and elevation data through both REST and gRPC APIs. I worked extensively on the altitude normalization service (one of the trickiest parts), converting between references with high accuracy and contouring complex AGL volumes so they remained correct after transformation.
Flight planning was another highlight. We implemented A* and Theta* algorithms tuned for our use case, balancing optimality, regulatory compliance, and speed. These routes had to be generated fast enough for real operations.
On the frontend side, we created a rich Mapbox visualization tool that showed live and historical flights, other operators' traffic, ADS-B tracks, and active alerts. Keeping that interface responsive under heavy load was a huge undertaking: at peak we were rendering 100+ simultaneous flights with hundreds of position updates arriving every second. The interface still gave pilots immediate visual and audible warnings when something was off.
We also built a comprehensive API documentation site. Every endpoint had rich documentation and a live demonstrator. I even helped implement a WebSocket proxy so developers could test gRPC calls directly in the browser.
As the platform grew, we integrated Redis and PubSub to keep realtime features reliable across our Kubernetes cluster, along with OpenTelemetry for observability and Slack alerting so we could respond to issues within minutes.
This project was one of the most technically interesting I've worked on — safety-critical systems, complex geometry, realtime constraints, and cross-organization coordination. It remains a great example of building software that has to work when it really matters.