pattern

The register for screens read from a couch: focus-driven navigation with a remote, oversized type and cards, horizontal rails, and safe margins for TV overscan.

A collectible marker awarded for a milestone and displayed on a profile, often shown greyed out before it is earned so the set is visible.

A reverse chronological list of things that happened, each entry naming an actor, a verb, and an object, grouped when many are alike.

Replacing a set of address fields with one lookup that suggests full addresses after a few characters and fills the rest on selection.

A solution reached for again and again for a familiar problem, which fails at the thing it was reached for and often leaves the situation worse than doing nothing.

A row of removable tokens above the results showing every filter currently in force, with a control to clear them all at once.

The browser filling a form from values it has already saved, on its own or from a dropdown of the reader's own profile, so a field arrives answered.

Playback that starts with no gesture from the reader, which browsers now allow only while the sound is off, so autoplay in practice means a silent moving picture.

Persisting the reader's work continuously without a save action, usually with a quiet status line reporting when the last save happened.

A control that appears after the reader has scrolled some distance and returns them to the top of the page in one action.

Selecting several rows and applying one command to all of them, usually through a bar that appears once a selection exists and reports its count.

A mail button built to survive a renderer that drops CSS: the fill carried by a cell or box behind the link rather than by a background the client can refuse.

Tufte's word for ink that decorates a chart without carrying data: 3D bevels, gradient fills, mascots, gridline thickets.

A review screen listing everything the reader entered, with a change link beside each answer, shown before the submission is final.

Structuring plans or products so their features and prices cannot be lined up, forcing a decision that no side-by-side reading would support.

The screen that closes a transaction, stating plainly that it succeeded, giving a reference the reader can quote, and saying what happens next.

Wording the decline option so that choosing it is an admission of something embarrassing, making refusal feel like a confession rather than a choice.

An interface operated in turns of language rather than by controls, where the transcript is the state and the only visible affordance is a box to type in.

A notice asking permission to store non-essential cookies before the reader has done anything, offering accept, reject, and a route to per-purpose choices.

A running clock attached to an offer or a held resource, showing how long remains and what will happen when it reaches zero.

Paging that moves by a pointer into the result set rather than a page number, so newly inserted rows never shift what the next page contains.

Designing a mail for clients that will invert its palette without asking, where a near-black behaves better than black and a logo needs a ground it survives on.

An interface arranged to make the reader do something they did not intend and would not have chosen, by exploiting how attention and defaults work.

Tufte's measure of chart economy: the share of ink that would be missed if erased, with everything else a candidate for deletion.

Offering a corrected spelling for a query that returned little or nothing, either as a suggestion to accept or as a substitution the reader can undo.

An interface that exists inside the fiction it serves, so the character can see and use it too, rather than being drawn on top of the world for the player alone.

Writing series names next to the data instead of in a legend, trading a lookup for a glance.

Acting on an object by handling the object itself, dragging, resizing, or typing into it, rather than describing the change in a separate control.

An advertisement styled to look like a control or an item of content, so the click it collects was aimed at something else entirely.

Asking a new subscriber to confirm from the address they typed, so a list holds only addresses whose owner agreed and a typo never becomes a stranger's mail.

The semi-transparent copy of the dragged item that follows the pointer, sometimes collapsed into a stack when several items move at once.

Changing the order of a list by dragging an item to a new position, with the remaining items shifting to show where it will land.

Going deeper into a hierarchy one level at a time inside the same panel, each level replacing the last and offering a way back up.

Advertising a low headline price and adding mandatory fees one screen at a time, so the true total only appears once the buyer is committed.

The line or highlighted gap drawn during a drag to show exactly where the item will land if it is released now.

Two value axes sharing one plot so two series can be compared, and a free knob for manufacturing whatever correlation you like.

The screen a container shows when it holds nothing, naming the absence and offering the action that ends it.

Starting a progress meter part filled, so the reader feels they are continuing something already begun rather than starting from nothing.

The whole screen a site serves instead of the page that was asked for: what happened, in the reader's words, and the shortest way back to something that works.

A block at the top of a failed form listing every problem as links that move focus to the field that caused it.

A row of one-tap payment buttons placed above the normal form, which fetch address and payment details from a wallet the buyer already has.

Narrowing results by ticking values from several independent attribute groups, with counts showing how many results each value would leave.

A control that looks shipped and leads nowhere, put in the interface on purpose to count how many people want the feature behind it.

Claiming limited supply that is not real, with stock counts or demand messages generated to pressure a decision rather than report a fact.

Manufacturing evidence that other people approve, through invented reviews, testimonials, or live activity messages nobody actually generated.

Presenting a deadline that does not exist, usually a timer that resets on reload, so the reader hurries a decision they had time to make.

A page that looks finished at a point where content actually continues, so the reader stops scrolling and never sees the rest.

Showing a locked feature in place, with its real position in the interface, so the reader sees what upgrading would unlock rather than a hidden absence.

A one-time announcement pointing at something newly added, shown in place next to the feature and dismissed for good once acknowledged.

Everything shown only on the very first open, from a welcome sequence to seeded sample content, and never shown to that person again.

Turning a free trial into a paid subscription automatically, with the card taken up front and no reminder before the first real charge.

Accepting whatever shape the reader types and normalising it afterwards, instead of rejecting input that differs only in spacing or punctuation.

Asking for access to a contact list under one pretext and using it to send invitations that appear to come from the reader.

An interface whose parts are chosen or composed by a model at runtime, so a request is answered with a built form, chart, or panel instead of a paragraph of text.

Effort rising as a visible goal gets closer, which is why interfaces show how little is left rather than how much has been done.

Replacing a sign-up form at the front door with a first useful action, so the reader experiences value before being asked for anything.

Letting a buyer complete a purchase without creating an account, with the offer to save details moved to after the order is placed.

Documentation opened beside the task rather than over it, keeping the form usable while the explanation is read and staying open across steps.

A form field hidden from people but visible to automated form fillers, used to reject submissions that fill it in without challenging anyone.

A navigation shape where every task is reached from one home screen and returns to it, with no way to move sideways between tasks.

The pass where script attaches behaviour to server-rendered HTML, turning a page that is already painted and readable into one that answers input.

A list that appends the next page of results automatically as the reader approaches the bottom, so the content never ends and no page controls appear.

Completing the reader's text inside the field itself, with the guessed remainder selected so the next keystroke replaces it.

Checking a field as the reader fills or leaves it and showing the verdict beside that field, rather than saving every complaint for the submit button.

A link or button that shows more when a reader shows interest in it, by hovering, focusing or long pressing, with no click and no script deciding what interest means.

Explaining a system by dressing it as something the user already knows: the desktop, the trash can, the folder, the shopping cart.

A full screen placed between two steps of a flow, carrying a message, an advert, or a warning that the reader must pass through to continue.

A button that names the element it acts on and what to do to it, in markup, so opening a dialog or toggling a popover needs no script at all.

Showing the work a system is doing, or stretching it, so the answer feels earned: the search that lists the sites it is checking instead of answering at once.

Deferring the fetch of an image, list section, or module until it is about to be needed, usually when it approaches the viewport.

Letting someone use a product and accumulate state anonymously, and asking for an account only when that state needs to survive the session.

A ranked list of participants by some score, with the reader's own position pinned into view even when it falls outside the visible range.

Rendering only the rows currently in view and a small buffer around them, while spacers preserve the scrollbar of the full list.

A button at the end of a list that fetches and appends the next batch only when pressed, keeping the reader in control of how much arrives.

Signing in by clicking a single-use link emailed on request, with no password, and a screen that waits and offers to resend while the mail arrives.

Typing a trigger character inside a text field to open a filtered list of people or objects, inserting the chosen one as a linked token.

A paywall that grants a fixed number of free items per period and counts down publicly, so the barrier arrives only after the reader is invested.

An interface's smallest strings: the verb on the button, the line under the field, the sentence when it fails. Short enough to be read every time.

A one or two question survey placed inside the product at the moment being asked about, answered in place rather than on a separate page.

A compact view of the basket opened from the cart icon, confirming what was just added and offering checkout without leaving the current page.

Using contrast, size, and position to pull attention to the option the business prefers while the other option is present but visually demoted.

A screen shown as it will look rather than as it will work: colour, type and real copy all settled, and nothing in it clickable.

One control that changes what it says and does according to state, showing play when paused and pause when playing rather than offering both.

An interface that accepts and answers in more than one channel at once, letting a person speak, type, touch, or point and pick whichever suits the moment.

Interrupting a task again and again with the same request, so that agreeing becomes the cheapest way to be left alone.

An interface whose input is ordinary language, typed or spoken: the user states an intent in their own words and the system parses it, instead of picking from controls.

What a search or filtered list shows when nothing matched, naming the query, explaining why, and offering a way to loosen the constraints.

Collecting many similar alerts into one summary rather than delivering each, so the count rises but the number of interruptions does not.

Putting deliberate hurdles in front of an action the business does not want taken, so the effort itself does the discouraging.

A persistent notice that the product has lost its connection, saying what still works, what is queued, and when the last sync happened.

A persistent list of setup tasks with completion state and a progress meter, kept available so the reader can return to unfinished steps.

A short sequence of pointers layered over a live interface, each naming one control, advanced by the reader and skippable at any point.

Asking a single question on each screen of a form so the reader never chooses which field to answer first and errors point somewhere unambiguous.

Signing in by typing a short code sent to a second channel, keeping the reader inside the app rather than sending them out to a mail client.

Showing the work as it happens, the kitchen made visible, so a wait is understood rather than merely endured and the result is trusted more for having been watched.

Showing the result of an action immediately and reconciling with the server afterward, instead of making the user wait for confirmation.

The persistent panel beside a checkout listing items, quantities, and every cost line, kept visible so nothing about the total arrives as a surprise.

One command word or icon wired to different outcomes depending on where it sits, so having used it once teaches the reader nothing about the next one.

Signing in with a device-held credential unlocked by the reader's own biometric or screen lock, so the interface asks for a face or fingerprint, not a secret.

A gauge that scores a password while it is typed and names what would improve it, replacing a list of rules with continuous feedback.

A barrier that stops access to content or a feature until the reader pays, placed either before anything is shown or partway into the content.

Explaining why access is needed in the product's own dialog first, and only firing the operating system prompt once the reader has said yes to that.

Arriving at a choice with the answer that benefits the business already ticked, so consent is collected from everyone who does not notice.

The line an inbox prints under a subject, written as hidden text at the top of the mail so the client shows those words instead of scraping whatever body copy comes first.

The rules that decide what a page becomes on paper: navigation dropped, link targets spelled out, backgrounds abandoned, and the content given page margins.

A horizontal menu that keeps as many items visible as fit and moves the rest into a More control, recalculating whenever the available width changes.

Steering people into sharing more about themselves than they meant to, by making the permissive choice the easy one and the private choice several clicks deep.

Showing the few options most people need and keeping the rest one deliberate step away, so complexity arrives only when it is asked for.

Showing a cheap stand-in for an image, a blur, a dominant colour, or a low resolution copy, and swapping in the full file once it arrives.

Collecting profile details a few at a time across separate visits, instead of demanding the whole record in one long form at registration.

Simplifying a control as the same person uses it more, dropping the label once the icon has been learned and restoring it after a long absence.

A design wired up just enough to be tried: screens linked so that a tap goes somewhere, with nothing real behind the links.

Dragging a list downward past its top edge to trigger a reload, with an indicator that appears in the space the drag opens up.

A header that slides out of the way while the reader scrolls down and returns immediately on the first upward scroll, without waiting for the top of the page.

Opening a summary of an item over the list it came from, so the reader can inspect it and return without losing scroll position or filters.

A burst of repeated clicks on one spot, the shape frustration takes when a control answers nothing, and the analytics signal that goes looking for it.

An in-product request to rate or review, usually timed to a moment of success and often filtered so only positive responses reach the public store.

A per-message marker reporting how far a message got, sent, delivered, or read, drawn as ticks, labels, or the recipient's avatar.

A bar tied to scroll position that shows how much of an article remains, usually pinned to the top edge and filling as the reader descends.

An event stored once as a rule instead of as copies, so every second Tuesday can be edited, skipped for one week, or ended, without touching the rest.

Making entry into a commitment take one click and exit take a phone call, a chat queue, or a buried page, so the asymmetry keeps people subscribed.

Assembling a condition from dropdowns and values, joined by and or or, so a non-programmer can express a query without writing one.

Moving an item out of the active list into a parked list that stays associated with the reader, without deleting it or committing to it.

A label reporting how little of something is left, in stock, in seats, or in time, placed beside the action it is meant to accelerate.

A gradient mask at the edge of a scroll container that fades clipped content out, hinting that more lies past the edge without drawing a control.

Overriding the browser's scrolling so a wheel turn advances a scripted sequence instead of moving the page by the distance the reader asked for.

Navigation that watches the scroll position and highlights the entry for the section currently in view.

A narrative layout where a pinned graphic stays fixed while text scrolls past it, each step changing what the graphic shows.

Offering to extend a selection from the visible page to every matching row, after a header checkbox has selected only what is on screen.

The name a mail appears to come from, chosen rather than inherited, because a reader scanning an inbox decides on it before reading a word of the subject.

A loading state made of grey shapes standing where the content will be, showing the layout before the data arrives.

Typing a forward slash in a composer to open a menu of actions, where choosing one runs it rather than inserting the words into the message.

A strip pinned to the top of a mobile web page urging the reader to open or install the native app instead, with an install or open action.

Prefilling a choice with the answer most people in this situation want, so the common case needs no work and every other case is still reachable.

Adding an item the buyer never chose, an insurance, a donation, a warranty, into the cart through a preselected control found earlier in the flow.

Signing in by delegating identity to an existing account elsewhere, presented as a row of provider buttons above or instead of a password form.

Showing what other people did or said next to a decision, as counts, reviews, logos, or live activity, so the reader can borrow their judgement.

Removing an item from view but keeping it recoverable in a trash or archive for a period, so deletion is reversible without a confirmation step.

Fetching, or fully rendering, a page before the reader asks for it, on a guess about where they go next, so the navigation is already done when the click lands.

Telling the reader where they are in a multi step task and how many steps are still to come, so the end of the task is visible from the start.

A condensed product bar that pins itself to an edge once the real buy button has scrolled away, keeping price and purchase always reachable.

A sequence of full-screen cards that advance on a timer, paused by holding, skipped by tapping the edges, and gone after a fixed lifetime.

A count of consecutive periods in which the reader did the thing, displayed prominently and lost if a period is missed.

Splitting one value across several small fields with fixed shapes, which teaches the expected format but costs the reader extra focus moves.

Alt text given size, colour and weight so a mail whose images are blocked still reads as something designed instead of as a column of grey stubs.

The one line a mail is opened or ignored on, written to survive a list that truncates it and shows it wedged between the sender and the preview text.

A stack of cards judged one at a time, each thrown left or right to record a binary decision and reveal the next card underneath.

Flinging an item off the edge of the screen to remove it, with the item tracking the finger and snapping back if the throw is too short.

A list of a document's sections, linked in reading order, shown beside or above the text.

Whose clock a time is shown on, the reader's or the event's, and saying which, because a time with no zone beside it is a meeting somebody is going to miss.

Mail sent because one person did one thing, a receipt or a reset, which is why it may carry no marketing and why its design is a record rather than a pitch.

Phrasing a choice so its plain reading is the opposite of its effect, typically through double negatives or a label that describes the wrong outcome.

Starting a value axis above zero so differences look bigger than they are; honest for lines and dots, a lie for bars.

Guarding a destructive action by making the reader type the name of the thing being destroyed before the confirm button becomes usable.

Offering suggestions that update on every keystroke, drawn from a live query, so the reader picks a result rather than finishing the phrase.

Letting an action run immediately and offering to reverse it afterwards, instead of stopping to ask whether the reader really meant it.

Warning the reader that edits will be lost before a navigation or close is allowed to proceed, and offering to save or discard first.

The way out of a mailing list, which the law and the mail clients now both insist is one click, and whose difficulty is the honest measure of a sender.

A screen drawn as structure only: blocks where the content goes, a crossed box for an image, ruled lines for text, with no colour or type decided yet.

The first-run screen a feature shows before any data exists, written to teach the feature rather than to report emptiness.

A paradigm where the screen stops being the interface and the interaction happens through voice, gesture, presence, or sensors, so the system responds without anything to look at.