Recently searched

Problem Context

• The product has search boxes that users revisit over time, across sessions, or within a long task.
• Query wording matters enough that recalling an earlier submitted query saves effort.
• Search terms can reveal sensitive intent, work, health, finances, legal concerns, customers, or private projects.

Selection Rules

• Choose recently searched when entries should be query strings the current user actually submitted, not possible suggestions or opened objects.
• Capture only meaningful submitted searches such as Enter, Search button, or selected recent-query rerun, not each keystroke or focus event.
• Order by most recent search time, deduplicate by normalized query plus scope, and move repeated searches to the top instead of duplicating them.
• Show enough context to rerun safely, including query text, scope, source, timestamp, and optionally current result count.
• Provide remove-one and clear-all controls that affect recent query history only.
• Expose search-history state and account, browser, device, or workspace scope when history can sync or persist across sessions.
• Hide the list or show an empty history state when no trustworthy recent searches exist rather than substituting popular searches under the same label.
• Use search suggestions when the user needs help forming a future query; use saved search when the user intentionally stores named criteria; use recently viewed when the history is opened items.
• Expire, cap, or avoid storing sensitive queries when the search surface is shared, signed out, regulated, or privacy-sensitive.
• Keep recent searches separate from autocomplete for constrained values such as people, addresses, codes, products, or entities.

Required States

• Empty or hidden state before any qualifying query has been submitted.
• Populated state with newest-first query history, scope, and timestamp.
• Rerun state where selecting a recent query restores query text and search scope.
• Remove-one state that deletes a single query from history only.
• Clear-all state that removes all visible recent queries for the stated scope.
• History off state where searches still run but new queries are not stored.
• Synced or account-scoped state when history can appear across devices or sessions.
• Sensitive or shared-surface state where history is hidden, short-lived, or explicitly disabled.

Interaction Contract

• Submitting a qualifying search writes or updates a recent-search entry for the current scope when history is on.
• Selecting a recent search reruns that query and scope, updates recency, and preserves the distinction from saved searches.
• Removing a recent search deletes only the query-history entry, not saved searches, saved filters, viewed items, results, or records.
• Clearing recent searches removes visible query history for the stated account, browser, device, or workspace scope.
• Turning search history off prevents future queries from being stored while still allowing search to run.
• The component must not show another user's queries unless a shared account or sync scope is explicit and controllable.
• Popular searches, recommendations, promoted queries, and query suggestions must not be labelled as recently searched unless they came from the user's submitted history.

Implementation Checklist

• Define the event that stores a recent query, such as explicit search submit or selected recent-query rerun.
• Normalize query text and scope for deduplication while preserving the display string users recognize.
• Store scope, timestamp, and optional result count metadata so users can distinguish similar queries.
• Enforce a visible count limit and retention period appropriate to the device, account, and sensitivity of the surface.
• Provide remove-one and clear-all actions with copy that says search history rather than saved search or results.
• Respect signed-out mode, private browsing, managed-device settings, account sync, consent, and search-history off state.
• Separate Recent searches, Popular searches, Suggestions, Saved searches, and Recently viewed with headings and data-model boundaries.
• Refresh or clearly mark result counts when a recent query is rerun so stale counts do not mislead users.
• Test keyboard selection, removal focus, clear-all recovery, history-off behavior, mobile layout, shared-device privacy, and duplicate query handling.

Common Generated-UI Mistakes

• Recording unsubmitted keystrokes as search history.
• Mixing recent searches with popular searches, promotions, saved searches, recent views, recommendations, or bookmarks.
• Showing private queries on shared devices or signed-out public surfaces.
• Providing no way to remove a single embarrassing or sensitive query.
• Clearing saved searches or saved filters when the user only meant to clear recent search history.
• Duplicating the same query every time it is rerun.
• Hiding search-history settings while using synced account activity.
• Showing old result counts as if they are current.

Critique Questions

• What exact action qualifies a query as recently searched?
• Can users tell whether an entry is passive history, a suggestion, a saved search, or a viewed item?
• What account, browser, device, workspace, or session scope does this history use?
• Can users remove one query and clear all history without deleting saved searches?
• Does turning history off stop future storage while preserving the ability to search?
• How are sensitive, signed-out, shared-device, or managed-account searches handled?
• Does rerunning a recent search restore the right query text, scope, filters, and current result count?