Scan & Pay
iOS • Retail Innovation

Scan & Pay

Mobile UXRetail InnovationPayment FlowUser Testing

Platform

iOS (native app) · Retail

Role

UX Designer

Timeline

[TODO: e.g., 2017–2018]

Overview

Scan & Pay turns the Macy's app into a self-checkout terminal: a customer in the store can scan a price tag, see live pricing and applied offers, pay from a saved card, and walk out — flashing a digital receipt at an associate for security-tag removal on the way out. It collapses what used to be a register line into a flow that lives entirely on the phone.

The Challenge

Department-store checkout lines are the single biggest friction point in an otherwise pleasant in-store experience. Customers who already had the item in hand — and a payment method on file in the Macy's app — were still being routed through the same register line as everyone else. Meanwhile, the most loyal customers (app users with stored cards and Star Rewards) were the ones bearing that wait the longest.

The bet: if a customer can scan, price-check, and pay from their phone, the line becomes optional.

The design needed to:

  • •Reduce checkout friction and waiting time inside the store
  • •Keep payment processing secure with the credentials the customer had already saved
  • •Integrate cleanly with existing register and loss-prevention operations
  • •Build user trust in a self-service model where no associate is in the loop until the very end

My Role

As the UX designer on this project, I was responsible for:

  • →Conducting in-store user research to understand pain points in the traditional checkout process
  • →Designing the user flow from product scanning to payment completion and associate hand-off
  • →Creating wireframes and high-fidelity prototypes
  • →Collaborating with engineering and product teams on implementation
  • →Conducting usability testing and iterating based on user feedback

[TODO: name PM, eng leads, research partners, anyone who deserves a credit at the bottom.]

Research & Discovery

We ran in-store observations and shopper interviews to understand the real checkout experience — not just the line itself, but everything around it: people scanning tags with the camera app, asking associates for prices, abandoning items at the register.

Three concerns came up consistently, and they shaped the rest of the design:

  • 1.

    Security of payment information

    Would the app actually charge their saved card, and would an associate be able to verify it?

  • 2.

    Accuracy of scanned items and prices

    Could they trust that the price on the phone matched the tag, including any current offer?

  • 3.

    What to do if they needed help

    At a register there's a person; in a self-checkout flow, who do they ask, and where?

Each of those concerns is answered by a specific screen in the flow below.

The User Flow

Entry Point: The Store Landing Screen

The first design decision was where Scan & Pay should live. We pushed it onto the store landing screen — the screen a customer sees when the app detects they've walked into a Macy's. Store info up top (Union Square, Open, Change store), a row of quick actions (Store Map, Catalog, Contact, Directions), and then a single, full-width red CTA: Barcode Scan — Scan for price, reviews & checkout.

Putting Scan front-and-center on the in-store landing meant a returning customer never had to hunt for it.

Store landing screen showing Union Square with Barcode Scan CTA and offers

The Intent Picker: Scan for Info vs. Scan to Buy

A scan can mean two very different things. Sometimes a customer is browsing — they want to read reviews or check if it comes in their size. Sometimes they've decided and they just want to pay. Trying to infer which one and route silently would have meant guessing wrong half the time.

So the camera opens with a bottom sheet that asks plainly: What would you like to do? Two large options — Get Product Info and Mobile Checkout: skip the line! Just scan, pay & go — each with an icon and a one-line description so the choice is obvious.

This is also the moment the user is taught what the feature is. Even on first run, the intent picker is the tutorial — directly addressing the "what do I do if I need help?" research concern by making the next action obvious.

Scan intent picker showing options to Get Product Info or Mobile Checkout

Designing for Bad Reception

Macy's flagship buildings are concrete-and-marble dead zones for LTE. A scan-and-pay flow that silently fails the second a customer walks past a load-bearing wall would be worse than no feature at all.

Two designs handled this:

1. Non-blocking network warning

When signal drops, a yellow banner appears above the viewfinder — "Poor network connection. Please connect to WiFi" — without taking over the screen. The customer can keep scanning if they want; the banner is a tap-target if they don't.

Scanner showing yellow network warning banner

2. Branded captive portal

Tapping the banner lands on Macy's branded captive portal — Connect to Free Macy's WiFi — with a single Accept & Connect button. The styling matches the app so the customer doesn't feel like they've been bounced into a settings menu.

Macy's branded WiFi captive portal with Accept & Connect button

Once back on the network, the scanner returns to its clean default state.

[IMAGE 5: Scanner — clean state] → Use page 16 of the PDF (scanner viewfinder with "Center barcode & hold still", no banner).

Recent Scans

A small but important affordance: a Recent Scans tray pinned to the bottom of the scanner. Customers often scan two or three items in a row, and reopening the camera each time is a frustration. Recent Scans gives them a one-tap return to anything they've already pulled up.

Scanner with Recent Scans button at the bottom

After the Scan: Product Card

The instant a barcode is recognized, a product card slides in over the dimmed photo of the tag — preserving the customer's mental model that they're still looking at the same physical item. The card carries everything they need to make a yes/no decision: name, size, color, ratings, and (most importantly) the live price.

A red banner — "Offer applied. $XX.XX saved" — calls out automatic discounts so the customer knows their loyalty pricing is already in there. No coupon hunting, no "did I get the deal?" anxiety.

This screen directly answers the research concern about accuracy of scanned items and prices. The customer sees the same item that's on the tag, the original price, the discounted price, and the offer applied — all at once.

Product detail card showing price and offer applied

The Bag Step

Tapping into the card expands it into a bag preview with a quantity stepper, a running savings total, the bag total, and a red Checkout button. Just below it: a faded scanner view with Add Items, so the customer can keep building a cart without losing the bag they've already filled.

The two-CTA pattern (Checkout and Add Items, always co-visible) was deliberate — it kept the customer from feeling trapped in a single-item flow.

Bag preview with quantity stepper, totals, and Add Items option

Checkout

Checkout itself is intentionally short. Saved payment from the user's profile, an email field for the receipt, an optional 10¢ shopping-bag toggle (a real Macy's policy in some states), and a purchase summary. Nothing the user hasn't already configured in the app gets re-asked.

This is the screen that addresses the security of payment information concern. The customer's saved Visa is shown with the last four digits — enough to confirm "yes, that's the right card" without ever exposing or re-entering anything sensitive.

Bag toggle off:

Checkout screen with bag toggle disabled

Bag toggle on:

Checkout screen with bag toggle enabled

The two-state pair shows the only meaningful interaction on the page — keeping the rest of the screen still emphasizes how short the form really is.

The Hand-Off: Receipt as Proof

The trickiest part of any "skip the line" flow is the moment the customer leaves the building. Items still have security tags. The customer still wants a bag. An associate at the door still needs to know this person actually paid.

So the receipt screen does double duty. It's the customer's confirmation — green check, "Thanks, one more thing" — and it's the proof they show an associate: "For security tag removal and a bag, show this screen at a checkout counter." Order metadata (item count, time, date) is large enough to read across a counter, and the email-receipt note reassures the customer the long-form record is already on its way.

This is the screen that closes the "what do I do if I need help?" loop. The customer never has to wonder about their next step — the screen tells them where to go and what to show.

Receipt screen with green checkmark and associate hand-off instructions

This was the screen we iterated on the most. Earlier rounds buried the "show this to an associate" instruction; moving it directly under the green check made the customer's next physical step obvious without making the screen feel transactional.

Key Challenges & Solutions

Challenge: Building Trust in Self-Checkout

A customer who's never used the feature has to believe — before they walk past an associate — that the app actually charged them.

Solution: Clear visual confirmation at every step. The product card shows exactly what was scanned, with an image, name, size, color, and price. Checkout shows the saved card with the last four digits. The receipt screen shows a green check, the item count, and the time. At no point is the customer guessing what just happened.

Challenge: Handling a Flaky In-Store Network

A scanner that silently fails inside a marble-walled flagship is worse than no feature at all.

Solution: The non-blocking yellow banner + the branded captive portal hand-off. Together they let the customer recover their connection in two taps without ever leaving the app's visual world.

Challenge: Closing the Loop with Associates

Self-checkout doesn't actually remove the associate — it changes their job. The flow needs to give them something to verify against.

Solution: The receipt screen as a hand-off artifact. Big checkmark, big timestamp, big item count. Designed to be read across a counter at arm's length.

More Work