GDS web application enhancement: 2x increase in API integration speed

Web

Innowise conducted a comprehensive platform code refactoring and significantly simplified the process of integrating new APIs.

Customer

Industry

Travel

Region

Client since

2023

Our client, a prominent player in the travel industry, operates a global distribution system (GDS) for issuing ferry tickets and other travel services. This web application is a single point of contact for managing various ferry bookings, including long and short-distance trips, multi-seat types, and even complex multi-hop itineraries.

Detailed information about the client cannot be disclosed under the terms of NDA.

Challenge

Navigating market limitations and documentation gaps

This client found themselves limited by their current market size, and wanted to branch out further. To achieve this expansion, they aimed to set up API integrations with travel agencies.

Additionally, the absence of a structured software architecture documentation was a significant pain point. This gap led to several challenges, such as bringing newly hired team members up to speed, maintaining a common understanding of the system among various stakeholders, and smoothly implementing new product features.

Consequently, the client turned to us for API integrations and for creating a comprehensive software documentation architecture.

Solution

Scaling up web application efficiency and polishing API integration techniques

Innowise provided web application modernization and optimized API integrations with travel agencies to elevate the ferry experience across Europe.

Creating a software architecture documentation

At the outset, we began by conducting extensive interviews with the client’s development team and stakeholders. This approach ensured that we captured the essence of what they needed.

With this wealth of information, we set out to design an intuitive and understandable documentation structure. The documentation covered everything from high-level system overviews to code-level details. We incorporated diagrams, flowcharts, and interactive elements to make it informative and engaging.

But it wasn’t just about creating a static document. In our experience, the best documentation is one that lives, breathes, and evolves with the system it describes. So, we implemented a dynamic documentation process that would be continuously updated as the system grew and changed. This living document approach ensured that the documentation was always updated.

Moreover, we focused on making the documentation accessible and comprehensible to all parties involved. This meant avoiding jargon, using clear and concise language, and ensuring that technical and non-technical stakeholders could find value in it.

In essence, by establishing this comprehensive software documentation architecture, we didn’t just lay the groundwork for the current project, we provided the client with a tool that would aid in future development, onboarding new team members, and facilitating clear communication among all parties involved. It was the cornerstone upon which all further developments were built.

Code refactoring and migration to microservices

Upon diving into the client’s existing system, we found the deprecated version of Java with code duplications and outdated practices. The initial architecture, a monolithic application, had served its purpose in the early stages. However, as the platform grew, this approach showed its limitations. Scalability became arduous, and the codebase became a confusing maze that was increasingly difficult to navigate and update without introducing new bugs.

Based on our analysis, we determined that transitioning to a microservices architecture was necessary. Microservices offered a solution to the monolithic system’s scalability and agility problems. Each microservice in this architecture operates independently, which means that changes made in one service do not directly impact others. This independence is crucial for a system like our client’s, where frequent updates and integrations are the standard.

The migration to a microservices architecture was not an overnight process. Instead, we adopted an incremental approach, carefully dismantling the monolithic structure and reassembling it into a more dynamic, microservices-based architecture. This method allowed us to maintain system functionality throughout the transition, avoiding any significant downtime that could adversely affect our client’s operations.

We carefully extracted each service, refined it, and deployed it independently. Our developers separated services such as ticket booking and itinerary management into distinct units. This separation meant that updates to the itinerary management system, for instance, could be made without risking unintended consequences in the booking system.

For this transformation, we used Spring Boot and Spring Cloud. Spring Boot made setting up and configuring microservices easier, speeding up development. Spring Cloud offered valuable tools for distributed systems, like configuration management and service discovery.

We also integrated Kafka as our message broker. Its ability to handle large data volumes and ensure reliable communication between services was crucial, especially given the high data flow of the new architecture.

Finally, we implemented new microservices on the latest version of Java. This upgrade contributed to better performance and enhanced security, forming a strong and modern foundation for the entire architecture.

Elaborating on the development of a new processing module

As we refined and enhanced our client’s system, we identified the need for a more efficient way to handle new integrations. This led to the development of a specialized processing module, a pivotal addition to the system that brought about substantial improvements in the integration process.

Addressing redundancy challenges

One of the primary challenges we faced was the repetitive nature of the code-writing process for each new integration. Prior to the development of this processing module, every new integration with another travel agency or service required a significant amount of code written from scratch.

Designing the processing module

The processing module we developed was designed to act as a versatile interface between our client’s system and external APIs. This module consists of pre-built, customizable templates and tools that significantly reduce the need to write new code for each integration. It works by abstracting standard functionalities and processes typically involved in integrating with various travel services, such as ticket booking systems or customer databases.

The module includes several key features:

API communication handlers: these are designed to manage travel agencies’ incoming and outgoing API requests. They handle the complexities of different API protocols and data formats, making it easier to connect with external systems.
Data mapping and transformation tools: often, data structures vary between different systems. Our module includes tools that automatically map and transform data to and from the format required by our client’s system and external service providers. This facilitates smooth data exchange and integration.
Configuration and customization interface: recognizing the need for flexibility, the module is equipped with an interface that allows developers to configure and customize integrations easily without delving deep into the core code. This allows for quick adaptation to the specific requirements of each new travel agency or service.

API integrations with travel agencies

Afterward, we integrated our client’s GDS with 4 travel agencies that used REST and SOAP exchange mechanisms. These integrations were crucial for improving the ticket booking, modification, and cancellation processes for ferry services. Our challenge was to create an integration framework capable of managing a diverse range of ferry bookings, including different routes, seating configurations, and supplementary services.

Implementing these integrations involved several critical steps. Initially, we sifted through agencies’ APIs to understand their data structures and functional demands. Leveraging our newly developed processing module, we created customized connectors for each agency. These connectors were tailored to handle each agency’s specific data formats and operational workflows, ensuring fluid data integration with our client’s GDS.

The process included deploying sophisticated data mapping and transformation tools within our processing module. This technology played a crucial role in ensuring data integrity and consistency. Our team undertook extensive testing to validate the effectiveness and reliability of these integrations. We simulated various booking scenarios to test the integrations under diverse conditions. Following successful testing, we deployed the integrations into the live environment, setting up continuous monitoring mechanisms to oversee their performance and swiftly address any issues.

Technologies

Back end

Java 17, Spring, Spring Boot, Spring Cloud, Hibernate

API

REST, SOAP

Data storage

PostgreSQL, Memcached

Message brokers

Kafka

DevOps

GitLab CI/CD pipelines

Services

Gitlab, Jira, Confluence

Process

Discovery and analysis

We created a Vision & Scope document to align project goals with client expectations in the initial phase. This document set the project's foundation by understanding the client's objectives and system challenges.

Software architecture documentation development

Then we developed dynamic, easily understandable documentation, designed to evolve in sync with the project, thereby optimizing team communication and making the onboarding process more efficient.

Design and development

Here, we focused on implementing the microservices architecture and crafting the processing module. This phase showcased our technical expertise, resulting in a refined system architecture and a fully functional processing module.

Integration and testing

Leveraging the processing module, we seamlessly integrated APIs of travel agencies. Rigorous testing ensured system reliability and enhanced functionality.

Communication and task tracking

Microsoft Teams was our primary communication tool, streamlining discussions, updating shares, and maintaining a central information repository. We used Jira to keep organized and efficient workflow management for task tracking.

Team

Back-End Engineers

QA Engineer

Team Lead

Project Manager

Software Architect

Business Analyst

Delivery Manager

Results

Achieving transformative outcomes with soaring sales and broadened market presence

Following the successful implementation, the client’s web application exhibited remarkable performance improvements. The combination of code refactoring and the migration to a microservices architecture resulted in a notably smoother operation. This technical overhaul, coupled with the seamless integration of new services, catalyzed a substantial surge in the client’s sales.

The impact of this transformation extended beyond the financial realm. It led to significant expansion, not only in revenue but also geographical presence. This marked a momentous leap in the company’s market coverage, reinforcing its position as a prominent player in the industry. Our partnership with the client is ongoing, with more integrations on the horizon.

Project duration

March 2023 - Ongoing

30%

boost in sales

increase in API integration speed

Related cases

Contact us!

Book a call or fill out the form below and we’ll get back to you once we’ve processed your request.

What happens next?

Having received and processed your request, we will get back to you shortly to detail your project needs and sign an NDA to ensure the confidentiality of information.

After examining requirements, our analysts and developers devise a project proposal with the scope of works, team size, time, and cost estimates.

We arrange a meeting with you to discuss the offer and come to an agreement.

We sign a contract and start working on your project as quickly as possible.