Aleksandra Irzykowska
Let's chat
All work

Flight Editing Feature

A self-service flight editing feature for a corporate travel app, giving travelers full control over their bookings without the wait and reducing the load on customer service.

Lola flight editing screens on three phones
Client
Lola Travel & Expenses
Role
Product Designer
Partners
Product, engineering, and Wombat support
Scope
0→1 · Edge cases · Self-service · Travel · B2C · Native mobile

To comply with my non-disclosure agreement, I’ve omitted confidential information. The data featured here is my own and does not reflect Lola’s views.

The problem

Every flight change meant a call to customer service.

When COVID-19 disrupted travel plans worldwide, Lola’s internal support team, the Wombats, was overwhelmed with flight change requests overnight. Users had no way to modify flights in the app, so every change, no matter how small, required manual intervention. Delays mounted, users were frustrated, and operational costs climbed.

The answer was to put control back in users’ hands. But self-service editing isn’t just the happy path: the system had to decide in real time whether someone could edit their own booking, and if not, explain why and what to do next. At that moment, the design either builds trust or destroys it.

Key challenges

  • Airline fare rules are complex and invisible to users. How do we surface eligibility without overwhelming them?
  • The cost of a wrong decision is high: missed flights, fees, forfeited value. How do we create confidence at the decision point?
  • Some users can self-serve and some can’t. How do we redirect smoothly without making people feel abandoned?

My role

I owned design for the travel pillar and the full UX process from discovery through high-fidelity delivery. I worked directly with the product manager, engineering, and the Wombat customer support team to design a system that handles both self-service and handoff scenarios gracefully.

  • Ran a discovery sprint with product, engineering, and support
  • Defined the eligibility logic for self-service
  • Mapped edge cases and handoff scenarios
  • Delivered high-fidelity design for the full editing flow

Approach

A decision framework first, then every edge case

01Defining the decision framework

The discovery sprint produced a decision framework that grouped every possible editing scenario into two buckets: eligible for self-service, and not eligible. It became the backbone of every design decision that followed. I built the happy path first, got it right, then layered in edge cases, each designed not as an error state but as a moment of trust.

Self-service eligible

The traveler selects a new flight, reviews the change, and completes checkout.

  • Single traveler booking
  • No flown segments
  • All legs selected for a class change
  • Booked by the traveler or on behalf of someone else
  • More than 60 minutes before departure

Not eligible

Routed to Wombat support with a clear explanation and a direct next step.

  • Multiple travelers in a booking
  • Class changes for individual legs
  • Less than 60 minutes before departure

02Letting the system make the call

Rather than presenting users with a wall of airline restrictions, the system makes the eligibility call silently and routes accordingly. No jargon, no technical explanations, just the right experience for the right scenario.

Fare cards showing total cost, residual value, airline credit and no extra cost options
Refund outcomes surfaced before users commit.Depending on airline rules, a change could be an even exchange, a partial refund, or forfeited value. Each outcome is shown clearly at the decision point, not after.
Flight detail with change and cancel actions next to a booking within the refund window message
The void period, surfaced proactively.Edits made shortly after booking can qualify for a free void, so users get the option to cancel instead of going through a full change they don’t need.
Cabin class change flow: not eligible when only one leg is selected, eligible when all legs are selected
Cabin class changes that explain, not just block.Class changes had to apply to the whole trip to qualify for self-service. The system detects partial eligibility and explains why instead of simply saying no.

Outcome

Self-service where possible, a clear handoff where not

Eligible travelers change their own flights end to end. Everyone else gets an explanation and a direct path to the Wombat team, never a dead end.

Happy path from trip detail through flight change, leg and date selection, new time, checkout and confirmation
The happy path, from trip detail to confirmation.Single traveler, no flown segments, plenty of time: the user selects a new flight, reviews the change, and completes checkout without friction.
Not eligible scenarios: one leg flown, multiple travelers, 60 minutes to departure, each routing to live agent chat
Ineligible scenarios handed off with context.One leg flown, multiple travelers, or under 60 minutes to departure: each explains why self-service isn’t available and opens a chat with the Wombat team, pre-filled with the booking details.

Impact

37% fewer callsThe Wombat customer support team saw a significant reduction in calls,
as travelers handled eligible changes on their own
  • Positive user feedback on autonomy and reduced wait times
  • The eligibility framework set the foundation for future automation across travel management

Reflections

The hardest design work on this project wasn’t the happy path, it was the edge cases. Each one was a moment where user trust could be built or broken. A clear explanation, a direct next step, a proactive surface of information the user didn’t know to ask for: these details made the difference between a feature that empowered users and one that simply redirected them.

This project also reinforced how much edge case design depends on deep collaboration with engineering and support. The Wombat team knew every scenario that caused friction. Engineering knew every constraint. Getting those perspectives into the design early is what made the system robust.