An interactive airline network exploration platform that transforms global flight data into dynamic graph structures using geographic visualisation, graph algorithms, and route analysis.
FlightNetworkExplorer allows users to explore airport connections, expand flight networks interactively, discover routes between destinations, and analyse airline connectivity through an interactive world map.
FlightNetworkExplorer is a full-stack aviation network analysis system built around graph-based modelling of airline routes.
Instead of treating flights as isolated records, the system represents the global airline network as a directed graph:
- Airports become graph nodes
- Flight routes become directed edges
- Graph algorithms discover paths and connections
- The frontend provides interactive geographic exploration
The application combines:
- React and Leaflet for map-based visualisation
- Spring Boot for REST APIs and backend services
- Python and NetworkX for graph computation
User Interaction
|
↓
React Interactive Map
|
↓
Spring Boot REST API
|
├───────────────┐
↓ ↓
Flight Database Python Graph Service
(NetworkX)
|
↓
Graph Algorithms
|
↓
Routes and Connections
|
↓
Interactive Visualisation
Global airline networks contain thousands of airports and millions of possible connections.
Traditional flight databases represent routes as independent records, making it difficult to understand:
- How airports connect globally
- Which airports act as major hubs
- What paths exist between destinations
- How routes relate through intermediate airports
- How network structures evolve
FlightNetworkExplorer models airline data as a graph, enabling users to explore connectivity, analyse routes, and visualise relationships between airports.
React + Leaflet Client
|
|
Spring Boot API
|
|
Flight Data Services
|
|
Python Graph Engine
|
|
NetworkX Graph
Built with React and Vite.
- Interactive world map rendering
- Airport selection
- Route visualisation
- Dynamic graph expansion
- Route highlighting
- Airport information panels
- React
- Vite
- JavaScript
- React Leaflet
- CSS
Built with Java 21 and Spring Boot.
- REST API layer
- Airport and route management
- Database communication
- Data processing
- Graph service integration
- Java 21
- Spring Boot
- Spring MVC
- Spring Data JPA
- Hibernate
- H2 Database
- PostgreSQL support
backend
├── controller
│ REST endpoints
│
├── service
│ Business logic
│
├── repository
│ Database access
│
├── model
│ JPA entities
│
└── dto
API response objects
The graph service is a dedicated Python service responsible for graph analysis and route computation.
- Python
- FastAPI
- NetworkX
The airline network is represented as a directed graph:
Airport = Node
Flight Route = Directed Edge
Example:
JFK
|
↓
LHR
|
↓
AMS
Each edge stores route information including airline and connection data.
GET /api/network/{iata}
Example:
GET /api/network/AMS
Returns connected airports and routes around a selected airport.
Used for dynamic map expansion.
GET /api/routes/{from}/{to}
Example:
GET /api/routes/AMS/JFK
Returns route information between two airports.
Example response:
{
"from": "AMS",
"to": "JFK",
"routes": [
{
"via": "LHR",
"airline": "Example Airline"
}
]
}GET /api/routes/compare/{from}/{to}
Example:
GET /api/routes/compare/AMS/JFK
Returns available route options.
Example:
AMS
├── LHR
│ |
│ ↓
│ JFK
│
└── CDG
|
↓
JFK
GET /api/airport/{iata}/stats
Example:
GET /api/airport/AMS/stats
Returns statistics for a specific airport.
GET /api/graph/connections/{airport}
Example:
GET /api/graph/connections/JFK
Returns neighbouring airports from the graph service.
GET /api/graph/path/{from}/{to}
Example:
GET /api/graph/path/JFK/LHR
Returns a route path between airports.
The application provides an interactive global map for exploring airline networks.
- Airport exploration
- Route rendering
- Geographic visualisation
- Connection inspection
- Network discovery
The map allows users to navigate the airline graph visually rather than through static tables.
The complete global network is not loaded immediately.
Instead, airports are expanded on demand:
Select Airport
|
↓
Request Connections
|
↓
Add Airports and Routes
|
↓
Continue Exploration
- Improved performance
- Reduced visual complexity
- Scalable exploration
- Focused graph rendering
Users can compare possible journeys between airports.
- Multiple route options
- Multi-leg journeys
- Route highlighting
- Connection discovery
- Alternative path exploration
Example:
Amsterdam
|
|
LHR
|
|
New York
The Python graph engine uses NetworkX to analyse the airline network.
- Airport neighbour lookup
- Shortest path discovery
- Alternative route generation
- Graph traversal
networkx.shortest_path
networkx.shortest_simple_pathsThe system supports:
- Airport connectivity exploration
- Hub discovery
- Route analysis
- Network traversal
- Graph-based aviation research
Example:
LHR
|
|
JFK ---- AMS ---- CDG
|
|
FRA
- Built a full-stack airline graph exploration platform
- Modelled flight routes as directed graph structures
- Created an interactive geographic visualisation system
- Integrated Spring Boot with a Python graph processing service
- Implemented graph-based route discovery
- Built reusable React map components
- Designed modular backend services
- Separated visualisation, API logic, and graph computation
Airline routes are represented as directed edges.
Example:
London → Amsterdam
does not automatically imply:
Amsterdam → London
This reflects real airline networks where routes can differ by direction.
Graph computation is isolated from the main backend.
- Dedicated graph processing layer
- Independent algorithm development
- Clear separation of responsibilities
- Easier future scaling
Large global networks quickly become difficult to display.
The explorer expands locally:
User selects airport
|
↓
Fetch connections
|
↓
Add nodes and routes
|
↓
Continue exploration
This keeps the visualisation manageable while supporting large datasets.
- React
- Vite
- React Leaflet
- JavaScript
- CSS
- Java 21
- Spring Boot
- Spring Data JPA
- Hibernate
- H2
- PostgreSQL
- Python
- FastAPI
- NetworkX
- CSV route imports
- Airport datasets
- Airline datasets
- Graph traversal
- Shortest path discovery
- Alternative path generation
- User opens the interactive world map
- Frontend requests airport network data
- Spring Boot processes API requests
- Graph service performs graph analysis
- Routes and connections are returned as JSON
- React renders airports and flight paths
- Users continue expanding the network
Starting from:
Amsterdam (AMS)
The explorer discovers:
AMS
├── London (LHR)
├── Paris (CDG)
├── Frankfurt (FRA)
└── New York (JFK)
Selecting another airport allows route comparison and path discovery.
- Airline network exploration
- Graph algorithm demonstrations
- Route discovery
- Airport connectivity analysis
- Geographic data visualisation
- Aviation research
- Network science experiments
Global flight datasets contain thousands of airports and routes.
- Dynamic expansion
- Selective loading
- Local graph exploration
Flight networks contain many possible paths.
- Directed graph modelling
- Dedicated graph service
- NetworkX algorithms
Large graphs can become difficult to interpret.
- Interactive exploration
- Route highlighting
- Focused rendering
- Incremental expansion
- Add weighted routes using distance or travel time
- Add airport centrality calculations
- Add graph caching
- Add Docker deployment
- Add authentication
- Add richer analytics
- Add historical flight data
- Improve route ranking algorithms
git clone https://github.com/YOUR_USERNAME/FlightNetworkExplorer
cd FlightNetworkExplorercd graph-service
pip install -r requirements.txt
uvicorn app.main.py --reload --port 8000Graph service:
http://localhost:8000
cd backend
./mvnw spring-boot:runBackend:
http://localhost:8080
cd frontend
npm install
npm run devFrontend:
http://localhost:5173
FlightNetworkExplorer
├── frontend
│ ├── src
│ │ ├── components
│ │ ├── api
│ │ └── assets
│ └── package.json
│
├── backend
│ ├── src/main/java
│ │ ├── controller
│ │ ├── service
│ │ ├── repository
│ │ ├── model
│ │ └── dto
│ └── pom.xml
│
└── graph-service
├── app
│ ├── main.py
│ └── graph_loader.py
└── requirements.txt
MIT License