How Navan’s Zero-Code, Driver-Based Platform Transformed Airline Integrations

Learn how Navan simplified airline integrations with a dynamic, zero-code platform that reduced onboarding time by 95%.

Integrating airlines into travel management solutions is a complex process, particularly when working with multiple carriers. Each airline has unique endpoints, data formats, and business rules that make traditional integrations time-consuming and resource-intensive. At Navan, where we strive to provide seamless travel management solutions, tackling these challenges efficiently is crucial.

Historically, integrating new airlines required:

• Extensive code changes for each carrier
• Increased maintenance overhead
• Lengthy deployment cycles
• Complex testing procedures
• Risk of system instability with updates

As a travel and expense management leader, Navan needed a flexible, scalable, and maintainable solution that would allow engineers to onboard new airlines with minimal code changes.

The answer was a dynamic, driver-based integration platform that leverages DocumentDB to integrate new airlines quickly while maintaining system stability. Navan’s engineers architected a solution that reduced time to market for new airline integrations by 95%, increased system availability to 99.9%, and sped up response times by 30%.

Here’s how.

Why Navitaire Integration Matters for Navan

Navitaire, an Amadeus company, powers more than 60 airlines worldwide. Its New Skies® reservation system supports essential airline operations, including:

• Passenger service system (PSS)
• Real-time inventory management
• Digital retailing
• Ancillary service management
• API-first integration for seamless connectivity

For Navan, integrating with Navitaire was a critical step in delivering a frictionless booking experience for our customers. Our clients expect a seamless travel management experience, and verifying that airline integrations work smoothly is a core part of that process.

However, with customized API implementations, diverse data formats (XML and JSON), and unique business rules for each airline within Navitaire, we needed a more modern integration approach that would remove bottlenecks and accelerate deployments.

The Problem with Traditional Integrations

Picture a growing city where each new building requires its own unique utility infrastructure: separate water lines, power grids, and communication networks. This was essentially the challenge with traditional airline integrations at Navan.

Instead of leveraging a standardized infrastructure, Navan’s engineers were building custom solutions for each airline, creating an increasingly complex and unsustainable network. With Navitaire alone powering more than 60 airlines, this process resulted in:

1. Time-Consuming Development Cycles

• Engineers spent weeks building custom infrastructure for each airline.
• Each integration required unique handling of endpoints, data mappings, and business logic.
• Testing became exponentially complex with each addition.

2. Resource Bottlenecks

• Development teams were constantly switching between different implementations.
• Knowledge became siloed, with specific developers becoming specialists in particular airline systems.
• Conducting code reviews and maintenance required a deep understanding of each unique implementation

3. Scalability Challenges

• Changes to common functionality required updates across multiple systems.
• The risk of system-wide issues increased with each new integration.

4. Operational Overhead

• Debugging required an understanding of airline-specific implementations.
• Documentation and maintenance became increasingly complex.

The turning point came when we realized that while Navitaire’s partner airlines shared common foundational elements, we were treating each integration as a completely independent system. It was like building separate power plants for each neighborhood when we could have a central grid with standardized connections.

This realization led us to ask: What if we could create a standardized infrastructure (driver approach) that could adapt to each airline’s unique requirements without rebuilding the entire system? That would allow us to:

• Rapidly connect new airlines to our platform
• Maintain consistency across all integrations
• Reduce development and maintenance complexity
• Scale our system more efficiently

The need for a driver-based approach became evident. We needed a system that could handle the complexity of airline integrations while remaining flexible enough to accommodate unique requirements. This would transform our integration process from a custom construction project into a standardized connection procedure, dramatically reducing time to market and improving our ability to serve our customers.

This was more than just a technical decision — it was about creating a sustainable foundation for Navan’s growth in the travel management space.

After all, due to the increasing number of airlines and the constant evolution of their APIs, we needed a solution that would scale with our business while maintaining the high-quality experience our customers expect.

Step-by-Step: From Hard-Coded Logic to a Dynamic, Driver-Based Approach

Previously, integrating a new airline meant writing airline-specific logic directly into our systems — an inefficient and unscalable approach that required custom code for every airline.

Instead, we adopted a driver-based approach: Instead of hard-coding airline logic with “if-else” statements, each airline would get its own pluggable driver, making the system more maintainable and scalable.

Now integrations are managed dynamically, which makes it easy to onboard new airlines without modifying core application logic.

Leveraging DocumentDB for Configuration Management

The Navitaire integration relies on Amazon DocumentDB — a fully managed NoSQL document database service — for flexible and scalable configuration management.

Instead of hardcoding airline-specific logic, we started storing the configurations in DocumentDB. The configuration for the airline includes essential connectivity parameters, supported operations, and fee structures. It supports various API endpoints and methods necessary for seamless airline operations.

The flexible schema allowed new airlines to be onboarded without requiring code changes, which significantly reduced engineering effort and time to market.

System Architecture Overview

Navan’s new system follows a modular microservices architecture. Its key components include:

• Navitaire-lib, a reusable core library supporting both XML and JSON modules
• Navitaire Microservice, which implements a factory pattern for handling airline-specific configurations
• DocumentDB Configuration Store to house airline configurations

The Factory Pattern in Action

The Navan engineering team leverages a factory pattern to support multiple airline implementations that select the appropriate service based on the airline configuration. This pattern allows us to seamlessly add new airline integrations without modifying existing service logic.

Factory Pattern Implementation:

What if One Airline is Down? Preventing Cascade Failures

Imagine a scenario where one of the integrated airlines experiences an outage or significant performance degradation. Without proper isolation and circuit-breaking patterns, this could potentially lead to:

• System-wide performance degradation (response times, latency)
• Resource exhaustion (thread pools, memory, CPU)
• Service reliability issues (connection failures, timeouts)
• Poor user experience (search delays, booking failures)

To prevent cascading failures and maintain system reliability, Navan’s engineers implemented a resilient architecture featuring circuit breakers and real-time monitoring.

The circuit breaker mechanism isolates failing airlines to prevent disruptions from spreading across the system while enabling gradual recovery. And real-time monitoring and automated alerts help ensure quick issue detection, so engineers can address problems before they impact users. These safeguards keep the platform stable and protect a seamless booking experience for all travelers.

Key Design Decisions

Faster Integrations and Improved Stability

By leveraging DocumentDB and a driver-based architecture, Navan has achieved significant improvements in integration efficiency:

• 95% reduction in time to market for new airline integrations
• 99.9% system availability to give Navan users a more stable booking experience
• 30% faster response times due to streamlined request processing
• Zero downtime when adding new airline integrations

Key Takeaways

• Scalability: Navan can easily add new airlines without modifying existing code.
• Maintainability: Modular architecture reduces engineering complexity.
• Reliability: Robust error handling and retry mechanisms help ensure seamless transactions.
• Flexibility: Support for multiple data formats and API versions.

What’s Next?

Navan’s engineering team continues to optimize airline integrations, which right now means exploring AI-driven data normalization and machine learning-based error handling. By pushing the boundaries of travel technology, we aim to make business travel smarter, faster, and more intuitive.

Are you interested in tackling complex engineering challenges at Navan? Join our team and be part of the future of business travel technology!