From legacy code to modern standards: transforming Holafly’s infrastructure
Commercial success can become a trap. Holafly, a Spanish leader in connectivity solutions for travelers with operations in over 180 countries and 24/7 customer support, experienced exponential growth that exposed infrastructure weaknesses. What worked for a few clients became a burden when scale multiplied.
In this context arose the need for a technology partner to modernize their infrastructure without stopping the business. They needed to professionalize development, eliminate knowledge silos, and establish quality standards that would enable scaling without accumulating more technical debt.
Our solution was to implement high-impact incremental improvements: from 0% to 90% test coverage, adoption of Open Telemetry for modern observability, and shipping to production in less than 1 week a project blocked for months. The result: a professional operation ready to grow.
Scaling with infrastructure that wasn’t ready
Holafly faced the classic dilemma of fast-growth companies: their commercial success outpaced their technology’s capacity. Accumulated technical debt threatened their ability to continue innovating. To transform this situation, they needed a partner to help them face four main challenges.
Eliminate concentrated knowledge dependency
Only a few developers knew the critical system operations. There was no formal documentation or effective onboarding processes. Knowledge lived in the heads of a few people, creating bottlenecks with any absence or departure.
Implement professional quality standards
The technical situation was concerning:
- 0% test coverage: not a single line of code had automated tests
- Complete absence of typing: runtime errors from misused variables and methods with incorrect parameters
- Every deployment was a leap into the void, relying solely on manual testing
Modernize system observability
Trace protocols were deprecated and monitoring was practically nonexistent. The team operated blind: identifying the origin of an incident could take hours or days. The architecture included unnecessary use of PM2 in Kubernetes, causing trace loss.
Unblock paralyzed critical projects
The new support platform had been stalled for months without making it to production. The application showed mocked data, APIs didn’t work, and the team didn’t know how to move forward. Frustration was growing and confidence was declining.
Incremental modernization without blocking the business
Our strategy was clear: implement testing, typing, and observability without rewriting existing code or stopping ongoing development. Every decision responded to the same principle: measurable results in weeks, not quarters.
The heart of our solution was built on three pillars: quality, observability, and fast execution.
Integration tests and incremental typing
The first obstacle was cultural. The architecture team was reluctant to adopt TypeScript. Our response: implement typing through jsconfig.json, detecting typos and parameter errors without changing the technology stack.
The real challenge was testing. With 0% coverage and a proprietary library that didn’t support testing well, we designed a black-box integration testing strategy:
- Complete validation of each endpoint’s behavior
- Living documentation of expected system behavior
- Detection of untested use cases and incorrect flows
- Safety net for future changes
The result: coverage between 50% and 90% in critical services. The team learned to write and maintain tests, eliminating the dependency on manual validation in every deployment.
Reverse engineering the proprietary library
To improve traceability, we needed access to the source code of the proprietary library managing all BFFs. Using reverse engineering and exhaustive analysis of node_modules, we understood its internal workings and formally requested repository access. Once obtained:
- Migration to the Open Telemetry standard, supported and maintained by the community
- Elimination of unnecessary PM2 use in Kubernetes clusters
- Effective real-time monitoring
The team went from operating blind to having complete visibility of each service.
Complete restructuring of the blocked project
The biggest success was unblocking the support platform. The team had spent months unable to get it to production. Once we took charge, we achieved:
- Complete restructuring of APIs and endpoints
- Creation of 6 new screens and 8 functional endpoints with tests
- Strategic use of AI (Cursor) to accelerate layout
- Clear scope definition with structured backlog
In less than 1 week, the platform was in production. In 2 weeks, we had a complete and functional MVP.
Reverse engineering and standards adoption
The project required overcoming complex technical obstacles: a proprietary library without documentation, a hostile environment for testing, and the need to modernize without pausing development. The solutions applied not only resolved these problems but established new capabilities in the team.
Technical challenges overcome
Each obstacle required a different approach. It wasn’t enough to apply standard best practices: they had to be adapted to an environment with specific technical and cultural constraints.
Proprietary library without documentation: We applied reverse engineering on a critical library inherited from Ikea, without access to source code or public documentation. The code was on the lead architect’s personal computer. Using static and dynamic analysis tools, we understood its operation and implemented improvements without breaking anything.
Testing in hostile environment: The library wasn’t designed to be tested. We designed black-box tests that validated behavior without needing to understand internal details. We created pipelines to run these tests on every PR, going from 0% to 50-90% coverage.
Modernization without stopping development: Each improvement was implemented without pausing sprints or blocking the team. We used feature flags and progressive deployments to validate changes without disrupting operations.
Cultural change in the team: We went from a team reluctant to test to one that writes tests on every PR. From knowledge silos to active pair programming and training spaces like IT.all.
Applied innovations
Our solutions brought concrete capabilities to the team:
Progressive typing without TypeScript: jsconfig.json allowed detecting errors without changing the stack, eliminating the architecture team’s resistance.
Testing as living documentation: Integration tests document the behavior of each endpoint. A new developer can read them and understand the API without additional documentation.
Observability by design: Adoption of Open Telemetry so the team considers traceability from the first line of code, not as a later patch.
Continuous training: Pair programming and code reviews turned each task into knowledge transfer.
The Results: From technical chaos to professional operation
Results are measured in concrete changes that eliminated Holafly’s main technical bottlenecks.
90% test coverage
The system went from 0% to a range between 50% and 90% coverage in critical services. Pipelines automatically reject code without tests. Typing detects parameter errors before compiling.
Result: fewer bugs in production and fewer emergency hotfixes.
Delivery velocity
The support platform, blocked for months, went to production in less than 1 week:
- Complete restructuring of all APIs
- 6 new screens and 8 functional endpoints created in 2 weeks
- The support team could start operating effectively
Modern traceability
Open Telemetry adoption eliminated system blind spots. Traces show the path of each request through microservices. Dashboards identify the exact failing service.
Impact: from hours searching for errors to minutes identifying root cause.
Knowledge transfer
Knowledge stopped being in 2-3 key developers:
- Any developer can now work on any service through pair programming and continuous training
- No blockages due to vacations or dependencies on specific people for critical deployments
- Tests function as living system documentation
Technology used
- JavaScript – Runtime language
- jsconfig.json – Type safety without TypeScript
- Node.js – Runtime environment
- Open Telemetry – Distributed tracing standard
- SonarCloud – Code quality analysis
- Kubernetes – Container orchestration
- Cursor AI – AI-assisted development
- GitHub Actions/CI – Automated pipelines
