FlyingLyte
A custom online travel platform engineered from scratch on React and Django, powered by real-time Travel Boutique Online (TBO) API integration and secure PayU payment gateway.

Deliverables
- Custom React Single Page Application (SPA)
- Django & Django REST Framework (DRF) Backend
- Travel Boutique Online (TBO) API Integration
- PayU Payment Gateway Integration (SHA-512 Verification)
- Real-Time Flight Search & Dynamic Fare Matrix
- Automated PNR Generation & E-Ticket Issuance
- PostgreSQL Booking Database & Consultant CRM
- Automated WhatsApp Booking Confirmation & PDF Dispatch
Technology Stack
Capabilities Deployed
Executive Overview
FlyingLyte is a full-service online travel agency providing corporate and leisure travelers with comprehensive domestic and international flight bookings, curated holiday itineraries, and boutique hotel reservations. To compete effectively against established travel aggregators, the leadership required an independent digital property that could deliver real-time airline inventories, dynamic fare calculations, secure instant payment processing, and automated booking confirmations without the crippling load times, generic layouts, and rigid commission restrictions of white-label travel templates.
They engaged Infriva Solutions to build their entire digital web platform completely from scratch. We designed and developed an end-to-end custom architecture: a responsive, state-driven Single Page Application in React, a high-throughput backend service engineered in Django (Python) and Django REST Framework, bidirectional integration with Travel Boutique Online's (TBO) global B2B travel distribution API, robust checkout via the PayU payment gateway, and an automated PostgreSQL CRM pipeline that synchronizes live PNRs, e-tickets, and booking alerts directly to travelers via WhatsApp.
The Operational Challenge
Building a modern online travel agency from scratch presents formidable technical hurdles. Off-the-shelf white-label platforms rely on heavy iframes and bloated script bundles that take upwards of 5 to 7 seconds to render, suffer severe cumulative layout shifts on mobile devices, and offer no ability to implement custom business logic or dynamic markup tiers. Prior to our build, FlyingLyte experienced over 70% funnel abandonment as users dropped off during sluggish multi-step search queries.
The core engineering challenge centered on orchestrating two critical external systems in real time: Travel Boutique Online (TBO) for live inventory and the PayU payment gateway for transaction settlement. TBO's API coordinates live flight schedules, dynamic cabin classes, taxes, and seat availability, while flight ticketing requires immediate, non-reversible PNR issuance upon payment. Without strict server-side cryptographic hash verification and idempotent webhook reconciliation between PayU and Django, any network drop or payment callback delay could result in unticketed payments or unauthorized booking locks.
The Engineering Solution
We engineered FlyingLyte's web application from the ground up using a decoupled React and Django architecture. On the client side, we built a modern React SPA featuring instant route switching (one-way, round-trip, multi-city), live airline filtering (by stops, baggage allowance, departure windows, and refundable fares), and a friction-free progressive checkout funnel that preserves traveler state across navigations.
On the backend, we constructed a robust Django REST Framework application to serve as the secure orchestration bridge. Django handles all communication with both the Travel Boutique Online (TBO) API and PayU payment gateway. We implemented an intelligent multi-tier Redis caching layer to store high-frequency flight availability queries, dynamic margin and markup calculators, server-side SHA-512 cryptographic hash generation for PayU checkout, automated PNR creation upon verified payment webhook confirmations, and real-time triggers that dispatch branded WhatsApp e-tickets within seconds.
Deep System Architecture
Custom Full-Stack Architecture: React SPA & Django REST Backend
To provide seamless, 60 FPS consumer booking experiences while enforcing enterprise-grade security and transaction reliability, we decoupled the frontend client from backend business logic. The React client communicates with custom Django REST endpoints over encrypted, authenticated channels.
This separation of concerns enables the React frontend to handle complex client-side state—such as multi-city leg configurations, dynamic fare breakdowns, and interactive seat selections—without page reloads. Meanwhile, the Django backend isolates proprietary agency markup algorithms, booking logic, and sensitive passenger credentials in a secure, tamper-proof environment.
- Sub-1.2s Largest Contentful Paint (LCP) on mobile networks via optimized React bundle splitting and lightweight asset delivery.
- Django REST Framework (DRF) middleware managing dynamic agency markups, promotional discount codes, and multi-currency conversions.
- Modular component system allowing FlyingLyte to deploy new destination landing pages and seasonal holiday corridors without backend modifications.
Travel Boutique Online (TBO) API Integration & High-Throughput Caching
Direct integration with Travel Boutique Online's (TBO) global API gives FlyingLyte live access to hundreds of domestic and international airlines, real-time seat availability, and instant GDS ticket issuance. However, unoptimized flight queries across dozens of airline carriers can degrade performance.
We engineered an intelligent query broker in Django that normalizes TBO's XML/JSON responses into standardized schemas. Frequent route lookups are cached in Redis with granular Time-To-Live (TTL) policies, ensuring sub-second response times while running deterministic re-validation before the final booking lock to guarantee 100% fare accuracy.
- Full TBO API lifecycle integration: Flight Search, Fare Rule Verification, Special Service Requests (SSR), Seat Map Rendering, and Instant PNR Generation.
- Intelligent Redis caching layer that reduced flight search response times from 4.8 seconds down to under 1.2 seconds.
- Resilient circuit-breaker architecture with automated error handling and fallback routing to maintain platform uptime during upstream provider updates.
PayU Payment Gateway, Automated PNR Ticketing & WhatsApp Dispatch
We eliminated manual booking entry by developing an automated end-to-end transaction pipeline. When a traveler confirms their itinerary, Django calculates the dynamic order total and signs the payload with PayU's SHA-512 cryptographic hash, supporting instant payments across UPI, credit/debit cards, NetBanking, and corporate wallets.
The moment PayU's server-to-server webhook verifies successful payment, Django commands TBO's API to generate the official airline PNR and renders a branded PDF e-ticket with detailed flight itineraries, baggage allowances, and barcode data. Simultaneously, our event engine dispatches the confirmed e-ticket directly to the passenger's WhatsApp via the Meta WhatsApp Cloud API.
- Seamless PayU payment gateway integration with server-side SHA-512 cryptographic verification and idempotent webhook processing.
- Zero-touch PNR generation and automated PDF ticket rendering directly within the Django backend.
- 12 automated WhatsApp Cloud API lifecycle flows for booking confirmations, payment receipts, flight status reminders, and post-trip reviews.
- Centralized PostgreSQL booking database with consultant dashboard for real-time customer support, booking modifications, and cancellation handling.
Measured Production Outcomes

