Invention Disclosure Document

The present invention relates generally to computer-implemented commercial systems for the travel retail industry. More specifically, it relates to a computer-implemented ecosystem and method that enables multiple independent organisations — including travel partners (airlines, online travel agencies, accommodation providers, car rental companies, cruise operators, train operators), airport retailers, enterprise point-of-sale (POS) system providers, and travellers — to participate in, validate, and automatically share commercial value generated by verified airport retail transactions through a single transaction lifecycle.

The travel retail industry comprises numerous independent participants that collectively contribute to a traveller's journey. Travel partners (airlines, OTAs, hotels, car rental companies, cruise lines, train operators) generate passenger traffic but receive no financial benefit from airport retail purchases made by the travellers they refer. Airport retailers must independently invest in customer acquisition with no shared infrastructure. Enterprise POS providers merely process transactions without participating in commercial value creation. Marketing campaigns terminate once a traveller arrives at the airport — the single most commercially valuable moment in the journey.

Existing solutions address only one participant in isolation: loyalty programmes serve a single retailer or airline; commission systems are bilateral (two-party); airport marketing platforms deliver advertisements but do not link them to verified transactions; and POS systems record sales without attributing them to a referring travel partner. No known system or method connects all participants into a single, computer-implemented revenue cycle in which one verified retail transaction automatically generates and distributes commercial value to multiple unrelated organisations according to predefined business rules.

There is therefore a need for an independent commercial operating layer that: (a) issues digital credentials to travellers before airport arrival via travel partners; (b) validates those credentials at the point of sale through enterprise POS integration; (c) attributes each verified transaction to its originating travel partner; (d) calculates and distributes commercial entitlements among all participating organisations automatically; and (e) creates a self-reinforcing incentive cycle in which each transaction encourages further traveller activation.

The system comprises a central platform server operatively connected to: (a) a credential database storing digital credit records (DutyCredit tokens / vouchers), each record comprising a unique credential code, a booking identifier, a discount percentage or credit amount, a departure airport, an expiration date, a status field, a traveller count, a ticket price, a travel type, a travel partner email identifier, and a traveller email identifier; (b) a booking database storing travel booking records for duplicate-prevention; (c) a transaction database storing verified retail transaction records; (d) a retailer database storing participating airport retailer records; and (e) communication interfaces for inbound API calls from travel partner systems and retailer POS systems.

Access control is enforced through row-level security policies: credential records and transaction records are readable only by the originating travel partner (matching their authenticated email) or by platform administrators; creation, update, and deletion of transaction records is restricted to platform administrators. Travel partner systems are authenticated via session tokens; retailer POS systems are authenticated via a shared secret transmitted in a request header.

The credit calculation engine computes the initial digital credit amount issued to a traveller at the time of booking. The engine receives booking data and applies the following formula:

Wherein basePerTraveller is determined by travel type (a first value for short-haul flights, a second higher value for long-haul flights); multiplier is determined by ticket price (a first multiplier below a first threshold, a second multiplier at a second threshold, a third multiplier at a third threshold, a fourth multiplier at a fourth threshold); and the result is clamped between a predefined floor and a predefined cap. The engine generates a unique credential code in a predetermined format and derives an expiration date by adding a predefined validity period to the departure date.

At the point of sale, the system applies a progressive discount model that maps the traveller's basket value to a discount percentage using piecewise-linear interpolation between predefined breakpoints. The breakpoints define a monotonically increasing function: a minimum spend threshold yields a first percentage, and progressively higher thresholds yield higher percentages up to a maximum percentage at a maximum breakpoint and above.

For basket values falling between two adjacent breakpoints, the effective percentage is computed by linear interpolation. The discount amount equals the product of the basket value and the effective percentage. The effective discount percentage is derived by dividing the discount amount by the basket value.

Upon validation of a credential and calculation of the discount, the settlement engine computes the commercial entitlements of each participating organisation:

• Platform fee: a first percentage of the transaction value, capped at a maximum amount, and waived entirely above a high-value threshold.
• Travel partner commission: a predefined share of said platform fee, capped at a maximum amount, attributed to the originating travel partner identified by the credential's partner email identifier.
• Amount due from traveller: the transaction value minus the discount amount.

Each verified transaction is persisted with its full financial breakdown and the association to its originating travel partner, enabling per-partner revenue reporting, aggregated dashboards, and automated monthly payout calculations.

The POS integration endpoint receives transaction requests from retailer POS systems in real time. The workflow comprises: (a) authenticating the POS system via a shared secret; (b) validating the presence of required fields (credential code, transaction value, retailer identifier); (c) querying the credential database and verifying active status and non-expiry; (d) enforcing a minimum basket threshold; (e) calculating the progressive discount and settlement amounts; (f) persisting the transaction record; (g) marking the credential as redeemed to enforce single-use; and (h) returning a structured response to the POS system for receipt printing.

The system further comprises a refund processing method for handling partial or full returns of goods after a redemption. When a traveller returns goods, the method: (a) retrieves the original transaction record; (b) computes an adjusted basket value by subtracting the refund amount and any previously refunded amounts from the original transaction value; (c) recalculates the progressive discount for the adjusted basket using said breakpoint model; (d) recalculates the platform fee and travel partner commission for the adjusted basket; (e) computes a refund due to the traveller equal to the returned goods value minus the discount adjustment (original discount minus new discount); (f) updates the transaction record with adjusted values and a refund status (partial or full); and (g) returns the adjusted breakdown to the POS system.

Each verified transaction creates incentives for further traveller activation: the travel partner receives a commission, demonstrating the commercial value of participation and encouraging further credential issuance; the retailer gains a customer acquisition without independent investment; the traveller receives a tangible discount, encouraging repeat usage; and the platform sustains the ecosystem. This constitutes a circular — not linear — commercial model.

The following algorithms constitute the technical core of the invention. Each algorithm is presented in formal pseudocode and is referenced by the corresponding step in the method of Section 2.

ALGORITHM A: CalculateDutyCredit
INPUT:  ticketPrice ∈ ℝ⁺, travelers ∈ ℤ⁺, travelType ∈ {Short-haul, Long-haul}
OUTPUT: creditAmount ∈ [floor, cap]

1.  IF travelType = Long-haul THEN
2.      base ← LONG_HAUL_BASE
3.  ELSE
4.      base ← SHORT_HAUL_BASE
5.  END IF
6.
7.  IF ticketPrice ≥ THRESHOLD_4 THEN multiplier ← MULTIPLIER_4
8.  ELSE IF ticketPrice ≥ THRESHOLD_3 THEN multiplier ← MULTIPLIER_3
9.  ELSE IF ticketPrice ≥ THRESHOLD_2 THEN multiplier ← MULTIPLIER_2
10. ELSE multiplier ← MULTIPLIER_1
11. END IF
12.
13. raw ← base × travelers × multiplier
14. creditAmount ← max(FLOOR, min(raw, CAP))
15. RETURN creditAmount

CONSTANTS:
  SHORT_HAUL_BASE, LONG_HAUL_BASE: predefined per-traveller base amounts
  THRESHOLD_1 < THRESHOLD_2 < THRESHOLD_3 < THRESHOLD_4: predefined ticket-price thresholds
  MULTIPLIER_1 < MULTIPLIER_2 < MULTIPLIER_3 < MULTIPLIER_4: predefined multipliers
  FLOOR, CAP: predefined minimum and maximum credit bounds

ALGORITHM B: GenerateCredential
INPUT:  bookingId, ticketPrice, travelers, travelType,
        departureAirport, travelDate, travelerEmail, partnerEmail
OUTPUT: {voucherCode, creditAmount, expirationDate, qrImageUrl}

1.  // — Duplicate prevention —
2.  existing ← Query(BookingDB, booking_id = bookingId)
3.  IF existing ≠ ∅ THEN
4.      RETURN Error("Credential already issued for this booking")
5.  END IF
6.
7.  // — Credit calculation —
8.  creditAmount ← CalculateDutyCredit(ticketPrice, travelers, travelType)
9.
10. // — Unique code generation —
11. charset ← "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
12. voucherCode ← "DB-"
13. FOR i ← 1 TO 8 DO
14.     voucherCode ← voucherCode + charset[random(0, |charset|−1)]
15. END FOR
16.
17. // — Expiration derivation —
18. expirationDate ← travelDate + VALIDITY_PERIOD
19.
20. // — Persist booking record —
21. BookingDB.create(bookingId, ticketPrice, travelers, travelType,
22.                   departureAirport, travelDate, partnerEmail, travelerEmail)
23.
24. // — Persist credential record —
25. CredentialDB.create(voucherCode, bookingId, creditAmount,
26.                      departureAirport, expirationDate, status="active",
27.                      partnerEmail, travelerEmail)
28.
29. // — Generate QR code —
30. qrImageUrl ← QRCodeService.generate(voucherCode)
31.
32. // — Transmit to traveller —
33. EmailService.send(travelerEmail, voucherCode, qrImageUrl,
34.                   creditAmount, departureAirport, travelDate, expirationDate)
35.
36. RETURN {voucherCode, creditAmount, expirationDate, qrImageUrl}

ALGORITHM C: CalcBasketCredit
INPUT:  basketValue B ∈ ℝ⁺
OUTPUT: discountAmount ∈ ℝ

1.  IF B < MIN_BASKET THEN
2.      RETURN 0
3.  END IF
4.
5.  IF B ≥ MAX_BREAKPOINT THEN
6.      RETURN round(B × MAX_PCT, 2)
7.  END IF
8.
9.  // — Identify adjacent breakpoints —
10. FOR i ← 0 TO |BREAKPOINTS| − 2 DO
11.     IF B ≥ BREAKPOINTS[i].spend AND B < BREAKPOINTS[i+1].spend THEN
12.         lower ← BREAKPOINTS[i]
13.         upper ← BREAKPOINTS[i+1]
14.         BREAK
15.     END IF
16. END FOR
17.
18. // — Linear interpolation —
19. t ← (B − lower.spend) / (upper.spend − lower.spend)
20. effectivePct ← lower.pct + t × (upper.pct − lower.pct)
21. discountAmount ← round(B × effectivePct, 2)
22. RETURN discountAmount

BREAKPOINTS = [
  (S₁, P₁), (S₂, P₂), (S₃, P₃), (S₄, P₄),
  (S₅, P₅), (S₆, P₆), (S₇, P₇)
]
where S₁ < S₂ < ... < S₇ (predefined spend thresholds)
and   P₁ < P₂ < ... < P₇ (predefined discount percentages, monotonically increasing)
MIN_BASKET, MAX_BREAKPOINT, MAX_PCT: predefined system parameters

ALGORITHM D: MultiPartySettlement
INPUT:  txnValue T ∈ ℝ⁺, voucher (contains partnerEmail)
OUTPUT: {discountAmount, effectiveDiscountPct, platformFee,
         partnerCommission, amountDue}

1.  // — Discount (Algorithm C) —
2.  discountAmount ← CalcBasketCredit(T)
3.  effectiveDiscountPct ← round(discountAmount / T × 100, 2)
4.
5.  // — Platform fee —
6.  IF T > FEE_WAIVER_THRESHOLD THEN
7.      platformFee ← 0
8.  ELSE
9.      platformFee ← round(min(T × FEE_PCT, FEE_CAP), 2)
10. END IF
11.
12. // — Travel partner commission —
13. partnerCommission ← round(min(platformFee × COMMISSION_SHARE,
14.                                COMMISSION_CAP), 2)
15.
16. // — Amount due from traveller —
17. amountDue ← round(T − discountAmount, 2)
18.
19. RETURN {discountAmount, effectiveDiscountPct,
20.          platformFee, partnerCommission, amountDue}

CONSTANTS:
  FEE_PCT: predefined platform fee percentage
  FEE_CAP: predefined maximum platform fee per transaction
  FEE_WAIVER_THRESHOLD: predefined threshold above which fee is waived
  COMMISSION_SHARE: predefined share of platform fee allocated to travel partner
  COMMISSION_CAP: predefined maximum travel partner commission per transaction

ALGORITHM E: POSTransactionWorkflow
INPUT:  voucherCode V, txnValue T, retailerId R, storeName S,
        airport A, posSecret K
OUTPUT: TransactionResult | Error

1.  // — Authentication —
2.  IF K ≠ STORED_POS_SECRET THEN RETURN Error("Unauthorized")
3.
4.  // — Field validation —
5.  IF V = ∅ OR T = ∅ OR R = ∅ THEN RETURN Error("Missing fields")
6.
7.  // — Credential lookup —
8.  voucher ← CredentialDB.filter(voucherCode = V)
9.  IF voucher = ∅ THEN RETURN Error("Voucher not found")
10.
11. // — Status check —
12. IF voucher.status ≠ "active" THEN
13.     RETURN Error("Voucher is " + voucher.status)
14. END IF
15.
16. // — Expiry check —
17. IF voucher.expirationDate < currentDate THEN
18.     CredentialDB.update(voucher.id, status = "expired")
19.     RETURN Error("Voucher has expired")
20. END IF
21.
22. // — Minimum basket enforcement —
23. IF T < MIN_BASKET THEN RETURN Error("Minimum basket not met")
24.
25. // — Settlement (Algorithms C + D) —
26. result ← MultiPartySettlement(T, voucher)
27.
28. // — Transaction logging —
29. txnId ← TransactionDB.create(
30.     voucherCode = V, retailerId = R, storeName = S,
31.     transactionValue = T,
32.     baseDiscount = voucher.discountAmount,
33.     effectiveDiscount = result.effectiveDiscountPct,
34.     discountAmount = result.discountAmount,
35.     platformRevenue = result.platformFee,
36.     partnerCommission = result.partnerCommission,
37.     partnerEmail = voucher.partnerEmail,
38.     airport = A
39. )
40.
41. // — Single-use enforcement —
42. CredentialDB.update(voucher.id, status = "redeemed")
43.
44. // — Return breakdown to POS —
45. RETURN {txnId, V, grossValue: T,
46.          effectiveDiscountPct: result.effectiveDiscountPct,
47.          discountAmount: result.discountAmount,
48.          amountDue: result.amountDue,
49.          platformFee: result.platformFee,
50.          partnerCommission: result.partnerCommission}

ALGORITHM F: ProcessPartialRefund
INPUT:  transactionId TxnId, refundAmount F ∈ ℝ⁺, posSecret K
OUTPUT: RefundResult | Error

1.  // — Authentication —
2.  IF K ≠ STORED_POS_SECRET THEN RETURN Error("Unauthorized")
3.
4.  // — Retrieve original transaction —
5.  txn ← TransactionDB.get(TxnId)
6.  IF txn = ∅ THEN RETURN Error("Transaction not found")
7.
8.  // — Check prior refunds —
9.  IF txn.refundStatus = "full" THEN
10.     RETURN Error("Already fully refunded")
11. END IF
12.
13. // — Compute adjusted basket —
14. alreadyRefunded ← txn.refundedAmount ∨ 0
15. remainingBasket ← txn.transactionValue − alreadyRefunded
16.
17. IF F > remainingBasket THEN
18.     RETURN Error("Refund exceeds remaining basket")
19. END IF
20.
21. newBasket ← remainingBasket − F
22.
23. // — Recalculate discount for adjusted basket —
24. originalDiscount ← txn.discountAmount
25. newDiscount ← CalcBasketCredit(newBasket)
26.
27. // — Recalculate platform fee and partner commission —
28. IF newBasket > FEE_WAIVER_THRESHOLD THEN
29.     newPlatformFee ← 0
30. ELSE
31.     newPlatformFee ← min(newBasket × FEE_PCT, FEE_CAP)
32. END IF
33. newPartnerCommission ← min(newPlatformFee × COMMISSION_SHARE,
34.                             COMMISSION_CAP)
35.
36. // — Refund due to traveller —
37. discountAdjustment ← originalDiscount − newDiscount
38. refundDueToTraveler ← F − discountAdjustment
39.
40. // — Determine refund status —
41. totalRefunded ← alreadyRefunded + F
42. IF totalRefunded ≥ txn.transactionValue THEN
43.     refundStatus ← "full"
44. ELSE
45.     refundStatus ← "partial"
46. END IF
47.
48. // — Update transaction record —
49. TransactionDB.update(TxnId, {
50.     refundStatus, refundedAmount: totalRefunded,
51.     adjustedTransactionValue: newBasket,
52.     adjustedDiscountAmount: newDiscount,
53.     adjustedPlatformRevenue: newPlatformFee,
54.     refundDueToTraveler
55. })
56.
57. RETURN {originalBasket: txn.transactionValue, refundAmount: F,
58.          newBasket, originalDiscount, newDiscount,
59.          discountAdjustment, refundDueToTraveler,
60.          originalPlatformFee: txn.platformRevenue,
61.          newPlatformFee, refundStatus}

In the current best-mode implementation, the system is built on a cloud-based backend-as-a-service platform providing managed databases, server-side functions, authentication, and API endpoints. Travel partner integration is performed via a booking-submission API endpoint that accepts JSON payloads. Retailer POS integration is performed via a webhook endpoint secured by a shared secret transmitted in an HTTP header. Credentials are issued as alphanumeric codes with corresponding QR codes generated via a QR code generation service. Electronic communication of credentials to travellers is performed via an email service. The following technologies are implementation mechanisms only and are not claimed individually: REST APIs, enterprise POS systems, QR codes, secure authentication, cloud computing, mobile devices, transaction databases, and reporting engines.

The system maintains the following principal data structures: a Booking record (booking identifier, ticket price, traveller count, travel type, departure airport, travel date, return date, travel partner email, traveller email); a Credential/Voucher record (credential code, booking identifier, discount amount, airport, expiration date, status, traveller count, ticket price, travel type, partner email, traveller email); a Transaction record (credential code, retailer identifier, store name, transaction value, base discount, effective discount, discount amount, platform revenue, travel partner commission, partner email, airport, refund status, refunded amount, adjusted values); and a Retailer record (store name, airport, category, voucher acceptance flag, owner email, POS channel partner, commission rate).