UX Patterns Guide
UI + UX Collaboration And Social Interaction established

Follow / subscribe

Provide a per-object follow / subscribe control that names the watched target, shows current state and scope, previews included events and delivery destination, explains automatic subscriptions, supports immediate and digest modes, handles permission changes, and keeps unfollow or unsubscribe available from the same context.

Open in lab Compare alternatives
Decision first

Choose this pattern when the problem matches

Use when

  • Users need future updates from a specific object, thread, channel, space, repository, topic, saved view, or query.
  • The product can maintain subscription records, delivery rules, event types, frequency, and unsubscribe behavior.
  • The user benefits from fewer manual checks and from a visible promise about what will notify them later.

Avoid when

  • The user only needs quick return access without updates.
  • Another person needs to notify the user immediately inside authored content.
  • The product cannot explain target scope, included events, or delivery destination.
  • Updates are critical current-task blockers that must appear in context regardless of subscription.
  • The target is too sensitive to reveal follow state, watchers, or update delivery.

Problem it prevents

Users need to stay informed about future changes to selected work without repeatedly revisiting it, but follow and subscribe controls become noisy or untrustworthy when they hide target scope, delivery channel, auto-follow reasons, included events, permission limits, digest timing, or the unsubscribe path.

Pattern anatomy

What a strong implementation has to make clear

User need

Products may allow users to follow threads, pages, spaces, channels, repositories, issues, pull requests, saved searches, saved views, calendars, authors, topics, or entire workspaces.

Pattern promise

Provide a per-object follow / subscribe control that names the watched target, shows current state and scope, previews included events and delivery destination, explains automatic subscriptions, supports immediate and digest modes, handles permission changes, and keeps unfollow or unsubscribe available from the same context.

Required state

Not following state.

Recovery path

A follow control does not say what target scope it covers.

Access contract

Give the control an accessible name that includes target type, target name, current follow state, and destination when space allows.

Quality bar

The difference between expert and weak execution

Strong implementation

Specific, visible, recoverable

  • A thread header shows Following, explains replies will appear in the followed-threads list and Activity feed, and offers Unfollow replies from the same menu.
  • A Confluence page watch button says Watching page, separates page watch from space watch, and shows that edits and comments are sent by email or in-app notifications according to user settings.
  • A user follows a support thread before leaving for a meeting, receives only new replies in the promised destination, then unfollows when the incident closes.
  • A team member watches a project space for onboarding updates, sees that daily digest is active, and switches one critical page to immediate notifications.
Weak implementation

Vague, hidden, hard to recover from

  • A Subscribe button changes to Subscribed without saying whether the user subscribed to a page, all child pages, a space, email, push, or in-app updates.
  • A repository is watched automatically after one comment, but the user only finds the unsubscribe action three screens deep in global settings.
  • A user receives a stream of update emails from a space but cannot tell which page, mention, reply, or watch setting caused them.
  • A followed saved view keeps sending links after the user loses access to the underlying project.
UI guidance
  • Render follow or subscribe as a stateful control attached to the specific object being watched, with current state, target scope, delivery destination, event types, auto-follow reason when present, and an unfollow path.
  • Distinguish following from mentions, notifications, activity feeds, comments, saved views, and favorites by showing that the user is changing future update delivery for one target rather than sending attention, reading history, writing content, or bookmarking access.
UX guidance
  • Use follow / subscribe when users want future changes to a specific object, channel, thread, repository, page, space, saved view, or topic to come to them without repeatedly checking it.
  • Make subscriptions reversible, scoped, and explainable so users understand why updates arrive, where they arrive, which events are included, and how to stop or narrow noisy delivery.
Implementation contract

What the implementation must handle

States

  • Not following state.
  • Following state.
  • Watching broader parent scope state.
  • Auto-followed because replied, mentioned, authored, assigned, or created state.

Interaction

  • Activating Follow, Subscribe, or Watch creates or updates a subscription record for the named target, not merely a visual bookmark.
  • The control updates its visible label and selected state only after the product can explain the resulting scope and delivery behavior.
  • Users can inspect why they are receiving updates from the object context or notification item, including manual, auto-follow, parent-scope, mention, or preference reasons.
  • Unfollow or unsubscribe removes that subscription without deleting the target, comment, notification history, saved view, or favorite.

Accessibility

  • Give the control an accessible name that includes target type, target name, current follow state, and destination when space allows.
  • Do not rely on a filled star, bell, eye, or checkmark alone to indicate follow state.
  • Announce successful follow, unfollow, mute, failed update, and pending sync through status text.
  • Make scope and delivery details reachable from keyboard and touch, including overflow-menu implementations.

Review

  • What exact object, scope, or query does this control subscribe the user to?
  • Which future events will produce updates, and where will those updates appear?
  • Can the user see why they were automatically subscribed?
  • Can the user unfollow, mute, reduce frequency, or change delivery without losing object context?
Interactive lab

Inspect the states before you copy the pattern

Subscribe to future updates without hiding scope

Follow, unfollow, switch item/thread/parent scope, inspect auto-follow reason, delivery destination, digest, muted, permission-limited, closed-target, bulk cleanup, and compare vague-scope, hidden-unfollow, surprise-email, duplicate-delivery, stale-access, and fake-bookmark failures.

Follow / subscribe
Interactive demo is ready

Launch the live UI/UX lab when you want to inspect states, keyboard behavior, and common failure modes.

State To Inspect

Not following state.

Keyboard / Access

Tab moves to the follow control, scope menu, delivery menu, event-type options, frequency controls, and unsubscribe action.

Avoid Generating

Using Follow as a bookmark with no future update delivery.
Evidence trail

Source-backed claims behind this guidance

Full agent/debug reference

Problem Context

  • Products may allow users to follow threads, pages, spaces, channels, repositories, issues, pull requests, saved searches, saved views, calendars, authors, topics, or entire workspaces.
  • Subscriptions can be created manually by clicking Follow, Subscribe, or Watch, or automatically when the user replies, is mentioned, creates content, owns an object, joins a team, or changes notification settings.
  • Delivery may happen through notification center, activity feed, email, push, desktop banners, digests, followed-thread lists, channel badges, or integrations.
  • The same word can mean different scopes across products: watching a page differs from watching a space, following a thread differs from following a channel, and subscribing to a saved view differs from saving it.
  • Noisy subscriptions often persist longer than the user's original need, so users need narrow scope, visible reasons, and quick cleanup.

Selection Rules

  • Choose follow / subscribe when the user is opting into future update delivery from a specific target.
  • Use notification center for the retained inbox where delivered subscription updates are triaged, marked read, filtered, and acted on.
  • Use activity feed for broad catch-up across many sources; use follow / subscribe to decide which sources or objects are elevated from that stream.
  • Use mentions when another person routes attention to the user inside authored content.
  • Use threaded discussion when replies and branches need conversation structure; use follow / subscribe to control future reply delivery.
  • Use comments when the user is contributing written feedback; subscribing to comments only controls future comment updates.
  • Use saved view when the user stores a filtered surface; add follow / subscribe only when future changes to that view trigger delivery.
  • Use settings management for global defaults such as email, push, digest, quiet hours, and channel-level notification behavior.
  • Use favorites or pinned items for quick return access without update delivery.
  • Show whether the subscription target is one item, one thread, one channel, a page and descendants, a space, a repository, a query, or all matching future items.
  • Explain automatic follow reasons such as replied, mentioned, author, assigned, owner, or all-new-posts preference.
  • Provide unsubscribe, unfollow, mute, reduce frequency, and delivery-channel controls without forcing users to leave the object context.

Required States

  • Not following state.
  • Following state.
  • Watching broader parent scope state.
  • Auto-followed because replied, mentioned, authored, assigned, or created state.
  • Pending subscription update state.
  • Unfollowed or unsubscribed state.
  • Muted or delivery disabled state.
  • Delivery destination selection state such as Activity feed, notification center, banner, push, email, or digest.
  • Event-type selection state such as all updates, replies only, comments, edits, mentions, releases, or status changes.
  • Digest or immediate delivery state.
  • Permission-limited or inaccessible target state.
  • Deleted, archived, completed, closed, or resolved target state.
  • Bulk unsubscribe or manage subscriptions state.

Interaction Contract

  • Activating Follow, Subscribe, or Watch creates or updates a subscription record for the named target, not merely a visual bookmark.
  • The control updates its visible label and selected state only after the product can explain the resulting scope and delivery behavior.
  • Users can inspect why they are receiving updates from the object context or notification item, including manual, auto-follow, parent-scope, mention, or preference reasons.
  • Unfollow or unsubscribe removes that subscription without deleting the target, comment, notification history, saved view, or favorite.
  • Delivery settings separate target scope, event type, channel, frequency, digest, and quiet-mode behavior.
  • If access is lost or a target is archived, completed, deleted, or closed, future updates are stopped or downgraded and stale subscriptions become explainable.
  • Bulk management pages show enough context to unsubscribe without losing track of which target or scope is being changed.

Implementation Checklist

  • Define subscription target types, parent-scope inheritance, event types, delivery channels, frequency, auto-follow triggers, unsubscribe behavior, and cleanup policy.
  • Store explicit reason metadata such as manual follow, replied, mentioned, created, assigned, team preference, space watch, repository watch, or saved-view subscription.
  • Render per-object state with current label, scope, included events, destination, frequency, and unfollow action.
  • Support immediate, digest, muted, paused, and delivery-disabled modes without losing the underlying subscription explanation.
  • Synchronize subscriptions with notification center, activity feed, email, push, channel badges, and followed-thread lists.
  • Handle permission changes, deleted targets, renamed targets, parent-scope changes, duplicate subscriptions, offline toggles, and bulk unsubscribe safely.
  • Test keyboard toggling, menu selection, screen-reader labels, mobile long-press or overflow menus, high-volume subscription lists, digest timing, and cross-device state.

Common Generated-UI Mistakes

  • Using Follow as a bookmark with no future update delivery.
  • Using Subscribe as a mailing-list opt-in without showing which object or event types are included.
  • Hiding Unfollow in global notification settings only.
  • Automatically following users without showing why they are receiving updates.
  • Treating parent-scope watches and item-level watches as the same state.
  • Sending both immediate and digest updates for the same event with no deduplication.
  • Keeping subscriptions active after target deletion, archive, permission loss, or issue closure.
  • Calling a notification center subscription management page the follow control itself.

Critique Questions

  • What exact object, scope, or query does this control subscribe the user to?
  • Which future events will produce updates, and where will those updates appear?
  • Can the user see why they were automatically subscribed?
  • Can the user unfollow, mute, reduce frequency, or change delivery without losing object context?
  • How are parent-scope watches, item-level watches, and duplicates resolved?
  • What happens when the object is archived, closed, deleted, renamed, or no longer accessible?
Accessibility
  • Give the control an accessible name that includes target type, target name, current follow state, and destination when space allows.
  • Do not rely on a filled star, bell, eye, or checkmark alone to indicate follow state.
  • Announce successful follow, unfollow, mute, failed update, and pending sync through status text.
  • Make scope and delivery details reachable from keyboard and touch, including overflow-menu implementations.
  • Keep focus stable when the label changes from Follow to Following or Unfollow.
  • Expose auto-follow reasons and parent-scope inherited watches as text, not only tooltip hover.
  • Ensure bulk subscription lists identify each target, scope, reason, and selected state for screen-reader users.
Keyboard Behavior
  • Tab moves to the follow control, scope menu, delivery menu, event-type options, frequency controls, and unsubscribe action.
  • Enter or Space toggles the primary follow state when there is only one safe default.
  • Enter or Space opens a menu instead of toggling when the product must choose scope or delivery first.
  • Escape closes scope or delivery menus and returns focus to the invoking control.
  • Arrow keys may move inside menu, radio, or listbox controls according to their native pattern.
  • After unsubscribe, focus remains on the target row or moves to the next subscription in bulk-management views.
Variants
  • Follow thread
  • Subscribe to issue
  • Watch repository
  • Watch page
  • Watch space
  • Follow channel
  • Subscribe to saved view
  • Follow topic
  • Digest subscription
  • Auto-followed thread
  • Bulk unsubscribe
  • Muted subscription

Verification

Last verified: