User experience design has a terminology problem. “UX” is used to mean everything from pixel pushing to psychological research to business strategy, which means designers often spend years in the field without building a clear intellectual foundation for what they’re actually doing.
This is a problem because UX design — stripped of its jargon and tool-dependence — is a discipline with a coherent set of principles. These principles apply regardless of whether you are designing a mobile app, a web application, a kiosk interface, or a physical product. They predate Figma, Sketch, and every tool that came before them. They will outlast the tools that come after.
Here are seven of them.
1. Affordance: Objects Should Signal How They Are Used
An affordance is a property of an object that signals how it should be used. A door handle affords pulling. A flat plate affords pushing. A button affords pressing.
In digital interfaces, affordance is primarily communicated through visual design. A blue underlined text string affords clicking because years of web convention have established that as the hyperlink signal. A rectangular element with a slight shadow and a label affords pressing because it visually resembles a physical button.
Affordance failures are the cause of a specific class of UX error: the user doesn’t know what is interactive. They hover over everything because nothing looks clickable, or they try to interact with decorative elements because they look like controls.
The practical principle: every interactive element should be visually distinguishable from non-interactive content — not through size or colour alone, but through the conventions of the medium your users inhabit.
The corollary: don’t establish false affordances. An element that looks interactive but isn’t creates frustration disproportionate to the design decision that caused it.
2. Feedback: Every Action Deserves a Response
When a user takes an action, the system must confirm that the action was received and indicate what happened as a result. Without feedback, users repeat actions, abort processes, or — most expensively — submit duplicate data.
Feedback operates across five time scales:
Immediate (0–100ms): Button depression state, toggle state change, hover highlight. These confirm the input was registered.
Short-term (100ms–1s): Loading spinner, progress indicator, optimistic UI update. These confirm the system is processing.
Medium-term (1–5s): Completion confirmation, error message, success state. These confirm the outcome.
Long-term (5s+): Email confirmation, background job progress indicator, notification. These handle asynchronous outcomes.
Persistent: Saved state, changed setting, modified record — the interface reflects the result of the action without requiring the user to check.
Feedback failures at any of these time scales erode trust. An interface that doesn’t confirm actions feels broken, even if it technically functions correctly.
3. Mental Models: Design For How Users Think, Not How Systems Work
A mental model is the user’s internal representation of how a system works. It may be accurate or inaccurate — it is always incomplete. UX design is, in large part, the work of aligning the system’s behaviour with the user’s mental model.
The canonical example is the filing cabinet metaphor in early desktop operating systems. Users didn’t understand hierarchical file systems, so the interface was designed around a metaphor they already had: physical folders in physical drawers. The mental model was imposed on the system, not derived from it.
The failure mode is designing for the system’s logic instead of the user’s mental model. A settings architecture that maps to the product team’s internal divisions makes sense to the engineers who built it. It makes no sense to users who think about tasks, not features.
The practical principle: the navigation, terminology, and workflow of an interface should map to how users categorise and sequence tasks — determined through research, not assumed from the product roadmap.
4. Consistency: Don’t Make Users Relearn
Consistency means that the same action produces the same result in the same context across the product. It means that the same visual treatment means the same thing everywhere. It means that if deleting is destructive and irreversible in one part of the product, it is destructive and irreversible everywhere.
There are two kinds of consistency:
Internal consistency: Within the product, like elements behave alike. The primary button is always the same style. Destructive actions always require confirmation. Form validation always appears below the field, not above it.
External consistency: The product follows conventions established by the platforms and patterns users already know. Back navigation goes backward. The logo links to the homepage. The close button is in the top right.
The argument against external consistency — “but our product is different” — almost always loses. Users carry their mental models with them. Fighting established conventions extracts cognitive cost from users every time they encounter the deviation.
Consistency is a form of respect. It says: what you learned here will work everywhere. You don’t need to discover things twice.
5. Error Prevention and Recovery
The best error handling is error prevention: designing the interface so the mistake cannot easily be made in the first place.
Form validation that prevents submission of an invalid email before the user submits saves the round trip and the frustration. A confirmation dialog before a destructive action prevents accidental deletion. Disabling an action that is currently impossible prevents the confusing dead-end state.
But error prevention is not always possible, and over-applied it becomes patronising. When errors do occur, the recovery experience defines whether the user’s trust survives.
Good error messages have three properties:
They identify the problem specifically. “Something went wrong” is not an error message. “Your session has expired — please sign in again” is.
They indicate the cause. “Password must contain at least one uppercase letter” tells the user what to fix. “Invalid password” does not.
They offer a recovery path. The message should tell or show the user what to do next — not leave them to figure it out.
The underlying principle is non-destructive interaction: users should be able to undo, revise, cancel, and recover. The system should protect the user’s work even when the user makes a mistake.
6. Progressive Disclosure: Show Only What Is Needed
Every piece of information and every control in an interface has a cost: cognitive load. The user must process it, decide whether it’s relevant, and either act on it or dismiss it. The more unnecessary information is displayed, the higher the cost.
Progressive disclosure is the design strategy of showing only the information and controls relevant to the user’s current context or task, revealing more as needed.
A simple form with an “Advanced options” disclosure is progressive disclosure. A mobile app that shows a simplified view and an “Expert mode” setting is progressive disclosure. A checkout flow that only shows the shipping address form after the cart is confirmed is progressive disclosure.
The principle behind the strategy: complexity should be earned by context, not imposed by the system’s capabilities.
The common violation is feature exposure — displaying every capability the system supports regardless of whether the user is currently engaged with it. This is the interface equivalent of a waiter reciting every item on the menu when you ask for the soup.
7. User Control and Freedom
Users need to feel in control of the interface — that their actions are reversible, that they can exit unwanted states, and that the product is not making decisions for them without consent.
This principle manifests in specific patterns:
Undo. The most powerful UX feature in existence. An interface that supports undo allows users to explore without fear of permanent mistakes. Google’s “Message sent — Undo” is a masterclass in this: the destructive action is deferred just long enough for the user to cancel it.
Explicit confirmation for irreversible actions. Delete, cancel subscription, transfer ownership — actions that cannot be undone should require deliberate confirmation, not just a single click.
Exit paths. Every modal, flow, and state should have a clear exit. Users who feel trapped abandon products.
No dark patterns. Designs that make it easy to subscribe and hard to unsubscribe, that hide the cancel button, that use pre-checked consent boxes — these are violations of user control that produce short-term conversion gains and long-term trust destruction.
The relationship between user and product is a trust contract. Interfaces that honour user control maintain the contract. Those that exploit the user’s attention or confusion break it.
These seven principles — affordance, feedback, mental models, consistency, error handling, progressive disclosure, and user control — are not a checklist. They are a lens. Apply them as questions when reviewing any interface: Does this element signal its affordance clearly? Does this action have appropriate feedback? Does this flow match the user’s mental model? The answers diagnose more problems in less time than any usability heuristic framework.
This post covers foundational concepts from User Experience Design Fundamentals (HD·P1·02), part of the UI/UX Design silo in the Hacking Design professional curriculum. Explore the full silo at hackingdesign.in/professional/ui-ux/.