Role
Backend Developer
B2B Corporate Travel Platform
Trivio
A large B2B travel-tech platform covering the full corporate travel lifecycle: searching and booking hotels and tickets, transfers, payments, cancellations and refunds, financial documents, and operator-assisted handling of non-standard requests.
The platform aggregates offerings from multiple external providers and supports corporate trips from search and booking through financial documentation.
I worked on the backend of the existing production application built with Symfony, primarily focusing on external provider integrations, hotel booking, search, and legacy code refactoring.
Project Overview
Period
June 2025 – October 2025
Project Type
Large B2B travel-tech platform
Architecture
Monolithic Symfony application
Product
A full-cycle corporate travel management system with external provider integrations and 24/7 operator support.
Context
Trivio is a B2B platform for organizing corporate travel.
The system covers different stages of a business trip: searching and booking transportation and accommodation, payments, cancellations and refunds, financial documentation, and additional services.
For standard travel services, the platform integrates with multiple external providers. Non-standard customer requests can be handled by a 24/7 operator service.
I joined the project as a Backend Developer and worked with an existing large Symfony monolith and its legacy codebase.
A significant part of my work required independently investigating existing implementations and reconstructing the actual behavior of poorly documented subsystems.
My Role
My primary area of responsibility was backend development and maintenance of the existing production application.
Backend Development
- Developed and maintained the backend of a monolithic Symfony application
- Worked with the existing legacy codebase
- Developed and modified booking business logic
- Worked with MySQL and query optimization
- Worked with Elasticsearch
Integrations
- Developed and maintained integrations with external travel providers
- Worked with TravelLine, TravelGate, Ostrovok and Bronevik
- Normalized differing external data models
- Worked with incompatible status models
- Mapped hotels, rooms and rates
- Diagnosed issues with unstable external APIs
- Worked with integrations where documentation was incomplete or unavailable and no proper test environment was provided
Production Support
- Diagnosed issues in existing subsystems
- Investigated failures across external provider integration flows
- Worked with support teams to investigate production incidents
01
Travel Provider Integrations
One of the main technical challenges of the project was integration with external travel service providers.
Different providers used their own data models and status models, which could not be mapped directly to one another.
The platform therefore had to map and normalize hotel, room, rate and booking-state data across multiple external systems.
The external systems introduced additional challenges:
- Differing data models
- Incompatible status models
- Unstable API behavior
- Hotel, room and rate mapping
- Incomplete or missing documentation
- No proper test environment for some integrations
Working with these integrations involved more than implementing API clients. It also required investigating the actual behavior of external systems and adapting their data to the platform's internal model.
External travel providers
TravelLineTravelGateOstrovokBronevik
Mapping & normalization
- Different data models
- Incompatible statuses
- Hotel, room and rate mapping
- Unstable APIs
- Incomplete documentation
- Missing test environments
Trivio booking domain
Hotel Booking
I participated in the development and maintenance of the complete hotel booking flow.
This included searching provider offerings, retrieving and updating data, handling differences between providers, and dealing with failures in external APIs.
Because providers used different data models and did not always provide complete documentation or test infrastructure, a significant part of the work involved investigating actual integration behavior and diagnosing problems through the existing codebase and available API responses.
03
Hotel Search Optimization
Hotel search was implemented using Elasticsearch.
The existing implementation used an overly complex main search query that performed substantially more work than was necessary for the actual task.
I investigated its behavior and replaced the overloaded construction with a simpler standard Elasticsearch query.
As a result, hotel search became approximately 10 times faster.
The improvement did not require additional infrastructure or caching: the main performance gain came from removing unnecessary complexity from the existing implementation.
04
Financial Document Refactoring
One of my largest independent tasks was refactoring a legacy financial document generation subsystem.
The platform generated different forms for booking-related operations, including:
- Booking
- Payment
- Cancellation
- Refund
Separate document variants existed for different types of transportation, including air, rail and bus travel.
Each document was assembled from several parts, but the existing implementation had no single consistent approach to storing or assembling them.
Template fragments were scattered across different parts of the system and could be stored in the database, separate HTML templates, or directly inside PHP code.
Individual document fragments could also reside in functionally unrelated modules, while the corresponding assembly logic was distributed throughout the codebase.
As a result, even a small change to an existing document first required reconstructing its actual generation flow.
I reverse-engineered the existing implementation, identified the related document fragments and assembly logic, and consolidated them into a single predictable system with centralized rendering.
After the refactoring, the entire document generation flow could be traced from a single entry point.
Modifying an existing document became a matter of working with the corresponding template and the data passed into it, rather than rediscovering legacy logic distributed throughout the application.
This made the subsystem significantly more predictable, traceable and self-documenting.
Before
Database
HTML templates
PHP code
Assembly logic across non-obvious locations
After
One traceable entry point
Data
Template
Centralized rendering
Document
Predictable modification of existing forms
05
Working with Legacy Code
A significant part of the project involved working with a large existing application where the information required to solve a task was not always reflected clearly in documentation or code structure.
Solving these tasks required independently investigating execution flows, identifying actual dependencies between components, and reconstructing how existing subsystems worked in practice.
The financial document subsystem was the clearest example: before it could be refactored, the document generation logic distributed across different parts of the application first had to be reconstructed.
The same investigative approach was required when working with external integrations, particularly when provider documentation or test environments were unavailable.
- Investigate existing behavior
- Reconstruct implicit dependencies
- Simplify and make maintainable
Result
During my time at Trivio, I contributed to the development and maintenance of a large production platform with extensive business logic and numerous external integrations.
Key results of my work included:
The project gave me experience working with a large integration-heavy legacy application where backend development involved not only writing new code, but also investigating existing behavior, reconstructing implicit dependencies, and incrementally simplifying complex subsystems.
~10× faster
Improved Elasticsearch hotel search performance by approximately 10x by eliminating unnecessary complexity in the main search query
Centralized and traceable
Consolidated scattered templates and document assembly mechanisms into a centralized and traceable system
Provider integrations
Developed and maintained integrations with multiple travel providers using differing data and status models