V5: Next-Generation Airport & Airspace Intelligence Platform

Vision — 30-second "what does V5 do?"

Extract and ingest surveillance data from any data source
Handle data processing in both real-time and batch modes
Transform the data — enriching and validating for operational use
Designed to operate both on-premises and in cloud environments
Display the result in web-friendly, regulatory-compliant UI

Platform Overview

V5 is a fully integrated surveillance and analytics platform purpose-built for airports and air navigation service providers. It delivers real-time aircraft tracking, operational KPIs, post-operational replay, and ATC training — all from a unified technology stack.

Architecture

The platform processes live radar/ADS-B/Mode-S data through a pipeline of 15+ Rust microservices, achieving sub-second latency from antenna to screen. Data flows through Apache Kafka into gRPC-Web endpoints, feeding modern React frontends that run in any browser — no desktop installation required.

Ready for Expansion

Comprehensive inline documentation, strict TypeScript typing, and well-structured project conventions make the codebase exceptionally suited for expansion using AI coding agents. New product verticals can be scaffolded and developed at a fraction of the traditional cost and timeline, turning the IP into a launchpad rather than a static asset.

V5 platform stack — from data ingestion to application layer

Romeo5

For airports

Real-time Flight Tracking

Live aircraft surveillance. Streams real-time ADS-B/Mode-S data to render aircraft positions, trajectories, and flight levels on an interactive map for both air and ground. Sub-second updates via Kafka to gRPC.

Data model: Real-time streaming (live gRPC)

Madrid airport live (AIR) demo Madrid airport live (GROUND) demo Leeds/Bradford airport live (GROUND) demo

Delta5

For airports

Metrics Dashboard

Operational analytics for airports. Computes KPIs from historical data: runway occupancy (AROT), turnaround times, traffic counts, taxiway usage, speed alerts, ground vehicle incursions.

Data model: Batch/historical (SQL queries by date)

Madrid airport live demo

Bravo5

For airspace and airports

Post-operational Replay & Analytics

Historical flight replay. Ingests radar data and plays back recorded surveillance data, allowing review of past traffic situations with time controls and shareable links. Analytics dashboards for traffic volume, complexity, separations, etc.

Data model: Batch/historical (replay from archive)

Demo US airspace

Tango5

For ATC training

Gamified Conflict Detection Training

Interactive scenario-based game where users identify potential flight conflicts on a map. Timed rounds with scoring. Scenarios defined as JSON data (flight paths, conflict pairs). Backstage admin panel for managing scenarios and viewing scores.

Data model: Scenario-based (JSONB in PostgreSQL)

Tango5

Romeo5 — Air, Madrid (LEMD)

Romeo5 — Ground, Madrid (LEMD)

Romeo5 — Gloucestershire (EGBJ)

Bravo5 — Airspace Replay

Romeo5 — Ground surveillance, Leeds/Bradford

Romeo5 — Ground, Leeds/Bradford (EGNM)

Bravo5 — Ground Replay

Bravo5 — Traffic Complexity

Delta5 — Airport Metrics

Delta5 — Operational Analytics

Tango5 — ATC Training

Tango5 — Conflict Detection

Platform Capabilities

Data Ingestion

Surveillance sources Mode-S AVR/BEAST, ASTERIX (Cat21 & Cat62), APRS, FlightAware Firehose, Aireon AireonSTREAMS, and proprietary formats

Ingestion protocols TCP/UDP, AMQP, Kafka, HTTP REST polling, gRPC, S3-compatible object storage

Connectivity Secure and flexible — compatible with OpenVPN, L2TP-VPN, and Zero Trust architectures

Data Processing

Consolidation From single data points to consolidated aircraft status

Extensibility Supports Python pipelines to compute derived data

Performance Optimized for end-to-end low latency

Storage Multilayered data retention — long-term object storage, short-term relational database

Architecture Unified data flow serving all applications from a single pipeline

Infrastructure

Portability Platform-agnostic, infrastructure as code — portable across public and private clouds

On-premise Supports Linux bare-metal deployments on a private server

Applications

Delivery Modern standard web and desktop — native browser support, no plugins required

Customization Custom maps with full control of the data pipeline

Technical Specifications

TL;DR

Services are written in Rust
Prototypes are written in Python
Web is written in TypeScript
Infrastructure as code using Terragrunt & Terraform
Service communication through Kafka
Inter-service data exchange via Protobuf
Extensive tooling to maximize efficiency
CI/CD pipelines:
- Automated testing
- Automated building with one-click manual deployment

V5 Architecture Overview — microservices pipeline from ingestion to application

	Romeo5	Delta5	Bravo5	Tango5
Frontend stack	Next.js 14 React 18 TypeScript MapLibre GL Radix UI shadcn/ui TanStack Table Tailwind CSS 4 Auth0 JOSE	Next.js 14 React 18 TypeScript Radix UI shadcn/ui Lucide TanStack Table Recharts Tailwind CSS 4 Auth0 JOSE	Next.js 14 React 18 TypeScript MapLibre GL Radix UI shadcn/ui TanStack Table Tailwind CSS 4 Auth0 JOSE	Next.js 15 React 19 TypeScript Mapbox GL react-map-gl Radix UI shadcn/ui TanStack Table Tailwind CSS 3 Clerk Turf.js Lucide
Data layer	gRPC-Web Protobuf RxJS streams PostgreSQL Drizzle ORM	gRPC-Web Protobuf PostgreSQL Raw SQL	gRPC-Web Protobuf PostgreSQL Drizzle ORM	PostgreSQL Drizzle ORM Neon serverless Zod React Hook Form Server Actions
Pipeline	Shared microservices platform: 15+ Rust services (tokio, rdkafka, redis, prost), Kafka (AWS MSK), Redis (ElastiCache), Martin tile server, Python ETL (enroute-kpis), ASMT (Rust gRPC). Archival to S3 (Parquet/CSV).			Standalone. Scenarios seeded via CLI (tsx). PostHog for analytics.
Infrastructure	Terraform Terragrunt AWS EKS Kubernetes Kustomize GitHub Actions SOPS + KMS			Docker Compose GitHub Actions Husky

Shared Platform Architecture

Romeo5, Delta5, and Bravo5 share a common backend pipeline.

Real-time Ingestion

15+ Rust microservices using tokio async runtime, rdkafka for Kafka consumers/producers, and prost for Protobuf serialization. Sub-second ADS-B/Mode-S data processing.

Message Streaming

Apache Kafka (AWS MSK) for high-throughput message streaming between services. Redis (ElastiCache) for caching and real-time state management.

Data Transport

gRPC-Web with Protobuf encoding delivers real-time and historical data to frontend clients. RxJS streams for continuous data flow in Romeo5.

Storage & Analytics

PostgreSQL for operational data. Archival to S3 in Parquet and CSV formats. Python ETL pipelines compute enroute KPIs. Martin tile server for map data.

Infrastructure as Code

Terraform/Terragrunt for AWS provisioning. Kubernetes (EKS) with Kustomize overlays. GitHub Actions CI/CD. Secrets managed via SOPS + AWS KMS.

Authentication

Auth0 (OIDC/JWT) with nextjs-auth0 integration. JOSE library for token verification. Clerk for Tango5 standalone auth.

What sets V5 apart technically

Rust-native backend — The entire real-time pipeline is built in Rust (tokio, rdkafka, prost), delivering the performance and reliability critical for aviation surveillance without the overhead.
Sub-second real-time streaming — Kafka to gRPC to browser in under a second. Romeo5 renders live aircraft positions with continuous updates, not polling intervals.
Four products, one platform — Romeo5 (live tracking), Delta5 (airport KPIs), Bravo5 (replay & analytics), and Tango5 (ATC training) share a common data pipeline and infrastructure, dramatically reducing integration cost and operational complexity.
Cloud or on-premise, same codebase — Every service is containerized (30+ Dockerfiles, 20+ Docker Compose definitions for local dev, Kustomize overlays for Kubernetes). The same images run on AWS EKS in production, on a local server via Docker Compose, or as standalone desktop apps (romeo5-lite, bravo5-lite). No code changes between deployment targets — only configuration. Infrastructure is codified with Terraform/Terragrunt, CI/CD via GitHub Actions, secrets via SOPS+KMS.
Modern frontend stack — Next.js, React, TypeScript, MapLibre GL, shadcn/ui. The UIs are a generation ahead of what aviation typically ships. Responsive, fast, and built with standard web technologies that any developer can maintain.
Production-proven — Product running now on real aviation data feeds for long periods with excellent SLAs, demonstrating the platform handles operational traffic at scale.

Key Takeaways

Seed IP for aerospace surveillance — The modular, data-source-agnostic architecture makes this a seed platform for building new surveillance and analytics products. Extend to drone tracking (UTM), military surveillance, Advanced Air Mobility, space situational awareness, or any domain requiring real-time sensor fusion and visualization.
Not just code — a running production system with infrastructure-as-code.
Cloud-native infrastructure as code (Terraform + K8s) means the platform can be redeployed anywhere and scaled on demand.
Modern stack (Rust, TypeScript, React) — excellent talent pool, easy to maintain.
Expansion-ready: Adding a new airport client is a configuration exercise (config JSON + map styles + Kustomize overlay), not a development project. The on-premise model (Romeo5 Lite) enables rapid deployment combining cloud expansion with local on-premise used as backup or main.