Object-Oriented User Interfaces

Your constantly-updated definition of Object-Oriented User Interfaces and collection of videos and articles.
Be a conversation starter: Share this page and inspire others!

418 Shares
Save

Get 1 Powerful Email Each Week

Join 315,231 subscribers.

What are Object-Oriented User Interfaces?

Object-oriented UIs (User Interfaces) are structured around the objects (nouns) users care about and their relationships. Objects are things, for example files, messages, and tasks, and actions are operations on those objects, rather than being the focal point of the interface. This matches how people naturally think about their work.

Instead of forcing users to rely on File, Edit, and View menus and memorizing where commands live, you present the things they want to work with directly on screen. A message object shows sender, subject, and preview text. Select it, and reply, forward, and archive options appear. The interface adapts to users, not the other way around.

This approach works because it mirrors how you already think. When you walk into your kitchen, you don't mentally scroll through possible actions. You spot the glass you want, and reaching for the cabinet follows naturally. Show people what they want to work with, and they'll instantly know what to do with it.

In this video, William Hudson, User Experience Strategist and Founder of Syntagm Ltd, explains how popular apps like Instagram, Notion, and Airbnb demonstrate object-oriented patterns that make interfaces feel intuitive from the first interaction.

Transcript

Real-World Object-Oriented User Interfaces You Use Every Day

You already use object-oriented interfaces daily, probably without realizing it. While these products may or may not have been created using formal object-oriented user interface approaches, examining them with these principles reveals why they work so well. Here's how:

Email Applications

Gmail inbox showing a list of email message objects with sender names, subject lines, and preview text, alongside an open compose window for drafting a new message.

Gmail displays message objects with key attributes (sender, subject, and preview) visible at a glance. Selecting a message or opening the compose window reveals only the contextual actions relevant to that object, which keeps the interface clean and focused.

© Google, Fair use. Modified by Interaction Design Foundation.

Gmail and Outlook demonstrate object-oriented patterns. When you open your inbox, you see message objects with visible attributes: sender name, subject line, preview text, and timestamp. You select a message, and contextual actions appear:

  • Reply

  • Forward

  • Archive

  • Delete

  • Mark as spam

Conversation threads illustrate object relationships. Related messages group together as a single conversation object. You expand the conversation to see individual message objects within it. This structure mirrors how you think about email: Conversations contain messages, and messages have senders, subjects, and content.

Travel Booking Platforms

Ryanair seat selection screen showing a visual map of available and unavailable seats on an aircraft, with passenger names and seat options displayed as part of the reservation booking object

Ryanair's booking interface demonstrates object-oriented design: The reservation object organizes flights, passengers, and seats, while contextual operations like "modify booking" and "select seats" keep interactions intuitive despite the platform's underlying complexity.

© Ryanair, Fair use. Modified by Interaction Design Foundation.

Airline booking systems like Ryanair illustrate object-oriented interface principles. The reservation is the central object that contains flight objects, passenger objects, and seat objects. You see your reservation with visible attributes: Flight numbers, departure times, passenger names, and booking reference.

You interact with the reservation object through contextual operations: Modify booking, select seats, add baggage, and check in. Each operation makes sense in the context of the reservation object. The interface manages complexity by organizing everything around objects you understand.

Social Media Platforms

Instagram home page displaying a post object with an image, caption, like count, and comment options, alongside navigation icons for accessing the home feed, profile, and messages.

Instagram organizes its interface around distinct object types (posts, profiles, and messages) each with their own visible attributes and contextual actions. Interacting with a post surfaces options like like, comment, and share, while switching to a profile reveals follow and message actions instead.

© Instagram, Fair use. Modified by Interaction Design Foundation.

Platforms like Instagram demonstrate object-oriented interface design clearly. Posts, profiles, stories, and messages are distinct object types with different attributes and operations. When you view your feed, you see post objects with visible attributes: Images, captions, like counts, and timestamps.

You interact with post objects through contextual operations: Like, comment, save, and share. You interact with profile objects differently: Follow, message, view posts. Each object type has operations that make sense for that object.

To make object-oriented user interfaces less abstract, we've created a case study of Instagram as an object-oriented interface. Download this free template to quickly see how those core concepts translate into a real-life interface.

Advance Your Career With This Free Template for “Instagram as an Object-Oriented UI”
Instagram as an Object-Oriented UI
Optional
Optional
We respect your privacy
Get 1 powerful email each week: Learn Design and AI From the Best.

How Object-Oriented User Interfaces Improve User Experience and Satisfaction

Object-oriented user interfaces create experiences that feel effortless from the first click. Here's why they work:

Users Learn Instantly and Make Fewer Mistakes

Object-oriented user interfaces feel instantly familiar because they show users things they already recognize: Messages, tasks, files, and products. They select one and discover what they can do with it. No training is needed because the interface mirrors concepts they already know from the real world.

Gmail works this way. Users see messages with senders, subjects, and previews. They click one and find they can reply, forward, or archive. The message makes sense and the operations make sense. This immediate recognition reduces learning time from hours to minutes, or even seconds.

Users can't accidentally delete something when nothing is selected. They can't perform operations that don't apply to what they're working with. The interface only shows them valid choices based on their selection. Better yet, objects behave consistently everywhere. Messages work the same way in inbox, sent mail, and drafts. Users learn it once and apply it everywhere.

Users Feel in Control

Every action gives users immediate, visible feedback. They drag a file and watch it move. They swipe a message and watch it disappear. They resize a window and see it respond instantly. They're manipulating objects directly, not issuing commands and hoping something happens. This builds confidence and creates a sense of mastery.

Products Grow Without Overwhelming Users

When you want to add new features or capabilities to your product, you attach or relate them to the objects users already understand. Adding scheduling to email? "Send later" appears as an option on messages. Adding collaboration to tasks? "Assign to" appears on tasks.

Users don't face entirely new interface patterns when the product grows. Someone who learned the interface with 10 features can still navigate it comfortably when it has 10 more because the organizing principle remains consistent.

Complex Systems Feel Simple

Object-oriented user interfaces make complex products with many features easy to navigate by organizing everything around familiar objects. Products that offer dozens or even hundreds of capabilities remain straightforward when you structure them around what users want to work with.

Two Monzo app screens side by side showing the banking interface and transaction lists: The left screen displaying one account, the right showing three accounts

Monzo organizes banking complexity around familiar objects like accounts, transactions, and cards.

© Monzo, Fair use. Modified by Interaction Design Foundation.

Consider banking apps like Monzo. Banking involves countless features: transfers, payments, budgets, savings, cards, statements, direct debits, standing orders, and more. An object-oriented approach organizes this complexity around core objects users understand: accounts, transactions, and cards.

  • Users select an account object and see relevant operations: transfer money, view transactions, set budgets.

  • Users select a transaction and see contextual actions: split with friends, add notes, request receipt.

  • Each object groups related features, so users never face an overwhelming menu of every possible banking operation.

This approach hides the underlying technical complexity. Behind each transaction object are database queries, security protocols, and payment networks, but users simply see a transaction they can split or categorize. The object-oriented interface encapsulates complexity, so users focus on their goals rather than system mechanics.

What Makes Object-Oriented User Interfaces Work?

Object-oriented user interfaces are effective because of these core principles.

Before exploring these principles in detail, William Hudson explains how conceptual models form the foundation of object-oriented design. Using Amazon's website evolution from 2002 to present, he demonstrates how core objects remain consistent even as visual design changes.

Transcript

Show Objects, Not Actions

When you open an object-oriented user interface, you immediately see the things you want to work with, not menus of actions you can perform. In a file manager, you see files and folders. In a task app, you see tasks. In a shopping app, you see products. These objects occupy the primary visual space using clear representations like cards, list items, or thumbnails.

The interface makes objects discoverable through visual design. Cards show photos with captions and like counts. List items show tasks with due dates and assignees. Product tiles show images with prices and ratings. You scan objects and identify what matters without opening menus or settings.

Objects display their essential properties directly on screen. A reservation shows flight number, departure time, and passenger names. A message shows sender, subject, and date. A product shows image, price, and availability. You see what defines each object without additional interaction, which enables quick decision-making.

Show Actions Only When Users Need Them

Instead of presenting menus full of commands, object-oriented user interfaces show you what you can do based on what you've selected. When you select a photo, editing and sharing options appear. When you select an email, reply and forward options become available. When you select a file, open, rename, move, and delete options appear.

This approach is called progressive disclosure, and object-oriented user interfaces make excellent use of it. The two approaches work hand in hand: objects provide the structure, and progressive disclosure reveals relevant operations at the right moment.

Contextual actions keep interfaces clean and focused. Instead of showing every possible operation at once, the interface reveals operations relevant to your current selection. This reduces visual clutter and cognitive load significantly. You see only what matters for your current task.

The pattern works consistently: select an object, see relevant operations. This predictable interaction model means you quickly learn to select first, then choose an action.

Make Objects Behave Consistently

All objects of the same type work the same way throughout the interface. Every email message responds to the same operations: reply, forward, archive, delete. Every task offers the same core actions: mark complete, change priority, reassign. Every file supports the same contextual menu: Open, rename, move, and delete.

You see a message in your inbox and learn you can reply to it. That knowledge applies to messages in sent mail, drafts, spam, and all other folders. The message object works consistently regardless of location or context. You don't need to learn different operations for the same object type in different places.

This behavioral consistency extends to how objects display their attributes. All messages show sender, subject, and date in the same visual pattern. All tasks show title, due date, and assignee in the same layout. Visual consistency reinforces behavioral consistency.

Let Users Touch and Move Objects

Object-oriented user interfaces let users interact directly with meaningful objects, often in ways that resemble how they handle real-world items. You can drag files between folders, swipe messages to delete them, or reorder tasks by priority. These interactions feel natural because these actions are tied to visible objects, not abstract commands.

Direct manipulation requires objects to be first-class interface elements, not hidden data. When files appear as visual objects on screen, you can grab and drag them. When messages appear as swipeable cards, you can swipe them away.

When you drag a file, it moves visually as you drag. When you delete a message by swiping, it slides off screen. When you resize a window, it changes in real time under your pointer. This immediate response builds confidence and helps you understand what actions do through direct visual feedback.

Connect Objects the Way Users Think About Them

Objects connect to other objects in ways that reflect real-world relationships. An email message belongs to a conversation thread. A task belongs to a project. A photo belongs to an album. A reservation has flights and passengers.

The interface shows these relationships visually through grouping, hierarchy, and containment. Conversation threads group related messages together. Project views display all related tasks grouped by project. Albums contain related photos shown as a collection.

You navigate by following object relationships rather than searching through flat lists. You open a conversation to see its messages. You open a project to see its tasks. You open an album to see its photos. This navigation pattern matches how you think about finding related items.

Create Your Own Object-Oriented Interface in 5 Steps

Building an object-oriented user interface requires careful attention to user needs and systematic application of core principles.

A sequential diagram illustrating five steps for creating object-oriented user interfaces: Identify primary objects, build a conceptual map, define contextual actions, make objects visible, and test and refine.

This five-step process provides a systematic method for creating object-oriented user interfaces that match user mental models and scale gracefully as your product grows.

© Interaction Design Foundation, CC BY-SA 4.0

1. Identify Your Primary Objects

Start by understanding what users want to work with. What nouns do they use when describing their work? In a project management tool, primary objects might be projects, tasks, and team members. In a healthcare app, they might be patients, appointments, and medical records.

In this video, William Hudson explains how use cases from object-oriented software design help identify the objects users interact with, bridging the gap between requirements and implementation.

Transcript

Conduct user research through interviews and observation. Listen for the nouns users mention most frequently. Watch which items they interact with repeatedly.

2. Build a Conceptual Map

Design your interface to display these objects prominently. Use clear visual representations: cards, list items, thumbnails, or icons. Add meaningful labels and show essential properties for each object.

Map these relationships to create the underlying structure of your interface. A project might contain multiple tasks, and each task might be assigned to one team member. An appointment connects to a patient and generates medical records. These relationships determine how users navigate between objects and how information flows through your system.

This conceptual map becomes the foundation for your entire interface. It shows which objects contain other objects, which objects link to each other, and how users move between related items.

3. Define Contextual Actions

Determine what actions make sense for each object type. What can users do with a project? View details, edit, share, archive, delete. What can they do with a task? Mark complete, change priority, reassign, ad add comments.

Map these actions to specific object types. Not all actions apply to all objects, so create action menus specific to each object type.

4. Make These Objects Visible

Design your interface to display these objects prominently using clear visual representations: Cards, list items, thumbnails, or icons. Add meaningful labels and show essential properties for each object.

Decide which UI elements and screens you’ll use to communicate your objects:

  • A dashboard might show all projects as cards, each displaying project name, progress, and team members.

  • A detail view might show a single project with all its tasks listed below.

Choose visual patterns that make objects immediately recognizable and their relationships clear.

5. Test and Refine

Watch real users interact with your object-focused interface. Do they immediately understand what they can work with? Can they discover actions easily? Do similar objects behave consistently?

Measure the impact on user behavior. Track time to first successful action, error rates on common tasks, and support tickets related to navigation confusion. Object-oriented user interfaces should show measurable improvements: faster task completion, fewer errors, reduced support volume. If metrics don't improve, revisit your object definitions. You might have chosen objects that don't match user mental models.

Why Object-Oriented User Interfaces Matters More Than Ever

Most designers don't know object-oriented user interface design exists, which means you can apply principles that directly address common design challenges while many of your peers work without this framework. When you design with objects, users get intuitive experiences from the start. They see objects they recognize, select them, and discover what's possible, with no training manuals or lengthy onboarding required. This reduces frustration, support tickets, and abandonment.

This approach positions you as the bridge between user needs and technical implementation. While other designers focus only on visual design and user flows, you bring systematic thought that helps teams build confidently and users learn intuitively.

When you apply object-oriented principles, you can build a coherent product rather than a collection of features. Master this approach, and you create interfaces that users love and developers appreciate.

References

Want to design interfaces that feel intuitive from the first click? Take our course, Object-Oriented UI Design: Build Interfaces Users Love. You'll master how to turn complex requirements into coherent interfaces, create systems that scale effortlessly as your product grows, and become the designer who delivers clarity and consistency on every project.

Struggling to identify which objects belong in your interface? Use Cases: The Ideal Bridge Between Requirements and Design? shows you how to extract primary objects from user requirements, ensuring your interface matches how people think about their work.

Our article, Conceptual Models: The Hidden Structure Behind Your Next Great Interface reveals the invisible framework that makes complex products feel simple. You'll discover why consistent conceptual models let users navigate sophisticated features without confusion.

Questions About Object-Oriented User Interfaces?
We've Got Answers!

What is an object-oriented user interface?

An object-oriented user interface is an interface structured around the natural objects users care about (such as messages, bookings, documents, or tasks) and what they can do with those objects. Instead of organizing experiences around screens or isolated features, an object-oriented user interface organizes the interface around objects, their attributes, and their operations. This mirrors how people naturally think and aligns closely with object-oriented software development, creating a shared conceptual model between users, designers, and developers.

When should I use an object-oriented approach in UI design?

You should use an object-oriented approach when you are designing systems with multiple related entities, long-lived data, or growing complexity, such as dashboards, SaaS products, admin tools, e-commerce platforms, or enterprise systems. Object-oriented user interfaces are especially valuable when features keep accumulating and the product risks becoming fragmented.

Are object-oriented user interfaces still relevant in modern UX/UI design?

Yes! Object-oriented user interfaces are not only relevant but increasingly important in modern UX/UI design. While visual styles and interaction patterns evolve, the underlying structure of most successful digital products can be achieved through an object-oriented design approach. Modern apps still revolve around objects like accounts, playlists, orders, posts, and conversations.

Object-oriented user interfaces provide the structural backbone that allows modern patterns such as responsive design, progressive disclosure, and AI-assisted workflows to scale without chaos.

Are object-oriented user interfaces compatible with user-centered design and design thinking methodologies?

Yes, object-oriented user interfaces are highly compatible with user-centered design and design thinking. Objects are discovered through user research, interviews, and stories of use, not imposed by technology. Object-oriented user interfaces complement personas, scenarios, and iterative design by giving structure to insights uncovered during research. They help translate user needs into systems users can actually understand.

In this video, Willaim Hudson describes how design thinking's iterative, user-centered approach naturally leads to discovering the objects users care about, which object-oriented user interfaces then structure into understandable interfaces.

Transcript

How do you define “objects” in an object-oriented user interface context?

In object-oriented user interfaces, objects are the meaningful “things” users recognize and talk about, usually nouns that make sense on their own, such as a reservation, invoice, flight, or document. Objects have attributes (properties like date, status, or owner) and operations (things users can do, such as edit, delete, share, or book). Objects are usually identified by analyzing user research.

Why is object-oriented user interface design important in UX?

Object-oriented user interface design helps you create interfaces that match how users naturally think. Users don't think in features and screens; they think in objects like messages, reservations, or projects. When you organize your interface around these objects, you create experiences that feel intuitive and require less mental effort. This approach also helps you manage complexity as products grow. Instead of adding disconnected features, you build a coherent system where new functionality connects naturally to existing objects.

An object-oriented user interface provides structure through a shared conceptual foundation that improves collaboration, reduces redesigns, and makes interfaces easier to scale.

What is the main difference between traditional user interfaces and object-oriented user interfaces?

Traditional user interfaces are often organized around screens, menus, or features, which can fragment the experience as systems grow. Object-oriented user interfaces, by contrast, are organized around objects and their relationships, providing continuity and coherence across the product. In object-oriented user interfaces, screens become views of objects, not destinations in themselves. This shift moves design from “stitching screens together” to “building systems.”

What are some highly cited scientific articles or books about object-oriented user interfaces?

van Harmelen, M. (1995). Object-oriented modelling and specification for user interface design. In P. Palanque & R. Bastide (Eds.), Design, specification, and verification of interactive systems '95 (pp. 179–196). Springer.

This paper introduces a structured approach to using object-oriented models in the specification of user interfaces, offering a bridge between software engineering practices and user-centered design. It is foundational for those designing interfaces that reflect the structure of the application’s underlying object model, promoting better alignment between system logic and user interaction. It is widely cited for formalizing how designers can model UI behavior using object-oriented paradigms.

Collins, D. (1995). Designing object‑oriented user interfaces. Benjamin/Cummings.

This work is a seminal academic/engineering text on object-oriented user interfaces design. It defines what an object‑oriented UI is, presents a comprehensive methodology for designing both the visible interface and the software architecture that underlies it, and explains how object‑oriented principles (like objects, classes, and interactions) can shape UX decisions in practice. It’s widely cited in research linking OO design with UI engineering.

Earn a Gift, Answer a Short Quiz!

1
2
3
4
1
2
3
4
Question 1
Question 2
Question 3
Get Your Gift

Question 1

What should happen when a user selects an object in an object-oriented interface?

1 point towards your gift

  • A tutorial should explain what the object does
  • Contextual actions relevant to that specific object type should appear
  • The interface should display a complete list of every possible action in the system

Question 2

How do object-oriented interfaces handle complexity?

1 point towards your gift

  • By presenting simple objects that hide technical implementation details
  • By showing users all system processes and technical details upfront
  • By limiting the number of features available to users

Question 3

What makes objects in an object-oriented user interface behave predictably?

1 point towards your gift

  • All objects of the same type work the same way throughout the interface
  • Each object has unique behaviors depending on where it appears
  • Objects change their behavior based on user preferences

Learn More About Object-Oriented User Interfaces

Make learning as easy as watching Netflix: Learn more about Object-Oriented User Interfaces by taking the online IxDF Course Object-Oriented UI Design: Build Interfaces Users Love.

Why? Because design skills make you valuable. In any job. Any industry.

In This Course, You'll

  • Get excited about transforming messy requirements into smooth, user-centered interfaces. Object-oriented UI design is a methodology most designers haven't been formally taught, which means most teams still assemble features without a system behind them. They end up with interfaces that confuse users and cost development time. According to Forrester's research, a clear, intuitive UI can double conversion rates. Object-oriented UI design makes that achievable: You base your interface on a conceptual map of the objects (things) your users care about, so it reflects how they naturally think. This approach also bridges the gap between UX and development. Master this methodology, and you'll design interfaces that grow with your product, collaborate seamlessly with developers, and work with a systematic approach that's becoming the new standard in UX and product design.

  • Make yourself invaluable by keeping design and development in sync. You'll stop losing user-friendliness in translation, because you'll learn to speak the shared language of stories of use, epics, constraints, conceptual models, and design maps. You'll understand development constraints and technical realities, so you avoid impractical designs, bugs, and expensive redesigns and keep projects on track. Pruitt and Adlin’s persona-weighted feature and prioritization matrices will enable you to prioritize what matters most, avoid wasted effort, and guide teams toward solutions that serve users. The result? Faster workflows, better decisions, smarter collaboration. You become the go-to person everyone trusts to drive real impact on critical projects.

  • Gain confidence and credibility as the designer who cuts through complexity and delivers clarity. No more guessing, no more "just add one more feature." You’ll have a structured framework for interface design built around Cook and Daniels' three levels of detail: essential, specification, and implementation. You'll know how to analyze requirements, prevent feature creep, and scale interfaces that stay consistent, intuitive, and loved by users. And when you replace your team's abstract user stories with researched persona stories, you'll foster empathy for real users and put them at the heart of product development. This will make you a respected partner in every cross-functional collaboration.

  • Craft your personal portfolio with results that show your skills. In these optional activities, you'll write compelling user stories, create wireframes and prototypes, and deliver design maps that show how you move from requirements to implementation-ready UI. You'll integrate your new skills as you create career assets that demonstrate something most candidates can't show: You can deliver designs users love and development teams can easily build.

Learn From Industry Leaders

Master complex skills with proven best practices and toolkits directly from industry leaders. Meet your expert for this course:

  • William Hudson: User Experience Strategist and Founder of Syntagm Ltd.

Earn Industry-Recognized Certificates

Industry giants trust our courses to train their teams, and prestigious universities integrate our content into their curricula. Add your certificates to your LinkedIn profile, résumé, and job applications.

Our clients: IBM, Harvard University, University of Cambridge, NASA, Adobe, Stanford, Massachusetts Institute of Technology, LinkedIn
Course Certificate

All Free IxDF Articles on Object-Oriented User Interfaces

Read full article
How to Design Use Cases in UX - Article hero image

How to Design Use Cases in UX

Imagine a new mobile app or an e-commerce site gets launched; it looks great, sure, and it should be a hit because it at least looks like it’s got what it takes, but—drumroll—it tanks in the marketplace, all because people find it hard to complete even the simplest tasks. That’s rough, but—behind th

Social shares
799
Published
Read Article
Read full article
Object-Oriented UI Design: How You Can Collaborate Seamlessly with Developers and Build Better Products - Article hero image

Object-Oriented UI Design: How You Can Collaborate Seamlessly with Developers and Build Better Products

You’re at your routine health checkup, sipping an iced coffee on a hot day. Suddenly, you get a sharp pain in your head. The doctor looks up from her notes, a sympathetic expression on her face. “You’re experiencing sphenopalatine ganglioneuralgia.” Your heart sinks. The coffee cup drops to the floo

Social shares
116
Published
Read Article
Read full article
7 Reasons Object-Oriented UI Design Will Grow Your Career - Article hero image

7 Reasons Object-Oriented UI Design Will Grow Your Career

Vacation time! You book your flight. You have a reservation. It's real. You paid for it. And yet, when you open the airline's app to look at it, it's surprisingly elusive. You don't want to check in, you don't want to change it, you just want to find it and check the details. It's not on the home sc

Social shares
112
Published
Read Article
Read full article
Copy These 3 Industry-Leading Apps and Turn Object-Oriented Design into Your Secret Career Advantage - Article hero image

Copy These 3 Industry-Leading Apps and Turn Object-Oriented Design into Your Secret Career Advantage

Which apps do you use throughout your day? Maybe you manage your projects on Trello, use Notion as an internal docs site, and maybe, just maybe, you do some swiping on Tinder during your lunch break. Despite looking nothing alike, these three highly successful apps are organized around the same idea

Social shares
111
Published
Read Article

How to Design Use Cases in UX

How to Design Use Cases in UX

Imagine a new mobile app or an e-commerce site gets launched; it looks great, sure, and it should be a hit because it at least looks like it’s got what it takes, but—drumroll—it tanks in the marketplace, all because people find it hard to complete even the simplest tasks. That’s rough, but—behind that—the use cases for the digital product weren’t planned well, and it’s the real “culprit.” Use cases are situations that outline how a user interacts with a product or service, in steps from their user goal through to the fulfillment of it. See some real-world examples, know how to make good ones, and get these right and you’ll be able to plug in insights that can help that app or site to rock and rule when it hits the market!

What is a Use Case in UX?

Use cases in UX (user experience) design are essential for continuous product discovery, where teams search and test ideas regarding the target audience’s needs, challenges, and desires, and more. Product managers and UX designers need a clear view of this information because it fills in a great deal about the “why” and “how” behind successful product design, and it guides them through the user journey, helps guardrail them from mistakes that could cost big-time in the “hurt” department for the brand, and helps them produce a user-friendly interface.

Each use case starts with a user goal and ends when the system fulfills that goal, and the use case details this process through simple and active steps.

Example of checkout page as a use case in user experience.

© Interaction Design Foundation, CC BY-SA 4.0

Use cases revolve around what users do—and what they need or want to do—on a design solution you intend to give them; so, for this, think about a use case for the checkout page of a site where, first of all, the customer navigates to the checkout page. Then, the system displays a summary of items, total cost, and payment options for that person to review, after which they pick a payment method that suits them.

And then, with the payment info done and dusted and out of the way, the system asks for a shipping address, to which the customer responds and enters their address details. From getting that input, the system calculates shipping costs and taxes, shows it to the customer, who then reviews the final amount and, happy—or at least satisfied with how things are, even if they’re not too thrilled price-wise—then confirms the purchase. And, with that, the system processes the payment and then sends a confirmation email to the customer; job done for this use case.

When you explore user behavior by creating specific use cases like this, it lays the foundation for building an intuitive and user-friendly product—not least since you’ll have been able to shape the user experience. The “trick”—or knack—to this is that you use use cases that are based on researched and tested user experience so they’re grounded in real-life data.

What are Benefits of Incorporating Use Cases in UX?

Maybe a better way of wording that might be to put it as—since creating use cases isn’t a step to skip or overlook—“What are the perils of not incorporating them?” and the opening lines of this piece kind of hinted at what might happen. In any case, though, whether you’re in the early stages of design of a brand-new product or in the process of refining a product, use cases help bucket-loads.

Streamlines Design Process

Since use cases outline what a user needs from a product, they can help you create journey maps and understand what to focus on rather than—more or less—guess into the problem space, and that knowledge is something that makes the design process faster and more efficient. When a team’s got clear ideation and specific goals, they can safeguard themselves from wasting time and effort on less important features that might even work against the digital solution in a holistic sense.

For example, imagine if you had a task of designing a travel booking app—a clear use case would give you the framework you’d want (and need!) to see how you’d have to prioritize ease of search, payment, and confirmation to give your users awesome service. Then, when you’ve got a firm grasp of that, you and your design team can then move forward with a single, clear goal in mind to make sure that the app would live up to what its core purpose is and no travelers-in-waiting would be left “stranded,” wanting something they had needed.

Watch as CEO of Experience Dynamics, Frank Spillers explains important points about service design:

Transcript

Reduces Development Costs

In the finest tradition of UX research and user research, when you know what the users’ needs are upfront, it’ll help prevent costly rework from needing to happen later in software development and stakeholders won’t need to scream—another bonus. To take an online grocery store as an example, if the use case indicates a “quick checkout” is a good idea, then developers can implement this feature from the start, and so save them—and the brand paying them—from the financial burden of having to modify the system later on.

Improves User Satisfaction

One of the big ideas with use cases is that they cover all eventualities that users might encounter when using a product—a niftily structured approach to problem-solving ahead of the game for them. Because of this, when you’ve got solutions designed with comprehensive use cases, they’re ones that are more likely to be robust and usable as they stand up in the marketplace and get lauded due to the greater user satisfaction they deliver. 

Enhances Team Collaboration

When everyone understands the use cases, there’s a unified vision and stakeholders, developers, and other team members can be on the same page at every turn in the design process. Imagine a team working on a fitness app, and from knowing the key use case is “easy tracking of workouts,” designers and developers align their tasks, so raising efficiency levels and helping ensure that each team member does their part in the name of the user and of successful project management.

What is The Process of Creating Use Cases in UX?

Elements of a use case and the 5 step process of creating use cases in UX.

© Interaction Design Foundation, CC BY-SA 4.0

What are Essential Elements a Use Case Needs to Have?

First up, the actor needs to be there—and in system design, this is a role such as customer or passenger, while in user experience design, it would be a persona who acts on the system, and you’d want to design the best persona possible for that.

Then there are the goals—as in, you want your actor to achieve these objectives with the product, and for them to get there, they’ll then need to take actions, which are the steps the user needs to take to reach the particular goal along with the system response.

Then there are flows to get into, and the basic (success) flow is the ideal sequence where the user achieves the goal without issues, and so the seamless experience has a much better chance of coming about. But in case something does crop up—or some things do get in the way— you’ll want an exception flow to cover situations where the user can’t achieve the goal. Alternative flows are the next thing to look into, and they outline other routes a user might take to reach the goal—plus, alt flows also include error conditions.

Identify Target User Groups

Let’s say we want to create a website review app—and the first step there is to perform user research and identify who is going to use the app: business owners, digital marketers, or SEO experts? To get behind the “who,” you create user personas and know your target audience so you can shape the features and functionalities you’re going to focus on.

Watch as CEO of Experience Dynamics, Frank Spillers explains important points about personas:

Transcript

Define Goals and Objectives

You want your persona to achieve specific goals and objectives and get through the tasks to the ultimate goal without disruption, and so you’re going to want to define them while you create your use cases. For this, you’re going to want to distinguish goals for different personas to help you better understand individual needs and intentions.

The persona for a website review app might aim “to analyze and improve website performance,” for example, and for additional objectives you could have “monitor SEO metrics” or “track visitor behavior.” And for the different personas, you’ll want to define the primary and secondary actors for the use case.

The primary actor is central to a particular use case and wants to achieve a goal using the system, and they’re the main beneficiaries of the system and the ones who tend to initiate the use case in the first instance.

Then, you’ve got the secondary actors—and they’re the ones who help the system achieve the primary actor’s goal for them, and provide additional services or information that the system needs to fulfill the primary actor’s request.

So, to take each actor, represented as personas, the goals would be like this, for instance. First, we’ve got James, who’s a front-end developer, a primary actor in this—and his primary goal is to analyze and improve website performance. Leslie is up next, an SEO analyst, who’s a secondary actor in this, with a primary goal of optimizing the website for search engines; and then, bringing up the rear, is Ruskin, a UX lead—another secondary actor, whose primary goal is to deliver an exceptional user experience on the website; a noble cause if ever there was one!

List Actions and Scenarios

The “people” are in place, and so “What are they going to do?” is the question to answer with all the actions which a persona has to perform to achieve the goal they want to get to—and what they get up to in aid of their goal may include “logging in,” “inputting a website URL,” or “selecting a type of analysis.”

Those are actions, but what you’ll also want to do is to outline the basic, exceptional, and alternative flows—for instance, the basic flow could be a successful login and analysis, while the alternative flow could include actions taken whenever a user forgets a password (something that does—and may well continue to—happen with many a user).

Watch as Author and Human-Computer Interaction Expert, Professor Alan Dix explains important points about user scenarios:

Transcript

Create Wireframes, Mockups, or Prototypes

Now you’ve got the first fundamental things in place, it’s time to head on over and create wireframes, mockups, or prototypes using UX design tools like Sketch or Figma and base them on the defined actions and flows—the visual representation you get from that will serve as a blueprint for you as a designer and your design team, and developers, too.

Conduct Usability Testing

You’re done creating a wireframe or prototype—well done—so now it’s time to conduct usability tests on it, and what tests should do is involve personas performing the goals identified in your use cases. Be sure to watch for any friction or obstacles that deviate from the basic flow, and then adjust the design based on the insights you get from what you noticed.

Watch as UX Strategist and Consultant, William Hudson explains important points about usability testing:

Transcript

What is The Difference Between Use Cases and User Scenarios?

Use cases help capture a system’s functional needs, and they detail all interactions between users and the system. A key point is that it isn’t possible to write user-centered use cases without incorporating stories of use from user research—and in the main, you do this in the form of user scenarios. User scenarios describe how users achieve their goals through a series of actions, and to show the difference between them and use cases, it might be best to take an example of an online store where a “Buy Product” user scenario would look something like the following.

A customer selects items from the catalog and then places them in the shopping cart. Then, when they’re ready, the customer enters shipping and payment details to finalize the purchase and then confirms the order, whereupon the system verifies the payment and in an instant confirms the sale via a follow-up email.

Diagram charting differences between use cases and user scenarios.

© Interaction Design Foundation, CC BY-SA 4.0

But different scenarios can exist, for sure—for example, a payment authorization forms one scenario. For another scenario, you’d have a returning customer with stored payment and shipping details at the ready—expecting that “recognition” factor to mean the brand cares about them as an individual and they can trust it. Though the scenarios vary, they’ve got a common thread, and it’s the user’s goal to purchase a product, and although the user mightn’t always succeed, the goal remains constant—and this unified user goal binds various scenarios into a single use case.

The use case is broader than a single scenario and acts as a blueprint for system design, to be sure, while a scenario is a single path through the basic and alternative paths. Different successful routes can lead to the same goal, but you’ve got to describe the error flows as well, and both use cases and user scenarios are essential tools in UX design but serve different needs and stages of the design process.

What are Tips to Create Use Cases?

A checklist of tips for creating use cases. 

© Interaction Design Foundation, CC BY-SA 4.0

1. Start with User Goals

To begin with, you’ll always want to identify what the user aims to achieve—not least since a clear understanding of user objectives forms the backbone of your use case. Get this right and you’ll make sure that all scenarios you develop align with meeting these primary goals, and so you can get things spot-on to enhance user satisfaction and system functionality.

2. Involve Stakeholders Early

Consult key stakeholders such as users, product managers, and developers early on, and that helps you identify real-world needs and constraints and get them defined in sharp relief. The insights you get from doing that can be invaluable for refining your use case to be more effective and realistic and so mirror what’s going to happen in the real-world scenarios when you do release your product.

3. Use Simple Language

It’s a point that’s easy to forget when you’re caught up in the design side, but you’ll always want to use straightforward and easy-to-understand language—and there are two reasons for that. For one thing, the terms you use may well end up in the user interface—and nobody wants to get confused when they encounter your designed product.

But it’s not just for the sake of preserving that all-important seamless experience, because simple language also means that team members can grasp the concept even if they’ve only got limited technical knowledge—which a fair few of them might well lack, anyway—and so those “easy” words make for better collaboration.

4. Apply Service Design Principles

Keep broader service design principles in mind while you create the use cases, as that will make sure that each use case contributes in a positive way to the user’s overall experience. Think of the various facets of what users can encounter when they—for example—place an order and venture out to pick it up from the store, and think of their expectations and the need to address and embrace an omnichannel concept there so the use cases satisfy the various facets and touchpoints with which users encounter your brand.

Advance Your Career With This Free Template for “How to Map the Ecosystem of Your Service Design”
How to Map the Ecosystem of Your Service Design
Optional
Optional
We respect your privacy
Get 1 powerful email each week: Learn Design and AI From the Best.

5. Be Consistent

Consistency is a big deal—and then some—so be sure to keep uniform symbols, terminology, and flow going throughout your use cases. For instance, English is a generous language that has “buy” and “purchase,” but pick one and stick with it (preferably “buy”!). Get things consistent and it makes for easier understanding and interpretation, for sure, and—what’s more—it’s a vital thing to have in place in particular if your project includes multiple use cases that interact with or depend on each other.

6. Prioritize Modularity

Design your use cases as modular units—and the reason for that approach is it makes them easier to update, review, and manage rather than if they’re more “organic” or “sprawling.” Speaking of “sprawl,” you’ll be bound to have complex scenarios from time to time and rather than have a monolithic entity with intricate things going on within it, feeding into one another with a great deal of interdependence, it’s better to take a modular approach by breaking the “big-picture” things down into smaller, more manageable pieces.

7. Iterate and Revise

Requirements may change, and initial designs can have flaws, so be sure to make it a habit to revisit and revise your use cases. If you do frequent revisions, you can make sure that they stay relevant and align with any new project developments or insights that come up.

8. Document Clearly

It’s pretty much a given that each use case has got to have clear documentation to outline its reason for being, the main and alternative flows, and any preconditions or triggers that are in there—to serve as a reference point and aid in training, and it can be crucial for future modifications, so do make sure it’s there.

9. Review with Team

Before you finalize things and mark them as “done,” review the use case with your development team—and note that it should be a straightforward affair (with no disappointing surprises) if you’ve collaborated with developers while you’ve been working on the creation of the use case. Do that and it’ll help with spotting logical errors, missing steps, or inconsistencies, and—what’s more—team reviews can spark ideas for improvements, too, or reveal overlooked requirements that need addressing; not for nothing is the review stage there, rather like a safety net and then some.

10. Test Scenarios

Once the use case is all developed and fit for service, well done; pat yourself on the back for a moment, take a deep breath, and then—drumroll—run test scenarios to validate how effective and accurate it is. And you’ll want to do that not least because testing helps make good and sure that all paths lead to the desired outcomes and meet the user’s goals—all the while sticking to system constraints to make sure the system can deliver on the “promises.”

If you’re in doubt about this, think about involving users through paper prototyping or some such way to engage them and get their feedback in nice and soon—you may be surprised by the incisiveness and insightfulness both of the people you get results back from.

What about Some Use Case UX Examples? 

1. Upgraded Online Booking for Airlines

Let’s say an international airline wants to modernize its booking platform so it can offer layered fare options and extra services to customers, including conveniences like curbside check-in. The team’s redesign is for the booking page to offer features like tiered fares, lounge access, and payment with loyalty miles; so, for that, we could have actor Laura (the customer) as a frequent international traveler for business and leisure.

Laura browses flights and prices; she picks a flight date and time; then adds extras like a lounge and checked bags; and then she pays with a credit card but finds she can pay with the loyalty miles she’s racked up.

2. Optimizing News Portal

A news website aims to personalize the user experience—and developers test several use cases, such as actor Alex (the user), a recent college grad who wants to stay updated with news tailored to his interests. For this one, we’ve got it that Alex chooses categories of interest during signup; he sees trending articles in the area of interest; he bookmarks articles for later; then, Alex shares an article via social media; and then he cancels a subscription.

3. Simplified Online Learning Platform

An e-learning platform wants to make course selection and learning easier, and for them the use cases tested involve actor Mia (the user), a lifelong learner who’s after expanding her skills in her free time. Now, Mia logs in and browses courses; then she adds a course to the wishlist; she then enrolls in a course with one click; then starts a course and tracks progress she’s making; and then—to end—Mia completes a course and receives a certificate for it.

What are Common Pitfalls and Challenges?

1. Don’t Overlook User Goals

Believe it or not, but it’s possible to fail to center the use case on actual user goals—something that can lead to designs that are functionally rich but user-poor (although this shouldn’t happen with good user research!).

For example, a travel app may focus too much on showcasing beautiful destination photos, but for all the beautiful beach scenes, iconic landmarks, and charming locales, they go and neglect an easy booking process—a serious design misfire when the core user goal is to book a trip, not browse photos.

Watch as UX Strategist and Consultant, William Hudson explains important points about user research:

Transcript

2. Don’t Have Excessive Complexity

Making a use case too complex can obscure its purpose and make it difficult to implement—and while complexity is sometimes a part of life and does crop up by nature in many an industry, you can’t afford to get lost in it when you want a functional use case.

For instance, a healthcare portal that’s got numerous steps for booking an appointment could discourage users—when they’d be better off to simplify design and make for a better user experience, and (vital in this case, too) prove a solid sense of empathy for what may be “users” (or patients-in-waiting!) who need more than a little compassion and gentle touch when they’ve got some pain or malady and a potential avalanche of worries due to it, too.

Watch our video to understand important points about designing with user empathy in mind:

Transcript

3. Don’t Ignore Alternative Flows

The main flow is the main one and not “the one”—as in, the only one—so to focus just on the main user flow and ignore alternative or “edge” cases is a recipe for not-so-good experiences to come of it.

That seamless experience with maximum convenience and solid proof of brand empathy for the user is a vital but fragile thing, and an e-commerce checkout—for example—that doesn’t account for gift card or coupon usage can make for a frustrating user experience, as can failing to deal with error conditions. It may sound fickle, but users can “turn” on a brand that had been turning them on up till the point the magic soured because of one overlooked factor.

4. Don’t Have Inadequate Stakeholder Involvement

The stakeholders have a great deal to offer, and not involving key stakeholders early and throughout the process is asking for trouble. To take a banking app developed without input from actual bank employees, for example, it might miss key functionalities—like a feature for scheduling recurring payments—that get customers frustrated and put strain on the customer support helpline to boot (for those customers who decide to stay; many a new user might be turned off and look elsewhere just because of that omission).

5. Don’t Have Inconsistent Terminology

Don’t use inconsistent names, labels, or icons—they can confuse users no matter how much they might make sense to whoever’s doing the designing. You can see this in a streaming service where the “Watchlist” gets referred to as “My List” in another section—and it can confuse users who are looking to find saved content because they’ve seen “Watchlist” before and now it’s changed on them (as in, into another thing).

6. Don’t Ignore Technical Constraints

It’s nice to aim big and design to delight users, of course, but overlooking what is technically feasible can lead to impractical use cases. For user-centered solutions, the user experience and development teams have got to work together to keep any “castles” from starting to get built in the “sky.”

For this one, think of a feature in a food delivery app that allows real-time tracking of all ingredients of a dish—“Wow, how cool; customers will love that!” we might cry out in unison—but then reality might kick in and it may be impractical to implement that.  

7. Don’t Fail to Update

This one can happen because—well—when it’s done, it’s done, right? Wrong; not revisiting and updating use cases to get in step with changing user needs or business goals can spell disaster.

This one might manifest in an education platform that fails to update its course offerings based on current job market needs—and the organization may see decreased enrollments (don’t worry; design is going to be around for quite some time, though, and we’re well on the ball with keeping things up to date!).

8. Don’t Forget to Validate

You might think this wouldn’t need to feature, but it’s in here because it’s impossible to overstate just how vital usability testing is, and failing to validate use cases through user testing is a surefire way to crash not just the use case that never got tested—but even the final product if it manages to somehow get out, too.

Say there’s an online bookstore that introduces a recommendation service that involves numerous steps. Users get lost and frustrated, but testing the use cases early would have revealed this and saved a pretty penny and many a headache for the frustrated, flustered (and probably furious) brand when they have a rude awakening about what they should have done instead to offer a valuable, user-centric solution.

Watch as Psychologist and Researcher Ditte Hvas Mortensen explains important points about validation and more: 

Transcript

The Take Away

And that’s a wrap in a piece about a pretty vital topic—one where what’s come up has been the critical role of designing use cases in UX, then the benefits, process, and essential tools for crafting effective use cases, along with real-life examples and common challenges to put things into view with the most light (and focus).

To get use cases spot-on, it’s a vital thing to center user goals in the UX design process and keep on validating use cases through testing and stakeholder input—and keep them “alive” as invaluable living documentation of what’s going to work well.

Use cases are there to put you through the paces of what your users will do, so you can stay ahead of what your users—and customers—want, expect, and act upon, so get them done well and fine-tuned and you’ll equip yourself better to develop intuitive, user-focused interfaces across various industries. From there, you’ll be all set to work the “magic” and meet users at every turn in seamless experiences from the brands you help—industry names which the target users you design for can trust and keep coming back to as a loyal target audience who know they’re valued and heard by a brand they like (or love!).

References and Where to Learn More

Learn more about user stories by heading to IxDF’s comprehensive piece.

39% of Today's Skills Will Change by 2030

The World Economic Forum expects 39% of today's skills to be transformed or become outdated by 2030.

The good news is that jobs in UX / UI design and AI are among the fastest-growing professions globally.

Build Skills That Keep You Relevant

Privacy Settings

By using this site, you accept our Cookie Policy and Terms of Use.
Customize
Accept all

Be the One Who Inspires

People remember who shares great ideas.

Share on:

Academic Credibility — On Autopilot

Don't waste time googling citation formats. Just copy, paste and look legit in seconds.