air new zealand

From Boarding Pass to Backend: The engineering That Powers Air new zealand

Air New Zealand's technology stack is as sophisticated as its in‑flight service - and senior engineers can learn a lot from how this airline orchestrates cloud infrastructure - mobile platforms. And real‑time data pipelines. While most aviation‑tech coverage focuses on airport kiosks or baggage tracking, the real engineering story lies beneath: a modern, multi‑region architecture that balances regulatory compliance, passenger experience. And operational resilience. Having consulted on similar large‑scale mobile platforms, I've seen firsthand how getting the infrastructure right is the difference between a seamless journey and a cascading system failure. In this post, we'll unpack the key technical decisions behind Air New Zealand's digital ecosystem - from the mobile app to the observability stack - and draw lessons you can apply to your own engineering project.

The airline industry is notoriously conservative when it comes to software upgrades. Yet air new zealand has earned a reputation for punching above its weight in innovation. In 2023, they migrated a substantial portion of their passenger‑facing services to AWS, adopted microservices for booking and check‑in. And rebuilt their mobile app with React Native. For a carrier of its size (serving ~17 million passengers per year pre‑COVID), these moves required careful engineering around legacy mainframes, strict data residency laws. And the need for 99, and 99% uptime during peak travel seasonsLet's break down the architecture, the tooling, and the hard‑won lessons.

Cloud Migration and Microservices: The Platform Story

Air New Zealand began its cloud transformation around 2018, initially using AWS to host its loyalty platform (Airpoints). By 2021, the airline announced a "cloud‑first" strategy, moving critical workloads like reservation systems and inventory management to AWS. The driving force was the need for elastic scaling - blackout periods (e, and g, holiday travel rushes) required 5-10x the normal compute capacity, something on‑premises infrastructure could not handle cost‑effectively.

The chosen approach was a hybrid of lift‑and‑shift for legacy. NET applications and greenfield microservices for new features. For example, the seat selection engine was rewritten as a set of domain‑specific services using Amazon ECS Fargate. While the core Passenger Service System (PSS) remains on an IBM mainframe (a reality for most large Airlines). The key engineering challenge was building an API gateway that could translate modern REST calls into mainframe‑friendly transactions. They used AWS API Gateway with custom Lambda authorizers to enforce rate limiting and IAM policies - a pattern described in the AWS Serverless Application Lens. This allowed them to decouple front‑end innovation from back‑end constraints, a tactic many enterprises struggle to add.

One real‑world consequence: during the 2022 Rugby Championship, when the All Blacks played in Auckland, the booking system saw a 400% spike in concurrent users. The auto‑scaling policies (based on CPU + memory utilization) kept p99 latency below 200ms. However, the team discovered that cold starts in Lambda functions handling mainframe bridge calls caused occasional timeouts. They mitigated this by using provisioned concurrency for the top‑five critical endpoints - a move that increased cost by 12% but eliminated the incident. This trade‑off between latency and cost is a recurring theme in airline engineering.

Mobile App Engineering: React Native, Offline First, and Push Architecture

The air new zealand mobile app is arguably one of the most feature‑rich airline apps outside the Big Three U. S carriers. Built with React Native, it supports mobile boarding passes, real‑time flight status, lounge access, seat selection, and ancillary purchases. The decision to use React Native was controversial internally - some engineers argued for Kotlin Multiplatform Mobile - but the team prioritized code sharing (reaching 85% shared code across iOS and Android) and faster deployment cycles.

From an infrastructure perspective, the app relies heavily on GraphQL (via Apollo Client) to aggregate data from multiple microservices: flight schedules from a Kafka stream, loyalty balances from a dedicated DynamoDB table. And booking changes via a legacy REST API. The engineering team implemented an offline‑first strategy using Redux Persist with custom conflict resolution logic. For example, if a user selects a seat while offline and then the seat becomes unavailable, the app queues the selection and notifies the user upon sync. This required careful event sourcing and idempotency keys - a pattern documented in the Event Sourcing pattern by Martin Fowler.

Push notifications are handled by AWS SNS with a fallback to Firebase Cloud Messaging for Android and APNs for iOS. The team built a dead‑letter queue for failed delivers and a back‑pressure mechanism to avoid flooding passengers during gate changes. In production, we've seen similar setups where notification systems become the first to fail under high load; Air New Zealand's approach of using separate SQS queues for different message priorities (boarding reminders vs. marketing offers) is a model worth copying.

Data Engineering at 35,000 Feet: Real‑Time Analytics and Predictive Maintenance

Behind the scenes, air new zealand runs a data platform built on Apache Kafka, Amazon Kinesis. And Apache Spark. The most compelling use case is predictive maintenance for their fleet of 110+ aircraft. Sensors on engines (like the Rolls‑Royce Trent 1000) generate terabytes of data per flight. The airline streams this data via Kafka into an Amazon S3 data lake, where it's processed by Spark jobs to identify anomalies - e g., slight temperature deviations in a turbine blade that precede a failure. This has reduced unplanned maintenance events by an estimated 18% (based on public reports).

Another critical pipeline is real‑time flight status. Every aircraft sends ADS‑B position data every few seconds, which is ingested into a Kinesis stream, then enriched with weather, air traffic control. And crew scheduling data. The enriched stream feeds a machine learning model (an XGBoost regressor) that predicts arrival delays with 85% accuracy up to four hours ahead. The model's predictions are exposed via a dedicated REST API that powers the mobile app's "flight tracker" feature and also feeds internal operational dashboards. The team uses MLflow for model versioning and Docker containers to ensure reproducibility across dev, staging. And production.

An important architectural decision was to avoid a monolithic data warehouse. Instead, they adopted a data mesh approach using Amazon Athena for ad‑hoc queries and Amazon Redshift for aggregated analytics. Each domain (flight ops, loyalty, revenue management) owns its data products and exposes them through standardized REST endpoints or Avro serialization in Kafka. This decentralized model reduces bottlenecks and aligns with the data mesh principles that many enterprises are now adopting.

Cybersecurity in Aviation: Protecting Passenger Data and Critical Systems

Aviation is a prime target for cyber attacks, air new zealand is no exception. The airline must comply with New Zealand's Privacy Act 2020, as well as PCI‑DSS for payment card data. Their security architecture includes a zero‑trust network (using AWS Security Groups and NACLs), mandatory MFA for all internal systems. And a dedicated incident response team that runs regular tabletop exercises. One notable practice is the use of AWS WAF with custom rules to block automated scraping of flight availability - competitors often monitor pricing via bots.

For the mobile app, they use certificate pinning, OAuth 2. 0 with PKCE. And client‑side encryption of sensitive data (like passport numbers) using the Web Crypto API. The backend token service uses short‑lived JWTs (10‑minute expiry) and rotates signing keys every 24 hours. Additionally, all API requests are logged via AWS CloudTrail and fed into a SIEM (Splunk) for anomaly detection. According to a 2023 whitepaper from the airline, they block an average of 200,000 malicious requests per month.

An often‑overlooked aspect is supply‑chain security for third‑party libraries. The airline enforces a strict Software Composition Analysis (SCA) pipeline using Snyk, integrated into their CI/CD (GitLab CI). Any package vulnerability with a CVSS score above 7, and 0 blocks the deploymentThis is a lesson for any engineering team: in a safety‑critical domain, weak dependencies can ground a fleet.

Observability and Site Reliability Engineering: Keeping the Schedule on Time

Air New Zealand's SRE team monitors over 500 microservices across production, staging. And disaster recovery environments. They use Prometheus for metrics collection (with Thanos for long‑term storage), Grafana for dashboards. And the ELK stack (Elasticsearch, Logstash, Kibana) for centralized logging. Every service defines Service Level Objectives (SLOs) based on criticality: the booking API has a 99. 95% uptime target, while the loyalty balance check has a looser 99. 5%. The team uses the error budget policy to decide when to halt feature releases.

One unique challenge is handling the "domino effect" of flight delays. If a flight is delayed, downstream systems (crew scheduling, catering, ground handling) all update. The SRE team built a custom Prometheus exporter that ingests real‑time flight status data from the airline's internal messaging queue (RabbitMQ) and creates latency histograms for each update. When a delay propagation exceeds a threshold, on‑call engineers receive a PagerDuty alert with a runbook that includes scaling the affected microservice and, if needed, falling back to a cached version.

Another practice worth mentioning: they use canary deployments with a weighted traffic split based on a custom header (X‑Canary: true). The canary group represents a subset of real passengers (e, and g, those on a specific route). If the error rate for the canary exceeds 1% of the baseline, the release is automatically rolled back via a GitOps pipeline (ArgoCD). This approach has caught critical bugs twice in the past year - once a change in the seat map API that incorrectly showed occupied seats as available. And another where the payment gateway integrated with Worldpay returned a malformed response.

Edge Cases and Lessons Learned: The Reality of Production Incidents

No architecture survives first contact with reality. During the 2023 Rugby World Cup, air new zealand experienced a 45‑minute outage of its check‑in kiosks at Auckland International Airport. The root cause: a misconfigured read replica in Amazon RDS for MySQL that fell behind by 10 minutes due to a sudden write spike. The application was reading from the replica assuming it was strongly consistent, leading to inconsistencies (e g., showing a passenger as already checked in when they were not). The fix involved adding a query hint to force reads from the primary for a subset of transactions - a trade‑off between consistency and availability that many teams debate.

Another lesson came from their push notification system. During a storm that grounded flights across the Tasman Sea, the team sent a single notification to all affected passengers. Over 50,000 push notifications were dispatched within one minute, causing a spike in downstream API calls as users opened the app simultaneously. The downstream booking service (a legacy mainframe bridge) couldn't handle 10,000 concurrent requests and began throttling. After the incident, they implemented circuit breakers (using Hystrix) on the mobile app's GraphQL resolver and added an exponential backoff on the client side for retries. This is a classic lesson in load amplification that any engineer building consumer‑facing systems should internalize.

Lessons for Senior Engineers: What You Can Apply Today

If you're building a high‑traffic, real‑time platform, take these engineering takeaways from Air New Zealand's journey:

• Invest in API gateways as the glue between modern and legacy systems. Without a clean abstraction, you'll create tight coupling that slows innovation.
• Treat offline‑first as a first‑class feature, not an afterthought. Mobile apps in aviation must handle tunnel connectivity (e g., during takeoff) gracefully,
• Use canary deployments with automated rollback Your error budget should be enforced programmatically, not by a release manager.
• Model failure modes explicitly. Simulate a domino effect of delayed flights and see if your services can backpressure properly.
• Push observability to the edge. Without real‑time metrics on notification delivery and API latency, you're flying blind.

For teams considering a similar transformation, I recommend studying the Air New Zealand case study on AWS - it covers many of the architectural decisions in more depth. And if you're looking for help with your mobile app architecture or cloud migration, contact us at Denver Mobile App Developer for a technical consultation.

Frequently Asked Questions

• What programming languages and frameworks does Air New Zealand use for its mobile app?
  The mobile app is built with React Native (JavaScript/TypeScript), Apollo GraphQL for data fetching. And Redux for state management. The backend services are largely Java (Spring Boot) and Node, and js
• Does Air New Zealand use machine learning for flight delays.
  YesThey operate an XGBoost‑based arrival delay predictor that ingests real‑time ADS‑B data, weather. And crew schedules. It achieves ~85% accuracy four hours before departure.
• How does Air New Zealand handle data residency and privacy compliance?
  They rely on AWS regions in Sydney (ap‑southeast‑2) and Auckland (for specific services). All passenger data stays within Australia and New Zealand. They comply with NZ Privacy Act 2020 and GDPR for European passengers.
• What is the airline's approach to disaster recovery?
  Critical services are deployed in a multi‑region configuration with Route53 latency‑based routing. They run full DR drills quarterly, including failover of the reservation system to a secondary region within 30 minutes.
• How do they manage dependencies and supply‑chain security?
  Every pull request triggers a Snyk scan for known vulnerabilities. And outdated or vulnerable packages block the mergeThey also rotate all API keys and secrets every 90 days