Aviation: Modern Airline Retailing

Overview

Aerotoys powers Offer & Order across airline retailing, centered on engines that are composable and independently scalable: Dynamic Validation, Offer Engine, Dynamic Pricing, and Stock Keeper — backed by Order Storage with full auditability. We fit your stack today and accelerate your path to IATA Modern Airline Retailing (MAR).

• Ship ancillaries, bundles, and fares with deterministic, testable rules.
• Align to Offer/Order (IATA MAR) while keeping your current stack productive.
• Publish offers to web, app, call center, and NDC — same core logic everywhere.

Why modern airline retailing

Customers expect contextual, transparent offers. Legacy stacks hard-code rules and fare logic in ways that slow teams down. Aerotoys externalizes rules, pricing, and capacity from channels so you can iterate safely and fast.

Dynamic Offers (replacing shopping)

Replace rigid “shopping” queries with Dynamic Offers generated from rules and signals: search context, traveler profile, trip purpose, interline constraints, and capacity. The result is a fully composed Offer, not just a list of flights.

• Offer graph: products + attributes + eligibility + reasons (for explainability).
• Per-channel strategies (direct, NDC, OTA) without forking business logic.
• Attach upsells contextually (seats, bags, lounge, Wi-Fi, FOP incentives).

Dynamic Bundles

Go beyond fare families. Compose bundles dynamically based on route, time, tier, device, and demand. Example: “Smart Business Saver” = seat + priority + lounge + 1 extra bag with targeted upgrade offers at T-36.

• Guardrails: bundle floors/ceilings, channel restrictions, and customer-tier perks.
• A/B flags: compare conversion and yield across bundle variants safely.
• Explainability: “why this bundle” reasons for agents and audit.

Ancillary Pricing

Price seats, bags, lounge, Wi-Fi, and upgrades with deterministic formulas + optional ML. Inputs can include route, seat map state, load factor, historical attach rate, fare class, and loyalty tier.

// Example: seat price with demand and context
seatPrice = baseSeatPrice(cabin, row, route)
          * (1 + alpha * loadFactor)            // demand pressure
          * (1 + beta * seatProximityToExit)    // desirability
          - loyaltyDiscount(tier)
          - bundleCredit(ifInBundle);

// Guardrails
assert(seatPrice >= floorByCabin && seatPrice <= ceilingByMarket);

Dynamic Pricing

Blend supply-demand, benchmarking, and ML signals with deterministic rules and full audit trails. Inputs often include load factor, days-out, search intensity, competitor deltas, seasonality, and willingness-to-pay segments.

• Floors/ceilings by market, brand, and channel; regulator constraints enforced.
• Elasticity curves + shadow pricing for safe rollouts.
• Idempotent APIs; same inputs → same price (with version hash).

Revenue management formula (illustrative)

A simple demand-based price update showing how we can compute supply/demand pressure with guardrails:

// Illustrative continuous price update
let p = filedFare(brand);
p *= (1 + a * (loadFactor - targetLF));        // demand pressure vs target
p *= (1 + b * searchIntensityIndex);           // real-time search demand
p *= (1 - c * daysOutDecay(daysOut));          // earlier shopping = lower uplift
p += competitorDelta(route, cabin) * k;        // benchmarking
p = clamp(p, floor(brand, market), ceiling(brand, market));

Continuous Pricing

Move beyond filed fare ladders and price on a continuous curve with explainable adjustments. Publish the resulting price as a valid MAR Offer with full audit (inputs, rules, version).

// Example continuous curve using elasticity E and baseline p0
p = p0 * (1 + u(loadFactor, daysOut, segment) - v(discounts, promo))
p = roundToIncrement(p, marketTickSize); // if required by market rules
assert(margin(p, expectedCost) >= minMargin);

• Rounding to market tick sizes or partner constraints when needed.
• Works side-by-side with classic filed families during transition.
• Every output is explainable: show “reasons” to agents and auditors.

Dynamic Validation

Validate complex inputs contextually (route rules, equipment, pax type, SSRs). Use rules to enable, require, or forbid fields and choices in real time.

• Policy-as-code with unit tests and rollout flags.
• Pre-validation for pricing & stock guardrails.
• Consistent UX across web, app, and call center.

Offer Engine

Compose products and bundles from any datasource. Eligibility, overrides, interline constraints, and merchandising live as rules — not branches scattered across services.

• Offer graph with explainable decisions and “why” reasons.
• Channel strategies without forking logic.
• Real-time publish to NDC, direct, and partner APIs.

Stock Keeper

Real-time counters, throttles, and reservations protect scarce capacity — seats, upgrades, lounge passes, bags, or partner stock. Define windows (per hour/per route) and dimensions (channel, device, tier) as rules.

• Strong consistency with optimistic retries and idempotency keys.
• Time-boxed counters and configurable back-off strategies.
• Use standalone or within Offer/Order flows.

Order Storage

Deterministic order state with who/what/why auditability. Keep the full decision trail (rules evaluated, prices chosen, stock mutations) for each order.

• Event-sourced ledger or SQL with append-only trails.
• Search and replay for investigation and recovery.
• GDPR/retention controls configurable per market.

Reference architecture

Deploy engines independently: cloud-hosted by Aerotoys or self-hosted in your VPC. APIs are stable, versioned, and well-documented. Admin UIs and sandbox demos help teams validate fast.

KPIs & outcomes

• +X% ancillary attach rate from contextual bundles.
• −Y% leakage via stock protection and idempotency.
• Lead time cut from quarters to days: rules, not rewrites.

FAQs

Can we adopt modules separately?

Yes. Many teams start with Pricing or Stock Keeper, then add Offer & Order.

How do you align with IATA Offer/Order (MAR)?

We keep your current stack productive while enabling a steady transition to Offer/Order models.

What’s the path to production?

Discovery → Prototype → Pilot → Rollout, with SLAs in cloud or self-hosted models.