Lefties Self-Checkout — One retail problem, two devices

Overview

Lefties has no self-checkout. The Inditex-owned fast-fashion chain still runs entirely on traditional counter service: customers browse the racks by hand, queue for a fitting room, queue again to pay, and speak to a staff member whenever anything goes wrong. Two queues and one bottleneck, in a store format built around high volume and low prices.

This project asked what would happen if that changed — and answered it twice, on two very different devices:

• Part A — a large-format self-checkout kiosk that uses AI and augmented reality to let customers try garments on virtually, then pay without staff assistance.
• Part B — a companion mobile app built on NFC and a grab’n’go model, where scanning a product adds it straight to the cart.

The result is a full design process — brand research, task analysis, conceptual model, sketches, wireframes, low-fidelity and high-fidelity prototypes — carried through to two complete, screen-by-screen interfaces, including the error states, confirmations and assistance flows that concept work usually skips.

Read this as a UI and process piece, not a research piece. This was a solo undergraduate assignment, developed speculatively around an existing brand with no client involvement and, critically, no usability testing with real users. Everything below is design reasoning, not validated evidence — and the section “What I’d do differently” says exactly where that gap sits.

The brief

The course brief was open: choose a real company, research its identity, and design a graphical interface for a self-checkout machine — then a mobile counterpart.

I chose Lefties for three reasons:

1. The gap was real. Lefties genuinely had no self-service technology in store at the time. The problem wasn’t invented for the exercise.
2. The brand system was strong and legible. A tight visual identity (neutral tones, a distinctive lowercase wordmark, clean modern typography) gives a designer clear constraints to work inside rather than a blank canvas.
3. The context is high-friction by nature. Fast fashion means high footfall, high transaction volume, and customers who make quick decisions — exactly the conditions where interface efficiency is measurable in queue length.

Understanding the retailer

Before any screens, I built a picture of who the brand is and how it speaks, so the interface could inherit an existing voice instead of inventing one.

Who Lefties is. A Spanish brand headquartered in A Coruña, founded in 2013 under the Inditex group — the same parent company as Zara, Massimo Dutti and Pull&Bear. Modern, affordable clothing across all genders, sold both in physical stores and online, positioned around sustainability and social responsibility in its supply chain.

How Lefties speaks. I broke the brand system into five dimensions that translate directly into interface decisions:

Why this step matters: a self-checkout is a brand touchpoint, not a utility. If the machine feels like generic POS software, it breaks the store experience it sits inside. Every interface decision below traces back to a row in this table.

Task analysis

I ran a structured task analysis on the existing in-store experience, working through a standard question set. Condensed:

The three findings that drove the design:

• Two queues, not one. Most self-checkout thinking targets payment. Here, the fitting room is an equal bottleneck — which is why both concepts include a virtual try-on rather than only a faster till.
• Learning happens by watching. With no training and no onboarding, an unfamiliar machine in a busy store either explains itself immediately or gets abandoned. This pushed towards a large standby screen with a single obvious entry point, and later towards a written instruction manual for the app.
• Help must stay reachable. Removing the staff member removes the fallback. A “call an assistant” path had to exist on the machine and in the app, otherwise self-service just converts one failure mode into a worse one.

The conceptual model

Both parts share the same underlying object model, defined before any screen was drawn.

Objects and attributes

Relationships

1. A product can have multiple sizes, colours and images associated with it.
2. Multiple products can sit in one cart.
3. A customer can have a purchase history.

Why define this first: the object model is what allowed the same conceptual foundation to produce two genuinely different interfaces. The kiosk and the app manipulate the same five objects — they just differ in how the user reaches them, which is a device question, not a domain question.

Part A — the kiosk

Conceptual model: a graphical interface for a Lefties self-checkout machine combining AI and augmented reality to assist the customer and let them try garments on in seconds.

Metaphor: guided shopping. The customer sees themselves on screen and tries clothes and accessories on virtually. From there they can select sizes and colours and buy, with no staff assistance and no physical fitting. Scanning a QR code linked to their account brings in purchase history and a favourites list to try on directly.

Interface decisions and the reasoning behind them:

• A standby screen that reads at distance. Full-bleed campaign photography, the wordmark, and a single instruction — Toca para iniciar a tua experiência. In a store where nobody is trained, the machine’s first job is to look approachable and have exactly one entry point. Account login sits in the corner as a QR code: optional, never blocking.
• Progressive category narrowing. Homens / Mulheres / Crianças first, then a second pill row (Blazers, Camisas, Calças, Acessórios, Sapatilhas, Calções, Casacos), then the product grid. A slide-out menu offers the full category tree for users who already know what they want. Two navigation depths for two levels of intent.
• Rhythm in the grid. Product rows are interrupted by full-width campaign banners. This is a retail convention borrowed deliberately — it prevents the endless-grid fatigue of a scrolling catalogue on a large screen.
• Availability shown, not hidden. Sold-out sizes are struck through in the size selector and the buy button becomes a disabled ESGOTADO state, keeping the price visible. The product still exists; only the action is removed. Sold-out variants in the AR view carry the same treatment.
• Payment adapted to the local context. Multibanco and cash, plus the NIF-for-invoice prompt that any Portuguese retail checkout requires. The cash flow shows an outstanding-amount readout as the customer inserts notes.

Part B — the app

Conceptual model: a graphical interface for a Lefties self-checkout app using NFC and a grab’n’go model — customers scan the products they want and they go straight into the cart, making the experience simpler and faster.

The app is not a shrunk-down kiosk. The device changes what is possible, so the interaction model changes with it:

The decisions worth defending:

• NFC as a location signal, not just a payment rail. The most interesting move in Part B is using NFC for the assistance flow: instead of raising a hand or hunting for a staff member across a large shop floor, the customer taps their phone to a marked bar and staff are told where they are. It solves a genuine store problem — the customer knows what they need, but not where help is.
• Scanning replaces browsing as the primary path. In the kiosk, the catalogue is the way in. In the app, the physical garment in your hand is the way in. This is what makes grab’n’go coherent: the phone augments the shelf rather than duplicating the website.
• Gestural editing in lists. Swiping a row in Favourites or the cart reveals its actions. This keeps list rows clean and dense — appropriate for one-handed use while walking through a store — but it is also the decision I would most want to test, since discoverable gestures are exactly what unaided users miss.
• Structured problem reporting. A dedicated Reportar Problema form with name, email, description and a screenshot attachment. When you remove the staff member from the transaction, the complaints book has to be replaced with something.

Designing the unhappy paths

Most of both prototypes’ screen count sits outside the happy path, and that was intentional.

Two conventions run through all of them: the safe option is the visually dominant one (the coral Não against the muted Sim), and every dead end offers a way back. Neither is novel — both are Nielsen’s error-prevention and user-control heuristics applied literally — but designing them explicitly is what separates a prototype from a screen mockup, and it is the part of this project I would still defend without qualification today.

Onboarding

Part B ships with an instruction manual — a documented mapping of every icon and gesture to its function: the assistance icon, QR login and scanning, the cart, lateral swipe to exit and go back, favouriting, the try-on control, colour selection, size and quantity, screenshot attachment, and the NFC bar.

This came directly from the task analysis finding that customers learn by observation with no training. It is also, in hindsight, a tell: if an interface needs a manual to explain its gestures, the gestures are carrying too much of the load. Writing the manual was the right instinct; what it actually documented was a discoverability problem I couldn’t see at the time.

What I’d do differently

This is a 2022/23 undergraduate project. Three years and an MSc in Interaction Design later, here is the honest audit:

• Test before high fidelity. There was no usability testing at any stage. A five-participant think-aloud on the low-fidelity prototype would have cost an afternoon and would have caught the discoverability problems the instruction manual is quietly compensating for — particularly the swipe-to-edit gesture and the two-tier category navigation.
• Validate the AR premise, don’t assume it. Virtual try-on on an in-store kiosk raises real questions I didn’t confront: how long the interaction actually takes under queue pressure, how it behaves in variable store lighting, and — most importantly — the privacy implications of a camera capturing a customer’s body in a public retail space. The concept is defensible; presenting it without those constraints stated is not.
• Justify the two-queue claim with data. The core premise — that the fitting room is as much a bottleneck as the till — came from observation, not measurement. Timed observations of queue length at both points would have turned a plausible assumption into an argument.
• Run a consistency pass on the system. A design system with named tokens and component states would have prevented the drift visible across screens.

Learnings

• The device changes the interaction model, not the domain model. The same five objects and three relationships produced a browse-first kiosk and a scan-first app. Separating what the system is from how it is reached is what made the two parts coherent instead of redundant.
• Removing staff means replacing everything staff did. Not just the transaction — also the wayfinding, the reassurance, the recovery when something breaks, and the complaints channel. Self-service design is mostly failure design.
• Documentation is a diagnostic. The moment I found myself writing a manual to explain the gestures, I had evidence of a usability problem. I treated it as an onboarding deliverable rather than a signal — that reframing is the single biggest difference between how I worked then and how I work now.
• Brand research is interface research. Translating five brand dimensions into concrete UI rules up front meant the visual decisions later were derivations rather than preferences, and I could explain any of them without falling back on taste.