A user opens the analytics dashboard on a Monday morning and the widget she needs is already at the top. Good. Then she notices the second widget, which is a churn report for a segment that she’s never looked at in this product. She did read about that segment last night, but in an email message, in a different app, on a different device. Although the dashboard is right, this awareness is also unsettling, and these two facts don’t cancel each other out.
This is the whole problem with the personalization of a screen. The useful version and the creepy version look almost identical. Both adapt the user interface to the person using it. The difference is where the signal came from and whether the user knew she was sending it. Do systems really need a surveillance-grade profile to show users the right shortcut, setting, or next step? Usually not, and products that assume otherwise pay for it in lost user trust.
Champion Advertisement
Continue Reading…
This article is about personalization of a user interface through adaptations that are scoped to what the user is doing, visible when they happen, editable when they’re wrong, and reversible when they’re no longer wanted. None of this means giving up on personalization. It means being more careful about which signals earn the right to change the user interface.
Creepy Starts When Context Leaks
Users tend to accept adaptations that follow logically from something they just did. Maybe the user chose the compact view, so the next screen is also compact. Perhaps the user filtered the data by one project, so the export form defaults to that project. The cause is visible and recent, so the adaptation reads as attention rather than surveillance.
User discomfort begins when the cause isn’t visible because the data came from somewhere else. Nielsen Norman Group’s research on overpersonalization found that personalized content felt especially creepy when it seemed to break the boundaries of what users thought a site or device should know. While one participant understood why her phone showed content relating to her mobile browsing, seeing the same activity reflected in ads on her computer was, in her word, creepy. Another described a social network as creepy because it seemed to know what she’d searched for and bought on another site. Nothing in those experiences was inaccurate. The signal had simply traveled farther than the user had.
There’s a word for this outside of product design, and it isn’t personalization. If a colleague remembered what you’d said in one room and brought it up in another, uninvited, you wouldn’t call that attentiveness. Digital stalking is a heavy phrase for an ordinary recommendation engine, so use it sparingly. But the mechanism the term names is the one to which users react negatively: a memory that crosses a boundary the user didn’t know was porous.
The Federal Trade Commission’s 2022 dark-patterns report describes the commercial version: user interfaces that present privacy choices while steering people toward the option that gives away the most information. This is background information, not an accusation. Most teams shipping a personalized dashboard aren’t designing dark patterns. But users have learned to expect them, so a user interface that adapts for reasons it won’t reveal inherits suspicion it didn’t create.
The design rule for personalization, then, is about distance. The farther a signal has traveled from the user’s current task, the more visible and controllable the adaptation on which it is built needs to be.
Champion Advertisement
Continue Reading…
Use Declared Preferences Rather Than Inferring Personality
When personalizing a user interface, start with what the user tells you. Nielsen Norman Group draws this line simply: customization is done by the user; personalization, by the system. A declared user preference is less magical than an inference. It’s also the only signal that won’t surprise users later, because they deliberately set it.
However, there is a real objection to customization. Most users don’t want to configure anything. The same NN/g piece says that most people aren’t interested in doing the work of tweaking a user interface to make a system fit their preferences. I made the same point from the other side in an earlier UXmatters article on users who don’t want to explore. Most people have a job to do, and a Preferences panel is one more obstacle in the way of doing it. So declaring preferences should not mean a Settings screen that the user must visit before the product works properly.
But this can mean asking a question at the moment the answer has value. For example, when a user sets up a third project using the same template, ask whether that template should be the default. When a user has used a dense layout for two weeks running, offer to keep it. The order in which events happen matters: ask, observe, confirm, then remember. Observation alone is a guess. Confirmation turns it into a preference the user owns.
This rules out treating one action as reflective of a personality. Someone who has opened the Pricing page twice is not a price-sensitive customer, but merely a person who has opened the Pricing page twice. A user interface should not start behaving as if it knows more than it can infer—such as a trait from an event, which is a kind of memory that leaks across contexts. Events should stay where they happened.
Table 1 presents these signals in order of how far each signal could safely travel for users to trust changes to a user interface. To preserve privacy in personalization, this signal ladder shows what each rung can change and the control that should sit beside it.
Table 1—A privacy-preserving personalization signal ladder
Rung
Example
What It Might Change
Control Beside It
1. Declared Preference
Using compact view; chosen during setup.
Everything the preferences dictate, wherever they apply.
Edit in place; no explanation required except you set this.
2. Same-Session Context
Current project; a filter the user just applied.
Defaults, ordering, and suggestions only for the current visit.
User selects “Remember this” for the service to keep it.
3. Confirmed Pattern
Dense layout; used during two prior weeks.
A default once the user has accepted it.
Ask the user before remembering; Undo and Stop Suggesting This.
4. Durable Profile
Saved preferences; preserved across visits.
Only what the user can see, edit, and delete.
Visible profile. Lifetime: until user edits or deletes. Don’t use this signal.
Rung 3 is where system observations become memory. For later rungs, the system keeps what it noticed, but only after the user confirms that the system should do so.
Allow Context to Expire
Session-scoped personalization in which context expires does most of the work here, and most product teams are already shipping this without naming it. A dashboard remembers which project the user was viewing. The onboarding path follows the role the user chose. Filters, form defaults, content density, and next-step suggestions all track the user’s current visit. The user interface feels attentive because it is—for exactly as long as a task lasts.
The question to ask regarding each adaptation is whether it should survive tomorrow. The filter settings for a report shouldn’t. But a collapsed sidebar probably should stay collapsed. A suggested next step that is based on the user’s current work should expire when the work is complete. If it reappeared next month, the user might feel that the system had been keeping notes on her.
This instinct has a name in privacy engineering. NIST’s Privacy Framework sets out three objectives for systems that handle personal data: predictability, manageability, and disassociability. Manageability is the capability for granular administration of data, including alteration, deletion, and selective disclosure. Disassociability is “enabling the processing of data or events without association to individuals or devices beyond the operational requirements of the system.” These are engineering objectives rather than a design checklist, but they translate directly. An adaptation that expires with the session is disassociable by construction. An adaptation the user can reset is manageable by construction.
In user-interface terms, this gives users three small controls that most personalized products lack, as follows:
A way to make a temporary adaptation permanent—“Remember this.”
A way to end a temporary adaptation“—Reset to default.”
A stated lifetime for any adaptation the system keeps without asking—Teams often skip this one. If a product is going to remember a choice, users should be able to find out for how long, in the same place they would change it.
Show Users What the System Thinks It Knows
Opaque adaptation damages user trust even when it’s right. A user interface that quietly rearranges itself is asking the user to work out what it did and why. Most users won’t be willing to do that work. They’ll accept the rearrangement without understanding it, which introduces fragility, or distrust it, which is expensive. The fix is not a privacy policy. It’s an explanatory sentence at the point of change such as the following:
“Shown because you chose compact view.”
“Suggested for this project.”
“Based on your last three exports.”
Short explanations like these do two jobs:
They name the signal, so a leak is visible at the moment it happens.
They become a handle because each one can have an Undo button, a “Don’t use this” checkbox, or an Edit Preference button beside it.
The W3C’s Privacy Principles require this kind of plain-language explanation regarding what data the system is using and how. They also add a principle worth borrowing whole: it should be as easy to verify or change a choice as it was to make it.
User trust lives in these moments rather than in the brand. I have argued that user trust is a UX design problem that is built through interactions rather than impressions. Personalization is where that argument becomes concrete. A product that explains its adaptations and makes them easy to correct is behaving in a trustworthy manner. A product that promises respect for privacy on its marketing site, and then rearranges a dashboard for reasons that it won’t state is not—whatever the copy says.
Table 2 shows how the correction path changes with the signal. Treat it as a working checklist rather than a standard.
Table 2—Explanation and control for each signal type’s reversible adaptation
Signal
User-Facing Explanation
Correction or Reset Control
Declared Preference
“You set this.”
Edit in place; no reset necessary.
Same-Session Context
“For this project” or “Because you filtered by….”
Clears with the session; or a “Remember this” checkbox keeps it.
Confirmed Pattern
“You’ve done this three times, so we made it the default.”
An Undo button; or a “Stop suggesting this” checkbox.
Durable Profile
“Based on your saved preferences,” with a link to them.
An Edit, Pause, or Delete button. State how long to keep the data.
Two controls belong on every row, as follows:
“Don’t use this signal”—Lets a user keep the product while switching off one input, which is usually what they want.
A temporary mode—call it Guest or Focus—Lets the user do something out of character without teaching the system a new trait.
Personalize for the Task, Not the Person
“This user is a price-sensitive shopper” is a claim about a person. “This checkout session requires user reassurance and fewer distractions” is a claim about a task. While both might produce the same screen, only the second can be explained in a sentence, corrected in a tap, and forgotten when the session ends.
Task personalization is easier to justify because the evidence is right there. The user is in a checkout flow, the cart holds one expensive item, and the user has gone back to the product page twice. Reassurance follows from that verification. If the system is wrong, the cost is one unnecessary trust badge.
Personal personalization requires a user profile that dictates where a label came from, what else an adaptation changes, and how the user can find out he has received it. NN/g’s advice on successful personalization is blunt about the underlying limitations: personalization is a best guess—and past behavior doesn’t always accurately predict future action.
This pattern holds across the contexts in which UXmatters readers work. An enterprise dashboard can adapt to the role users have chosen and their project without deciding what kind of manager they are. A learning platform can reorder a path around a module a learner is struggling with today, without labeling the user a slow learner. A wellness app can respond to this week’s entries without building a mood profile it would later use to sell something. Software-as-a-Service (SaaS) onboarding can branch on a goal the user stated on the first screen, which is the one signal they know they gave.
A boundary matters most where personalization shades into steering the user. When I wrote that good UX design shouldn’t be manipulative, the line I drew was user consent. Persuasive design helps people to choose through clarity; manipulative design hides the full picture. A personal profile that nudges users toward outcomes they didn’t choose is on the wrong side of that line, however accurate it is. A task adaptation that removes friction from the thing the user came to do is on the right side, and it’s usually cheaper to build.
The review question for a team: What is the smallest signal that can improve this task? If it’s something the user just did or said, build on it. If it requires knowing who the user is, ask whether the improvement is worth the explanation you’ll owe the user. Figure 1 gives UX teams a way to assess how far a proposed signal can travel from the user’s current task against how much the user can see and control.
Figure 1—A creepiness-threshold matrix
Make the System Easier to Correct Than to Escape
Personalization earns intimacy by showing restraint. This might sounds like a paradox, but it isn’t. The products that people describe as understanding them are rarely the ones that know the most. They’re the ones whose adaptations make sense on sight and that the user can change without submitting a support ticket.
The test for any adaptive feature has three parts, as follows:
The signal is visible. The user can see what has changed and which user input caused the change.
The change is reversible. Undoing the change costs just one action, not a hunt through settings.
The memory is scoped. The system keeps whatever the task requires for as long as the task lasts, and informs the user when it must keep more.
Run that test on the Monday-morning dashboard I discussed earlier. The first widget passes on all three counts. The second widget fails on the first count because the signal came from an email message in another app. It fails the third count, too. The analytics product didn’t need to remember anything about a churn report the user read at 11pm, the next morning. The fix is not to strip personalization out of the dashboard. The second widget requires a sentence explaining itself—a way to say “not this”—and a source that should be there in the first place.
The measure of safe personalization is whether a user can understand it and, if necessary, correct it, then leave it. If users have to leave an entire product to stop it from knowing them, the personalization has already failed, and no amount of accuracy will buy back user trust.
Magnus works as an independent copywriter and ecommerce search-engine optimization (SEO) specialist. Before embarking on his copywriting career, he was a content writer for digital-marketing agencies such as Synlighet AS and Omega Media, where he mastered on-page and technical SEO. Magnus holds a degree in Marketing and Brand Management. Read More