Home
← All case studies

Case study · RocketRez

Orion: Order details

The Orion admin Orders page started as a place to view orders and issue refunds. It grew into the hub for member functionality, refund processing and Stripe dispute status, built piece by piece from a modular “plug and play” design.

Role
Product designer
Project type
Admin web app, modular UI, refunds and payments
Tools
Figma, Claude Code
Orion: Order details cover

The brief

Issue

  • Operators needed a place to look up orders and issue refunds.
  • Orders are where almost every guest question ends up, so more functionality was going to land on this page over time.

Task

  • Meet the customer requirement: a list, an order view, and a refund button.
  • Design a page that could handle that growth without a rebuild each time.

Desired result

  • A launch small enough to ship
  • A clear plan for where each new feature would go

Results

72% down

Financial consolidation and change requests

80% up

Guest complaint issues solved by operators themselves

1.5 hrs a week

Developer time spent on ad hoc issues

Before: about 10 hours a week

These results were measured from June to August. Operators could now fix more problems on their own, so fewer requests reached the team. That freed up about 8.5 developer hours every week for planned work instead of one-off fixes.

Process: from blue sky to launch day

We started with wireframes that set up the page as “plug and play”: a layout made of self-contained sections that could be added, swapped or removed without disturbing the rest of the page.

Wireframe of the Orders list: search, saved views, filters and a table of orders with payment status, method and channel.
Low-fi: the orders list
Wireframe of an order: guest details, order items with forms, payment details, a timeline and backlinks, each in its own section.
Low-fi: order details, built from self-contained sections
Wireframe of the refund screen: items with a refund quantity each, and a summary with refund method, amount and a refund button.
Low-fi: refunding by item

From there we created a blue sky design, showing what the page would look like with no time or engineering constraints. It gave everyone a shared picture of where the page was headed.

High-fidelity order page: order items as cards, payment with the subtotal breakdown, a timeline, and purchase guest and notes cards on the side..
Blue sky: order details
The same order page with the order actions menu open, a resend confirmation dialog, an open note, and a delete note confirmation..
Blue sky: order actions, notes and confirmations

Then we worked backwards. We took that layout and removed everything that wasn’t absolutely necessary for launch day. What remained was the minimum operators needed to do their jobs. After launch, we added pieces back one at a time as real needs came up, always fitting them into the layout the blue sky design had already set.

This gave us two benefits: a launch that was small enough to ship, and a clear plan for where each new feature would go.

Building blocks

We built the page from individual components, each owning one part of an order:

  • Product cards for what was purchased
  • Guest detail cards for who the order belongs to
  • Payment detail cards for how it was paid

Because each card stood on its own, new functionality could plug into the card it related to, or arrive as a new card, without reworking the page. This is what made the step-by-step build after launch possible.

First pass: refund a full order, then confirm it
First pass: print a ticket, then reprint or reissue it

Refunds: separating money from access

As functionality expanded, refunds became the most complex part of the page. The first need was straightforward: full order refunds and partial order refunds, where operators refund some items and leave the rest of the order intact.

Real operator situations quickly went further. Sometimes an operator wants to refund a guest but still let them use what they paid for, for example as a goodwill gesture after a bad experience. The opposite is also true: sometimes items need to be removed from a guest’s access without any refund at all.

That meant treating the refund and the guest’s access as two separate decisions, instead of assuming one always comes with the other.

Once these were separate, every refund case fit into the same model, and operators could handle unusual situations without workarounds.

To work through the more complicated flows, we started with a general low-fi layout, then used Claude Code to prototype the flow end to end. That let us check it was usable and consistent with what we wanted operators to achieve. We then pulled the pieces of the prototype we liked into the new refund flow components.

Refunds start from the payment: choose a type, pick wallet items, then the refund method

Stripe dispute status

When a guest disputes a charge with their bank, operators need to know before they act on the order. We brought Stripe dispute status onto the order page as a status badge.

Stripe reports disputes with a long list of technical statuses that mean little to an operator. We grouped them into three states operators actually care about: In Progress, Lost and Won. Refund actions are gated by the dispute’s state, so the order page guides operators away from refunding money that is already being contested.

Challenge: last-minute launch requirements

The barebones version was planned in phases, but as launch day got closer, new requirements kept arriving: “Oh, and we forgot this is necessary for launch.” Many of them would have needed much heavier design work, pulling the layout and user flows into the advanced future state from the blue sky design. There wasn’t time for that.

The real challenge was defining what was realistic. For each request, we had to find a version that satisfied the client without rebuilding the whole layout.

We bought time with roundabout solutions. They worked, but they added steps to operators’ flows:

Launch requirementWhat we shippedThe trade-off
Refunds at the counterRefunds handled on the admin side, not the Point of SaleOperators had to leave the POS to complete a refund
Flexible refundsRefunds by item or full order, back to the original payment method onlyOther refund cases had to wait for later phases
Membership and guest informationAdded as note components inside the order page, since no full guest details page existedGuest details lived on each order instead of in one place

Our first-pass components made the problem visible. Reprinting and reissuing tickets, refunding across payment methods, and removing items from a guest’s wallet were all landing on a page built to view an order and start a refund. The order details page was no longer just somewhere operators went to initiate a refund.

After launch: improving without rebuilding

After launch, we had time to think properly about how these flows should work. Because the page was built from self-contained components, we could isolate one flow at a time and improve the components behind it.

That is how the page expanded: operators can now view a ticket’s history, suspend a membership instead of deactivating it, and handle more kinds of refunds, each built into the card it belongs to.

Ticket actions, one click from the card

Operators kept interacting with the page the same way. The improvements landed inside a layout they already knew, instead of arriving as a redesign they had to relearn.

Where it ended up

The page that started as “view orders and refund” became the operator’s central place for handling an order: member functionality, a full set of refund processes, and Stripe dispute status, all in one view.

It grew without a redesign because of decisions made at the start:

  • Design the destination, ship the minimum. The blue sky design set the direction, and cutting it back to launch essentials let us ship early without losing that direction.
  • Build in self-contained pieces. Cards for products, guests and payments gave every new feature an obvious home.
  • Model the real decision, not the assumed one. Separating refunds from access covered cases a simple refund button would have forced operators to work around.

Read next

← All case studies