SENTINEL Air Trafic Control

• 

  SENTINEL Real Time Air Traffic Control Re-Routing

• 

  SENTINEL Live Plane Monitoring

Inspiration

Modern airspace is one of the most complex distributed systems in the world. Thousands of aircraft move simultaneously through shared three-dimensional space, each with its own trajectory, speed, and constraints. Even with advanced tools, large scale emergencies require rapid coordination across hundreds of aircraft in seconds.

I was driven by a technical question: what would it take to simulate large scale airspace rerouting in real time using live aircraft data?

Rather than building another dashboard, I wanted to stress test infrastructure. Could a single Azure system ingest live plane transponder data, model geospatial constraints, project trajectory conflicts, and recompute safe routes for hundreds of aircraft in seconds?

SENTINEL applies distributed systems, parallel computation, geospatial algorithms, and AI orchestration to one of the most demanding real world coordination problems.

What it does

SENTINEL is a real-time airspace routing system that ingests live plane transponder data and models large-scale emergency rerouting scenarios.

When a restricted airspace event is introduced, the system recalculates new flight paths for hundreds of aircraft in parallel. It performs geospatial pathfinding around exclusion zones, projects aircraft trajectories forward in time, detects potential loss of separation, and prioritizes reroutes based on risk and proximity.

All updates are streamed live to a 3D globe, showing conflict-free bypass routes forming in seconds.

How I built it

Live plane transponder data is pulled from a public API (OpenSky Network) and streamed into an Azure backend built with Container Apps and Azure Functions. Each aircraft’s position, altitude, speed, and heading are cleaned, standardized, and stored in memory so the system can quickly answer questions like “which planes are near this boundary?”

When a closure event is triggered, parallel compute workers calculate new routes using A* pathfinding around the restricted zone. Instead of treating the airspace as empty, the system models it as a map with weighted regions. A trajectory projection module then estimates where each aircraft will be over the next few minutes based on its current speed and direction, checking for any predicted loss of safe separation under a five nautical mile threshold.

Weather data is added as dynamic cost layers in the routing model, meaning routes through strong winds or storms are discouraged but not automatically blocked.

Azure OpenAI acts as the coordination layer, translating verbal scenario instructions into structured actions and triggering the correct routing and safety pipelines. Final route updates are streamed through Azure Web PubSub to a CesiumJS 3D globe, where reroutes and conflict resolutions appear live in real time.

Challenges I ran into

• Turning raw plane transponder data into clean, structured aircraft states fast enough to support real time simulation on 3D globe
• Designing a routing model that was realistic enough to feel credible, but simple enough to recompute hundreds of routes in seconds
  
• Detecting future conflicts, not just current ones, by projecting aircraft forward using speed and heading
  
• Recalculating routes in parallel without creating new traffic conflicts downstream
  
• Adding weather influence to routing without turning the system into a full physics simulator
  
• Keeping total reroute time under a few seconds from trigger to visualization
  
• Streaming hundreds of updated paths to a 3D globe without dropping frames
  
• Separating what should be handled by algorithms versus what should be handled by Azure OpenAI
  
• Coordinating multiple Azure services so data flow stayed consistent under load
  
• Building and debugging the full distributed pipeline solo within hackathon time limits

Accomplishments that I'm proud of

• Successfully ingesting live plane transponder data and maintaining a continuously updated airspace model
  
• Recalculating hundreds of aircraft routes in parallel within seconds of triggering a closure event
  
• Implementing predictive conflict detection using forward trajectory projection
  
• Integrating weather as dynamic routing weights rather than static restrictions
  
• Streaming real-time reroutes to a 3D globe with visible conflict resolution
  
• Designing and deploying a distributed Azure-based architecture as a solo developer
  
• Demonstrating the entire process with visuals for easy understanding from scenario input to full airspace reroute

What I learned

• Real time systems are mostly about clean data flow and state management, not just algorithms
  
• Parallel routing is easy; preventing secondary conflicts is MUCH harder
  
• Predicting future aircraft positions requires careful handling of time and velocity, not just coordinates
• AI is best used for coordination and interpretation, not core optimization math
  
• Cloud architecture decisions directly impact latency and scalability
  
• Clear system boundaries between data ingestion, computation, and visualization make complex systems manageable

What's next for SENTINEL Air Trafic Control

• Replacing simplified routing with real world flight paths based on actual airways and waypoints
  
• Scaling from regional tests to continent wide airspace simulations
  
• Modeling traffic buildup over time to simulate congestion in busy sectors
  
• Using higher resolution weather data for more realistic route adjustments
  
• Adding airport arrival and departure limits to reflect real capacity constraints
• Running repeated large scale simulations to test how the system handles chain reactions and cascading delays
• Stress testing the system with thousands of aircraft to measure scalability on Azure
  

Basically, the next step is to incorporate real world regulatory constraints, controlled airspace classes, mandated separation standards, and federally defined reroute procedures.

Built With

• a-star-geospatial-pathfinding
• azure-application-insights
• azure-container-apps
• azure-functions
• azure-maps
• azure-monitor
• azure-openai-gpt-4o
• azure-web-pubsub
• cesiumjs
• docker
• event-driven-distributed-architecture
• node.js
• opensky-network-api
• python
• spatial-indexing-r-tree
• trajectory-projection-modeling
• typescript
• websockets