Building a Flight Operations Platform from Scratch

Flight operations software is the backbone of any aviation operation. Whether you're running a Part 135 charter company, a flight school, or a corporate flight department, you need tools to manage aircraft, crew, schedules, and the countless details that keep operations running smoothly.

In this guide, we'll walk through building a flight operations platform from the ground up. This isn't a toy project—we're covering real-world architecture decisions, data models, and the hard-won lessons from building systems that operators depend on every day.

Who Needs a Flight Ops Platform?

Before diving into code, let's understand who uses these systems:

Part 135 Charter Operators: Need to manage on-demand flights, crew duty times, and customer relationships
Corporate Flight Departments: Coordinate executive travel with internal stakeholders
Flight Schools: Track student progress, instructor availability, and aircraft scheduling
FBOs: Manage ground services alongside flight operations
Agricultural Aviation: Coordinate spray operations with weather windows

Each has unique requirements, but they share common building blocks: aircraft, crew, schedules, and the regulatory framework that governs aviation.

Core Features Overview

A modern flight ops platform typically includes:

Flight Scheduling - Creating, managing, and dispatching flights
Aircraft Management - Fleet status, maintenance tracking, availability
Crew Management - Duty times, qualifications, scheduling
Weather Integration - Real-time weather for route planning
Document Management - Flight logs, weight & balance, manifests
Notifications - Keeping everyone informed in real-time
Reporting - Operational analytics and compliance reports

Let's architect a system that handles all of these.

System Architecture

For a flight ops platform, we recommend a service-oriented architecture that separates concerns while remaining practical to deploy and maintain.

┌─────────────────────────────────────────────────────────────┐
│                        Frontend                              │
│              (Next.js / React Native)                        │
└─────────────────────┬───────────────────────────────────────┘
                      │
                      ▼
┌─────────────────────────────────────────────────────────────┐
│                      API Gateway                             │
│                  (Authentication, Rate Limiting)             │
└─────────────────────┬───────────────────────────────────────┘
                      │
        ┌─────────────┼─────────────┬─────────────┐
        ▼             ▼             ▼             ▼
   ┌─────────┐  ┌──────────┐  ┌─────────┐  ┌──────────┐
   │ Flight  │  │ Aircraft │  │  Crew   │  │ Weather  │
   │ Service │  │ Service  │  │ Service │  │ Service  │
   └────┬────┘  └────┬─────┘  └────┬────┘  └────┬─────┘
        │            │             │             │
        └────────────┴──────┬──────┴─────────────┘
                            ▼
                    ┌──────────────┐
                    │  PostgreSQL  │
                    │   + Redis    │
                    └──────────────┘

Technology Choices

Backend: Node.js with TypeScript or Go. TypeScript offers faster development; Go offers better performance for high-throughput scenarios.

Database: PostgreSQL is the clear choice. PostGIS extension handles geospatial queries (route distances, nearby airports). Strong ACID compliance for financial and regulatory data.

Cache: Redis for session management, real-time updates, and caching expensive queries.

Frontend: Next.js for the web dashboard. React Native if you need mobile apps (pilots often work from tablets).

Real-time: WebSockets for live updates. When a flight status changes, everyone needs to know immediately.

Database Schema Design

Let's design the core tables. This schema handles the fundamental entities in any flight operation.

Organizations and Users

CREATE TABLE organizations (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    name VARCHAR(255) NOT NULL,
    type VARCHAR(50) NOT NULL, -- 'part135', 'part91', 'flight_school'
    settings JSONB DEFAULT '{}',
    created_at TIMESTAMPTZ DEFAULT NOW(),
    updated_at TIMESTAMPTZ DEFAULT NOW()
);
 
CREATE TABLE users (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    organization_id UUID REFERENCES organizations(id),
    email VARCHAR(255) UNIQUE NOT NULL,
    name VARCHAR(255) NOT NULL,
    role VARCHAR(50) NOT NULL, -- 'admin', 'dispatcher', 'pilot', 'crew'
    phone VARCHAR(50),
    created_at TIMESTAMPTZ DEFAULT NOW(),
    updated_at TIMESTAMPTZ DEFAULT NOW()
);

Aircraft

CREATE TABLE aircraft (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    organization_id UUID REFERENCES organizations(id),
    registration VARCHAR(20) NOT NULL, -- N-number
    type VARCHAR(100) NOT NULL, -- 'Cessna 172', 'King Air 350'
    category VARCHAR(50) NOT NULL, -- 'single_engine', 'multi_engine', 'jet'
    
    -- Operational data
    base_airport VARCHAR(4), -- ICAO code
    seats INTEGER NOT NULL,
    useful_load_lbs INTEGER,
    fuel_capacity_gal DECIMAL(10,2),
    fuel_burn_gph DECIMAL(10,2),
    
    -- Status
    status VARCHAR(50) DEFAULT 'available', -- 'available', 'in_flight', 'maintenance'
    hobbs_time DECIMAL(10,1) DEFAULT 0,
    tach_time DECIMAL(10,1) DEFAULT 0,
    
    created_at TIMESTAMPTZ DEFAULT NOW(),
    updated_at TIMESTAMPTZ DEFAULT NOW()
);
 
CREATE TABLE aircraft_documents (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    aircraft_id UUID REFERENCES aircraft(id),
    type VARCHAR(50) NOT NULL, -- 'registration', 'airworthiness', 'insurance'
    expiration_date DATE,
    document_url VARCHAR(500),
    created_at TIMESTAMPTZ DEFAULT NOW()
);

Crew and Qualifications

CREATE TABLE crew_members (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    user_id UUID REFERENCES users(id),
    organization_id UUID REFERENCES organizations(id),
    
    -- Certificates
    certificate_number VARCHAR(50),
    certificate_type VARCHAR(50), -- 'ATP', 'commercial', 'private'
    medical_class VARCHAR(20), -- 'first', 'second', 'third'
    medical_expiration DATE,
    
    -- Contact
    emergency_contact_name VARCHAR(255),
    emergency_contact_phone VARCHAR(50),
    
    created_at TIMESTAMPTZ DEFAULT NOW(),
    updated_at TIMESTAMPTZ DEFAULT NOW()
);
 
CREATE TABLE crew_qualifications (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    crew_member_id UUID REFERENCES crew_members(id),
    aircraft_type VARCHAR(100) NOT NULL,
    qualification_type VARCHAR(50) NOT NULL, -- 'pic', 'sic', 'instructor'
    expiration_date DATE,
    check_ride_date DATE,
    created_at TIMESTAMPTZ DEFAULT NOW()
);
 
CREATE TABLE crew_duty_times (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    crew_member_id UUID REFERENCES crew_members(id),
    date DATE NOT NULL,
    duty_start TIMESTAMPTZ,
    duty_end TIMESTAMPTZ,
    flight_time_minutes INTEGER DEFAULT 0,
    rest_period_minutes INTEGER DEFAULT 0,
    created_at TIMESTAMPTZ DEFAULT NOW()
);

Flights

CREATE TABLE flights (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    organization_id UUID REFERENCES organizations(id),
    aircraft_id UUID REFERENCES aircraft(id),
    
    -- Flight identification
    flight_number VARCHAR(20),
    status VARCHAR(50) DEFAULT 'scheduled',
    -- 'scheduled', 'confirmed', 'dispatched', 'departed', 'arrived', 'cancelled'
    
    -- Route
    departure_airport VARCHAR(4) NOT NULL,
    arrival_airport VARCHAR(4) NOT NULL,
    alternate_airport VARCHAR(4),
    
    -- Times (all in UTC)
    scheduled_departure TIMESTAMPTZ NOT NULL,
    scheduled_arrival TIMESTAMPTZ NOT NULL,
    actual_departure TIMESTAMPTZ,
    actual_arrival TIMESTAMPTZ,
    
    -- Operational
    passengers INTEGER DEFAULT 0,
    cargo_lbs DECIMAL(10,2) DEFAULT 0,
    fuel_gallons DECIMAL(10,2),
    notes TEXT,
    
    created_at TIMESTAMPTZ DEFAULT NOW(),
    updated_at TIMESTAMPTZ DEFAULT NOW()
);
 
CREATE TABLE flight_crew (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    flight_id UUID REFERENCES flights(id),
    crew_member_id UUID REFERENCES crew_members(id),
    role VARCHAR(50) NOT NULL, -- 'pic', 'sic', 'cabin_crew'
    created_at TIMESTAMPTZ DEFAULT NOW()
);
 
CREATE TABLE flight_legs (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    flight_id UUID REFERENCES flights(id),
    leg_number INTEGER NOT NULL,
    departure_airport VARCHAR(4) NOT NULL,
    arrival_airport VARCHAR(4) NOT NULL,
    scheduled_departure TIMESTAMPTZ NOT NULL,
    scheduled_arrival TIMESTAMPTZ NOT NULL,
    actual_departure TIMESTAMPTZ,
    actual_arrival TIMESTAMPTZ,
    created_at TIMESTAMPTZ DEFAULT NOW()
);

Always store times in UTC. Aviation operates globally, and converting between time zones is error-prone. Let the frontend handle display conversion.

Indexes for Performance

CREATE INDEX idx_flights_org_date ON flights(organization_id, scheduled_departure);
CREATE INDEX idx_flights_aircraft ON flights(aircraft_id, scheduled_departure);
CREATE INDEX idx_flights_status ON flights(status) WHERE status NOT IN ('cancelled', 'arrived');
CREATE INDEX idx_crew_duty_date ON crew_duty_times(crew_member_id, date);
CREATE INDEX idx_aircraft_status ON aircraft(organization_id, status);

Flight Scheduling

The heart of any flight ops platform is the scheduling system. Let's build it properly.

Creating a Flight

interface CreateFlightRequest {
  aircraftId: string;
  departureAirport: string;
  arrivalAirport: string;
  scheduledDeparture: Date;
  scheduledArrival: Date;
  crewAssignments: {
    crewMemberId: string;
    role: 'pic' | 'sic' | 'cabin_crew';
  }[];
  passengers: number;
  notes?: string;
}
 
async function createFlight(
  orgId: string, 
  request: CreateFlightRequest
): Promise<Flight> {
  return await db.transaction(async (tx) => {
    const conflicts = await checkConflicts(tx, request);
    if (conflicts.length > 0) {
      throw new ConflictError('Scheduling conflicts detected', conflicts);
    }
    
    await validateCrewDutyTimes(tx, request);
    await validateCrewQualifications(tx, request);
    
    const flight = await tx.flights.create({
      organizationId: orgId,
      aircraftId: request.aircraftId,
      departureAirport: request.departureAirport,
      arrivalAirport: request.arrivalAirport,
      scheduledDeparture: request.scheduledDeparture,
      scheduledArrival: request.scheduledArrival,
      passengers: request.passengers,
      notes: request.notes,
      status: 'scheduled',
    });
    
    for (const assignment of request.crewAssignments) {
      await tx.flightCrew.create({
        flightId: flight.id,
        crewMemberId: assignment.crewMemberId,
        role: assignment.role,
      });
    }
    
    await notifyCrewMembers(flight, request.crewAssignments);
    
    return flight;
  });
}

Conflict Detection

Before confirming any flight, check for conflicts:

interface Conflict {
  type: 'aircraft' | 'crew' | 'maintenance';
  description: string;
  conflictingFlightId?: string;
}
 
async function checkConflicts(
  tx: Transaction,
  request: CreateFlightRequest
): Promise<Conflict[]> {
  const conflicts: Conflict[] = [];
  
  const bufferMinutes = 60;
  const startTime = new Date(request.scheduledDeparture.getTime() - bufferMinutes * 60000);
  const endTime = new Date(request.scheduledArrival.getTime() + bufferMinutes * 60000);
  
  const aircraftConflicts = await tx.flights.findMany({
    where: {
      aircraftId: request.aircraftId,
      status: { notIn: ['cancelled', 'arrived'] },
      OR: [
        {
          scheduledDeparture: { gte: startTime, lte: endTime }
        },
        {
          scheduledArrival: { gte: startTime, lte: endTime }
        },
        {
          AND: [
            { scheduledDeparture: { lte: startTime } },
            { scheduledArrival: { gte: endTime } }
          ]
        }
      ]
    }
  });
  
  for (const conflict of aircraftConflicts) {
    conflicts.push({
      type: 'aircraft',
      description: `Aircraft scheduled for flight ${conflict.flightNumber}`,
      conflictingFlightId: conflict.id,
    });
  }
  
  const maintenanceWindows = await tx.maintenanceWindows.findMany({
    where: {
      aircraftId: request.aircraftId,
      startTime: { lte: endTime },
      endTime: { gte: startTime },
    }
  });
  
  for (const window of maintenanceWindows) {
    conflicts.push({
      type: 'maintenance',
      description: `Aircraft in maintenance: ${window.description}`,
    });
  }
  
  for (const assignment of request.crewAssignments) {
    const crewConflicts = await tx.flightCrew.findMany({
      where: {
        crewMemberId: assignment.crewMemberId,
        flight: {
          status: { notIn: ['cancelled', 'arrived'] },
          OR: [
            { scheduledDeparture: { gte: startTime, lte: endTime } },
            { scheduledArrival: { gte: startTime, lte: endTime } }
          ]
        }
      },
      include: { flight: true }
    });
    
    for (const conflict of crewConflicts) {
      conflicts.push({
        type: 'crew',
        description: `Crew member assigned to flight ${conflict.flight.flightNumber}`,
        conflictingFlightId: conflict.flight.id,
      });
    }
  }
  
  return conflicts;
}

Crew Duty Time Management

FAA regulations (Part 117 for Part 121, Part 135 for charter) strictly limit crew duty times. Getting this wrong can ground your operation.

Part 135 Duty Time Rules (Simplified)

interface DutyLimits {
  maxFlightTime: number;
  maxDutyTime: number;
  minRestPeriod: number;
}
 
function getPart135Limits(scheduledFlights: number): DutyLimits {
  if (scheduledFlights <= 1) {
    return { maxFlightTime: 8 * 60, maxDutyTime: 14 * 60, minRestPeriod: 10 * 60 };
  } else if (scheduledFlights === 2) {
    return { maxFlightTime: 8 * 60, maxDutyTime: 14 * 60, minRestPeriod: 10 * 60 };
  } else if (scheduledFlights <= 4) {
    return { maxFlightTime: 8 * 60, maxDutyTime: 12 * 60, minRestPeriod: 10 * 60 };
  } else {
    return { maxFlightTime: 8 * 60, maxDutyTime: 10 * 60, minRestPeriod: 10 * 60 };
  }
}
 
async function validateCrewDutyTimes(
  tx: Transaction,
  request: CreateFlightRequest
): Promise<void> {
  const flightDate = request.scheduledDeparture.toISOString().split('T')[0];
  
  for (const assignment of request.crewAssignments) {
    if (assignment.role !== 'pic' && assignment.role !== 'sic') continue;
    
    const existingDuty = await tx.crewDutyTimes.findFirst({
      where: {
        crewMemberId: assignment.crewMemberId,
        date: flightDate,
      }
    });
    
    const flightDuration = 
      (request.scheduledArrival.getTime() - request.scheduledDeparture.getTime()) / 60000;
    
    const todaysFlights = await tx.flights.count({
      where: {
        scheduledDeparture: {
          gte: new Date(flightDate),
          lt: new Date(new Date(flightDate).getTime() + 24 * 60 * 60 * 1000),
        },
        flightCrew: {
          some: { crewMemberId: assignment.crewMemberId }
        },
        status: { notIn: ['cancelled'] }
      }
    });
    
    const limits = getPart135Limits(todaysFlights + 1);
    
    const currentFlightTime = existingDuty?.flight_time_minutes ?? 0;
    if (currentFlightTime + flightDuration > limits.maxFlightTime) {
      throw new DutyTimeError(
        `Crew member would exceed max flight time (${limits.maxFlightTime / 60}h)`
      );
    }
    
    if (existingDuty?.rest_period_minutes && existingDuty.rest_period_minutes < limits.minRestPeriod) {
      throw new DutyTimeError(
        `Crew member has not completed required rest period (${limits.minRestPeriod / 60}h)`
      );
    }
  }
}

Duty time regulations are complex and vary by operation type. This is a simplified example. Consult with your aviation attorney and implement the full regulations for your certificate type.

Crew Qualification Validation

async function validateCrewQualifications(
  tx: Transaction,
  request: CreateFlightRequest
): Promise<void> {
  const aircraft = await tx.aircraft.findUnique({
    where: { id: request.aircraftId }
  });
  
  if (!aircraft) {
    throw new NotFoundError('Aircraft not found');
  }
  
  for (const assignment of request.crewAssignments) {
    const qualification = await tx.crewQualifications.findFirst({
      where: {
        crewMemberId: assignment.crewMemberId,
        aircraftType: aircraft.type,
        qualificationType: assignment.role,
        OR: [
          { expirationDate: null },
          { expirationDate: { gte: request.scheduledDeparture } }
        ]
      }
    });
    
    if (!qualification) {
      throw new QualificationError(
        `Crew member not qualified as ${assignment.role} on ${aircraft.type}`
      );
    }
    
    const crewMember = await tx.crewMembers.findUnique({
      where: { id: assignment.crewMemberId }
    });
    
    if (crewMember?.medicalExpiration && 
        crewMember.medicalExpiration < request.scheduledDeparture) {
      throw new QualificationError('Crew member medical has expired');
    }
  }
}

Weather Integration

No flight ops platform is complete without weather data. Here's how to integrate aviation weather.

Fetching METAR Data

interface Metar {
  station: string;
  observationTime: Date;
  temperature: number;
  dewpoint: number;
  windDirection: number;
  windSpeed: number;
  windGust?: number;
  visibility: number;
  ceiling?: number;
  flightRules: 'VFR' | 'MVFR' | 'IFR' | 'LIFR';
  rawText: string;
}
 
async function fetchMetar(station: string): Promise<Metar> {
  const cacheKey = `metar:${station}`;
  const cached = await redis.get(cacheKey);
  
  if (cached) {
    const parsed = JSON.parse(cached);
    const age = Date.now() - new Date(parsed.observationTime).getTime();
    if (age < 10 * 60 * 1000) {
      return parsed;
    }
  }
  
  const response = await fetch(
    `https://aviationweather.gov/api/data/metar?ids=${station}&format=json`
  );
  
  if (!response.ok) {
    if (cached) {
      return { ...JSON.parse(cached), stale: true };
    }
    throw new WeatherError(`Failed to fetch METAR for ${station}`);
  }
  
  const data = await response.json();
  const metar = parseMetarResponse(data[0]);
  
  await redis.set(cacheKey, JSON.stringify(metar), 'EX', 900);
  
  return metar;
}
 
function determineFlightRules(visibility: number, ceiling?: number): string {
  if (visibility < 1 || (ceiling && ceiling < 500)) return 'LIFR';
  if (visibility < 3 || (ceiling && ceiling < 1000)) return 'IFR';
  if (visibility < 5 || (ceiling && ceiling < 3000)) return 'MVFR';
  return 'VFR';
}

Route Weather Analysis

interface RouteWeather {
  departure: Metar;
  arrival: Metar;
  alternate?: Metar;
  enroute: Metar[];
  recommendation: 'go' | 'caution' | 'no_go';
  concerns: string[];
}
 
async function analyzeRouteWeather(
  departure: string,
  arrival: string,
  alternate?: string
): Promise<RouteWeather> {
  const [depMetar, arrMetar, altMetar] = await Promise.all([
    fetchMetar(departure),
    fetchMetar(arrival),
    alternate ? fetchMetar(alternate) : null,
  ]);
  
  const enrouteStations = await getEnrouteStations(departure, arrival);
  const enrouteMetars = await Promise.all(
    enrouteStations.map(s => fetchMetar(s))
  );
  
  const concerns: string[] = [];
  let recommendation: 'go' | 'caution' | 'no_go' = 'go';
  
  if (depMetar.flightRules === 'LIFR' || arrMetar.flightRules === 'LIFR') {
    recommendation = 'no_go';
    concerns.push('LIFR conditions at departure or arrival');
  } else if (depMetar.flightRules === 'IFR' || arrMetar.flightRules === 'IFR') {
    recommendation = 'caution';
    concerns.push('IFR conditions present');
  }
  
  if (depMetar.windGust && depMetar.windGust > 25) {
    recommendation = recommendation === 'no_go' ? 'no_go' : 'caution';
    concerns.push(`Strong gusts at departure: ${depMetar.windGust}kts`);
  }
  
  if (arrMetar.windGust && arrMetar.windGust > 25) {
    recommendation = recommendation === 'no_go' ? 'no_go' : 'caution';
    concerns.push(`Strong gusts at arrival: ${arrMetar.windGust}kts`);
  }
  
  for (const metar of enrouteMetars) {
    if (metar.flightRules === 'LIFR' || metar.flightRules === 'IFR') {
      recommendation = recommendation === 'no_go' ? 'no_go' : 'caution';
      concerns.push(`Adverse conditions enroute at ${metar.station}`);
    }
  }
  
  return {
    departure: depMetar,
    arrival: arrMetar,
    alternate: altMetar || undefined,
    enroute: enrouteMetars,
    recommendation,
    concerns,
  };
}

Automate weather briefings but never automate the go/no-go decision. Present the data clearly and let the PIC make the call.

Real-Time Updates

Aviation operations change fast. Use WebSockets to keep everyone in sync.

WebSocket Server

import { Server } from 'socket.io';
 
interface FlightUpdate {
  flightId: string;
  field: string;
  oldValue: unknown;
  newValue: unknown;
  updatedBy: string;
  timestamp: Date;
}
 
function setupWebSocketServer(httpServer: HttpServer) {
  const io = new Server(httpServer, {
    cors: {
      origin: process.env.FRONTEND_URL,
      credentials: true,
    }
  });
  
  io.use(async (socket, next) => {
    const token = socket.handshake.auth.token;
    try {
      const user = await verifyToken(token);
      socket.data.user = user;
      next();
    } catch (error) {
      next(new Error('Authentication failed'));
    }
  });
  
  io.on('connection', (socket) => {
    const orgId = socket.data.user.organizationId;
    socket.join(`org:${orgId}`);
    
    socket.on('subscribe:flight', (flightId: string) => {
      socket.join(`flight:${flightId}`);
    });
    
    socket.on('unsubscribe:flight', (flightId: string) => {
      socket.leave(`flight:${flightId}`);
    });
  });
  
  return io;
}
 
async function broadcastFlightUpdate(io: Server, update: FlightUpdate) {
  const flight = await db.flights.findUnique({
    where: { id: update.flightId }
  });
  
  if (flight) {
    io.to(`org:${flight.organizationId}`).emit('flight:updated', update);
    io.to(`flight:${update.flightId}`).emit('flight:updated', update);
  }
}

Client-Side Integration

import { io, Socket } from 'socket.io-client';
 
class FlightOpsSocket {
  private socket: Socket;
  
  constructor(token: string) {
    this.socket = io(process.env.NEXT_PUBLIC_WS_URL!, {
      auth: { token },
      transports: ['websocket'],
    });
    
    this.socket.on('connect', () => {
      console.log('Connected to flight ops server');
    });
    
    this.socket.on('flight:updated', (update) => {
      this.handleFlightUpdate(update);
    });
  }
  
  subscribeToFlight(flightId: string) {
    this.socket.emit('subscribe:flight', flightId);
  }
  
  private handleFlightUpdate(update: FlightUpdate) {
    queryClient.invalidateQueries(['flight', update.flightId]);
    
    if (update.field === 'status') {
      toast.info(`Flight status changed to ${update.newValue}`);
    }
  }
}

Notification System

Keep crew informed with multi-channel notifications.

interface Notification {
  userId: string;
  type: 'flight_assigned' | 'flight_changed' | 'duty_reminder' | 'document_expiring';
  title: string;
  body: string;
  data?: Record<string, unknown>;
  channels: ('push' | 'sms' | 'email')[];
}
 
async function sendNotification(notification: Notification) {
  const user = await db.users.findUnique({
    where: { id: notification.userId }
  });
  
  if (!user) return;
  
  const promises: Promise<void>[] = [];
  
  if (notification.channels.includes('push')) {
    promises.push(sendPushNotification(user, notification));
  }
  
  if (notification.channels.includes('sms') && user.phone) {
    promises.push(sendSmsNotification(user.phone, notification));
  }
  
  if (notification.channels.includes('email')) {
    promises.push(sendEmailNotification(user.email, notification));
  }
  
  await Promise.allSettled(promises);
  
  await db.notificationLogs.create({
    data: {
      userId: notification.userId,
      type: notification.type,
      title: notification.title,
      sentAt: new Date(),
    }
  });
}
 
async function notifyCrewMembers(
  flight: Flight, 
  assignments: { crewMemberId: string; role: string }[]
) {
  for (const assignment of assignments) {
    const crewMember = await db.crewMembers.findUnique({
      where: { id: assignment.crewMemberId },
      include: { user: true }
    });
    
    if (!crewMember) continue;
    
    await sendNotification({
      userId: crewMember.user.id,
      type: 'flight_assigned',
      title: 'New Flight Assignment',
      body: `You've been assigned as ${assignment.role.toUpperCase()} on flight ${flight.flightNumber}`,
      data: { flightId: flight.id },
      channels: ['push', 'email'],
    });
  }
}

Data Sources and Integrations

A flight ops platform needs to integrate with external data sources.

FAA Data

Aircraft Registry: Validate N-numbers, lookup ownership
Pilot Certificates: Verify airman certificates (requires authorization)
Airport Data: Runways, frequencies, services

async function lookupAircraftRegistration(nNumber: string) {
  const response = await fetch(
    `https://registry.faa.gov/api/aircraft/${nNumber}`
  );
  
  if (!response.ok) {
    return null;
  }
  
  return response.json();
}

Weather Services

Aviation Weather Center: METARs, TAFs, AIRMETs, SIGMETs
NWS API: Supplemental forecast data
Commercial providers: Enhanced radar, turbulence forecasts

Flight Planning

ForeFlight API: Route planning, performance data
FltPlan.com: Free flight planning services
SkyVector: Charts and airport information

Fuel Pricing

async function getFuelPrices(airports: string[]): Promise<Map<string, number>> {
  const prices = new Map<string, number>();
  
  for (const airport of airports) {
    const cached = await redis.get(`fuel:${airport}`);
    if (cached) {
      prices.set(airport, parseFloat(cached));
      continue;
    }
  }
  
  return prices;
}

Deployment and Infrastructure

Recommended Architecture

For a production flight ops platform:

Application Servers: 2+ instances behind a load balancer
Database: PostgreSQL with streaming replication
Cache: Redis cluster for high availability
Object Storage: S3 or compatible for documents
CDN: For static assets and global performance

Monitoring

const metrics = {
  flightsCreated: new Counter('flights_created_total'),
  flightDuration: new Histogram('flight_duration_seconds'),
  apiLatency: new Histogram('api_request_duration_seconds'),
  activeUsers: new Gauge('active_users'),
};
 
app.use((req, res, next) => {
  const start = Date.now();
  
  res.on('finish', () => {
    metrics.apiLatency.observe(
      { method: req.method, path: req.route?.path || 'unknown', status: res.statusCode },
      (Date.now() - start) / 1000
    );
  });
  
  next();
});

Alerting Rules

Set up alerts for:

API error rate > 1%
Response time p95 > 2 seconds
Database connection pool exhausted
Weather data older than 30 minutes
Failed notification delivery

Use a simple rule: if it would wake someone up at 3am, it needs automated recovery. Otherwise, it can wait for business hours.

Lessons Learned

After building flight ops systems, here's what we've learned:

1. Time Zones Will Haunt You

Aviation operates in Zulu (UTC) time, but users think in local time. Every time display needs to be clear about which time zone is shown. Use libraries like date-fns-tz and be consistent.

2. Offline Capability Matters

Pilots don't always have connectivity. Design for offline-first on mobile apps, with sync when connectivity returns.

3. Regulatory Changes Are Constant

FAA rules change. Build your duty time and compliance logic in a way that's easy to update without major refactoring.

4. Data Accuracy Is Non-Negotiable

Aviation doesn't tolerate "close enough." Weight and balance calculations, fuel planning, and duty times must be exact.

5. Keep Audit Trails

Who changed what, when, and why. Every modification to flights, crew assignments, and aircraft status needs to be logged.

async function updateFlight(flightId: string, updates: Partial<Flight>, userId: string) {
  const current = await db.flights.findUnique({ where: { id: flightId } });
  
  const result = await db.flights.update({
    where: { id: flightId },
    data: updates,
  });
  
  await db.auditLogs.create({
    data: {
      entityType: 'flight',
      entityId: flightId,
      action: 'update',
      userId,
      changes: {
        before: current,
        after: result,
      },
      timestamp: new Date(),
    }
  });
  
  return result;
}

Conclusion

Building a flight operations platform is a significant undertaking, but it's incredibly rewarding. You're building tools that keep aircraft flying safely and efficiently.

Start with the core—flights, aircraft, crew—and expand from there. Focus on reliability over features. And always remember: in aviation, the details matter.

Have questions about building flight ops software? We'd love to chat: andrew@weflyhq.com.