Hubbry Logo
Pop-up notificationPop-up notificationMain
Open search
Pop-up notification
Community hub
Pop-up notification
logo
8 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Pop-up notification
Pop-up notification
Pop-up notification
View on Wikipedia
from Wikipedia
Close-up of the upper right corner of a Lubuntu 12.04 desktop, showing a notification that informs the user that the battery has finished charging
Close-up of the upper right corner of a Windows 8 desktop, showing a notification that informs the user that a new removable drive is now attached
A notification on Android that includes a progress bar
A pop-up notification that appears on Wikipedia after an edit made by a user publishes successfully

The pop-up notification (or toast, passive pop-up, snackbar, desktop notification, notification bubble, or simply notification) is a graphical control element that communicates certain events to the user without forcing them to react to this notification immediately, unlike conventional pop-up windows. Desktop notifications usually disappear automatically after a short amount of time. Often their content is then stored in some widget that allows the users to access past notifications at a more convenient time.

On mobile devices, a push notification system is typically used.

Support on different systems

[edit]

In Windows 2000, Microsoft introduced balloon help-like passive pop-up notifications, tied to the notification area of the taskbar. Notifications get queued when user is away or screensaver is running, and get shown when the user resumes activity. They remain on screen for nine seconds while fading out if the user appears to ignore them.[1] Microsoft also adopted similar notifications for its other software such as Windows Phone using the Microsoft Push Notification Service,[2] Internet Explorer 7 and later, Microsoft Outlook, Microsoft Security Essentials, as well as Windows 8 and Windows 10 using the Windows Notification Service.

Desktop notifications are a proposed standard for freedesktop.org,[3] but all the major desktop environments running on the X Window System already support this standard, making them typically available on Linux and other Unix-like systems. Google adopted the concepts of notification drawer[4] and toast popup messages[5] for user notifications as basic components of its Android operating system.

macOS (since OS X Mountain Lion) provides desktop notifications via Notification Center. Previous versions of OS X have no built-in desktop notification feature; however, Growl is a popular application that provides similar functionality and enjoys broad support from third-party software.[6] iOS also includes Notification Center as of iOS 5.

JavaScript

[edit]

Browsers that support JavaScript typically implement the Notification API.[7] This API asks for user confirmation to allow popups and give the programmer the opportunity to display notifications with a text (body) along with a descriptive icon and header.

Capabilities

[edit]
Notification on Ubuntu Linux, showing buttons and a pie-like time-out indicator

While passive pop-ups do not require any user interaction, some implementations still provide a way for the user to optionally interact with the pop-up. This is called actions.[citation needed] For the Freedesktop specification, this is an optional feature that clients cannot rely on, and its use is discouraged by some design guidelines.[8]

Android adds the ability to provide actions with Jelly Bean.[9]

In the Material Design language

[edit]

Google's Material Design introduced the term snackbar to refer to a user-interface element displaying a temporary, closable notification:

Snackbars inform users of a process that an app has performed or will perform. They appear temporarily, towards the bottom of the screen. They shouldn’t interrupt the user experience, and they don’t require user input to disappear.[10]

[edit]

References

[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Pop-up notification

View on Grokipedia
from Grokipedia
A pop-up notification is a transient graphical user interface (GUI) element that appears temporarily on a user's screen to deliver timely, non-intrusive information such as status updates, alerts, confirmations, or reminders, often in the form of a small window, banner, or balloon that overlays but does not fully block the main content. These notifications are designed to be concise and actionable, allowing users to glance at essential details without disrupting their current task, and they typically auto-dismiss after a few seconds unless interacted with. Common in operating systems, mobile apps, and web applications, pop-up notifications enhance user experience by providing real-time feedback while minimizing cognitive load. Pop-up notifications encompass several subtypes tailored to different contexts and urgency levels, including toast notifications, which are lightweight, auto-expiring messages that slide in from screen edges to confirm actions like saves or errors; heads-up notifications, which float briefly over content for high-priority alerts in mobile environments; and balloon tips, which emerge from system tray icons to signal non-critical events in desktop interfaces. In , the Notifications API enables browser-based pop-ups that display outside the page at the system level, requiring user permission for privacy. On platforms like and macOS, they appear as banners on the or , emphasizing brevity and with icons, titles, and optional action buttons. The evolution of pop-up notifications traces back to early GUI innovations, with introducing balloon-style passive notifications in tied to the taskbar's notification area for status indicators. Android popularized the "toast" variant in its 2008 release as unobtrusive, bottom-screen pop-ups inspired by quick, disappearing messages, influencing modern mobile UX. Over time, these elements have become standardized across ecosystems to balance informativeness with , though excessive use can lead to user fatigue, prompting guidelines for prioritization and customization. Best practices recommend limiting notifications to high-value content, ensuring through compatibility, and offering options to respect user preferences.

Overview

Definition

A pop-up notification is a temporary (GUI) element that overlays the current content to deliver information, alerts, or prompts to the user without necessitating a change in the active view or . These elements emerge suddenly, often triggered by system events, user actions, or application states, ensuring users receive timely feedback while maintaining continuity. Key characteristics of pop-up notifications include their ephemeral nature, with automatic dismissal after a brief duration—typically a few seconds—or upon user interaction such as or swiping. They achieve visual prominence through positioning (e.g., centered or edge-aligned overlays), animations (e.g., fade-ins or slides), and sometimes background dimming, immediate attention without overwhelming the interface. Pop-up notifications can be non-blocking, permitting interaction with underlying content, or blocking (modal), which halts further actions until acknowledged, depending on the urgency of the message. In distinction from static UI components like persistent sidebars, toolbars, or fixed panels, pop-up notifications are inherently transient and context-specific, appearing only when relevant to the immediate and vanishing to avoid clutter. This design prioritizes minimal intrusion while effectively communicating essential details. Common use cases encompass error messages indicating failures (e.g., network disconnection), confirmations for critical actions (e.g., data deletion), and status updates (e.g., successful file saves) within desktop, mobile, or web applications.

History

While early graphical user interfaces (GUIs) in the and laid the groundwork with modal dialog boxes for user alerts and interactions—influencing later non-intrusive designs—the evolution of pop-up notifications as transient, non-blocking elements began with passive status indicators. The Smalltalk environment, developed for the at PARC around 1974, introduced one of the first implementations of dialog boxes alongside windows, icons, and menus, enabling on-screen prompts for user input without relying on command-line interfaces. This system laid the groundwork for modal dialogs that temporarily halted user activity to demand attention, a core mechanic in later pop-up designs. By 1981, the commercial workstation expanded on these concepts with more refined dialog boxes for error messages and confirmations, influencing subsequent GUIs. The , released in 1983, marked a pivotal commercialization of dialog-based alerts in personal computing, featuring modal dialog boxes that required user acknowledgment before proceeding, often for warnings or confirmations. The Apple Macintosh, launched in 1984, popularized these elements through its intuitive interface, where alert dialogs became standard for system notifications, such as error messages or file operations, making them accessible to non-technical users. These early desktop systems established pop-ups as non-intrusive yet attention-grabbing overlays, evolving from rigid modal boxes to precursors of dynamic notifications. A significant advancement in non-blocking pop-up notifications came with in 2000, which introduced balloon-style passive notifications tied to the taskbar's notification area for status indicators. In the web era of the , pop-up notifications emerged as a browser-based extension of GUI dialogs, initially through capabilities. 2.0, released in September 1995, introduced the window.open() method as part of JavaScript 1.0, allowing web pages to spawn new browser windows for alerts or advertisements. This feature quickly led to the first pop-up advertisements in , when developer at Tripod.com used it to display auto ads in separate windows to avoid clashing with site content, inadvertently sparking widespread use for intrusive marketing. User backlash against these unsolicited overlays grew rapidly, prompting early countermeasures; by the late , third-party tools like PopupStopper appeared in 2000, followed by built-in blockers in browsers such as Opera 7.0 in 2003 and with Service Pack 2 in 2004. The shift to in the late 2000s transformed pop-up notifications into push-based systems optimized for smaller screens and intermittent connectivity. Apple's , introduced in 2007, initially lacked push capabilities, but 3.0 in June 2009 enabled the first push notifications, allowing apps to deliver remote alerts without user initiation, such as arrivals or social updates. This innovation addressed battery and performance concerns by routing notifications through Apple's Push Notification Service (APNS), reducing in-app polling. By the , in-app pop-ups evolved further, incorporating non-modal "toast" notifications—brief, auto-dismissing banners—in platforms like Android, starting with its initial release in 2008, and , prioritizing minimal disruption over full-screen interruptions. Standardization efforts in the aimed to unify pop-up behaviors across web and mobile environments. The W3C published the first draft of the Web Notifications API on March 1, 2011, defining a framework for web applications to display system-level notifications outside the browser context, with user permission. This API, recommended as a standard in October 2015, facilitated cross-platform consistency, enabling rich, interactive alerts while addressing concerns through opt-in mechanisms. Culturally, pop-ups transitioned from notorious web ad nuisances—often blocked by default—to essential, user-centric tools in modern apps, reflecting a broader emphasis on seamless, permission-based interactions.

Types

Toast and Banner Notifications

Toast and banner notifications represent a class of non-intrusive pop-up interfaces designed to deliver brief, informational messages without requiring user interaction or interrupting ongoing tasks. These notifications typically manifest as short-lived elements that slide in from the screen's edges—often from the bottom for toasts or the top for banners—and automatically fade out after a predetermined duration, ensuring minimal disruption to the user experience. In terms of mechanics, toast notifications, as implemented in Android, display for a configurable short period, commonly 2 to 3 seconds, though developers can extend this slightly for readability; they occupy only the necessary space at the bottom of the screen and do not overlay or block other content, allowing users to continue interacting with the app. Banner notifications in function similarly, appearing temporarily at the top of the screen for about 3 to 5 seconds in their default "temporary" style, with options for persistence if needed, but always without modal blocking; some variants include progress indicators to signal ongoing processes like downloads or uploads. Heads-up notifications, a high-priority variant in Android, appear as floating banners over the current content for urgent alerts, remaining visible briefly (typically a few seconds) and accessible in the notification drawer afterward. Unlike more demanding pop-ups, these notifications support swipe-to-dismiss gestures and often integrate subtle animations for smooth entry and exit, prioritizing seamless flow over attention capture. Balloon tips, common in desktop environments like Windows, emerge from system tray icons as small, transient pop-ups for non-critical events, such as status updates, and auto-dismiss after a short time without blocking the interface. These notification types find primary application in providing status updates for completed actions, such as "File saved successfully" in productivity apps, or conveying non-urgent alerts like incoming messages in social platforms without pulling users away from their current activity. They are particularly suited for mobile environments where maintaining user momentum is key, appearing in scenarios like confirming form submissions, reporting network status changes, or acknowledging minor system events. A key advantage of toast and banner notifications lies in their ability to enhance user flow by delivering essential feedback unobtrusively, reducing compared to interruptive alerts and enabling multitasking on touch-based devices. However, a notable drawback is the potential for users to overlook them entirely, especially during high-engagement tasks or if notifications queue rapidly, leading to missed information and possible user frustration from perceived system silence. Prominent examples include Android's Toast API, which provides lightweight, text-based feedback for operations like data saves, and the closely related Snackbar component from , which slides up from the bottom with optional action buttons for simple responses. On , banner-style alerts serve a parallel role, displaying as top-screen overlays for app events like new email arrivals, configurable via the UserNotifications framework to ensure they remain non-blocking.

Technical Implementation

Support Across Operating Systems

Pop-up notifications have been supported natively in Windows through the taskbar's notification area since Windows 2000, featuring balloon tips for non-intrusive status updates. This evolved with the introduction of Universal Windows Platform (UWP) toast notifications in Windows 10 in 2015, enabling actionable banners that integrate with the Action Center for modern applications. As of 2025, Windows 11 continues to refine toast notifications with enhanced customization in the 24H2 update, including improved grouping and focus modes. In the , macOS supports banner-style notifications through the , introduced in version 10.8 (Mountain Lion) in 2012, allowing temporary alerts that can be expanded for details. Similarly, iOS implemented banners starting with in 2011, enabling apps to deliver timely alerts outside the main interface. Recent updates in iOS 18 (2024) introduce Apple Intelligence features, such as Priority Notifications that summarize and prioritize alerts on the using on-device AI, and app locking that hides notifications for sensitive apps to enhance privacy. macOS Sequoia (2024) adds iPhone Mirroring, allowing iPhone notifications to appear on Mac for seamless cross-device access. These require explicit user opt-in via the UNUserNotificationCenter , introduced in iOS 10. Android provides native support for pop-up notifications via the Toast class, introduced in API level 1 with the platform's debut in , offering short-lived, non-interactive messages that automatically dismiss after a set duration. Building on this, Snackbars were added in 2014 as part of the guidelines, providing interactive pop-ups with optional action buttons that appear at the bottom of the screen and can be dismissed by swiping. For remote push notifications, Android integrates with , enabling server-sent alerts that leverage the system's notification framework. Android 15 (2024) introduces Private Space, which hides notifications for apps in a secure profile, impacting delivery visibility and requiring developers to handle permission scopes accordingly. Cross-platform development faces challenges due to inconsistencies in notification behaviors and permissions across operating systems; for instance, mandates explicit user opt-in for notifications via the UNUserNotificationCenter API, preventing unsolicited alerts, whereas Android allows more flexible channel-based permissions (introduced in Android 8.0 Oreo in 2017) but varies in default dismissal mechanics, such as auto-hiding versus persistent stacking in Windows. On distributions, support for pop-up notifications is less standardized, with environments relying on the libnotify library for desktop toasts, which sends notifications to the desktop shell for display as banners, though implementation details differ across desktop environments like or XFCE.

Web and Methods

In , pop-up notifications are primarily implemented using browser s and to display alerts outside the main browsing context, often requiring user permission to avoid intrusive behavior. The Web Notifications , standardized by the W3C, enables websites to show system-level notifications, such as desktop alerts for messages or updates, independent of the active tab. This was first supported in version 22, released in September 2012, marking an early adoption for permission-based notifications that prompt users to grant or deny access before displaying alerts. The 's core functionality involves checking permission status via Notification.permission and requesting approval with Notification.requestPermission(), ensuring notifications only appear after explicit user consent to mitigate spam. For custom pop-up dialogs within the page, leverages (DOM) manipulation to create overlay elements without relying on native browser windows. Developers typically use document.createElement('div') to generate a notification container, append it to the body, and apply CSS styles for positioning, such as fixed overlays with high z-index values to appear above other content. The , supported in modern browsers, further simplifies this by allowing modal or non-modal pop-ups via methods like showModal() for blocking interactions until dismissed. Libraries like SweetAlert2 provide pre-built solutions for these overlays, offering customizable, responsive pop-ups that replace basic alert() calls with styled dialogs, icons, and buttons, while handling accessibility attributes like roles. Event handling enhances and timing in these implementations. For instance, onclick events on notification buttons can trigger closures or actions, while setTimeout() schedules auto-dismissal after a delay, such as 5 seconds, to prevent persistent overlays. In scenarios requiring background delivery, service workers integrate with the Notifications API to show alerts even when the page is inactive; the ServiceWorkerRegistration.showNotification() method displays persistent notifications triggered by push events. Browser variations affect implementation reliability. introduced built-in pop-up blocking in version 1.0, released on November 9, 2004, to restrict unsolicited new windows and prioritize user control over site-initiated interruptions. Older versions of , lacking native support for the Notifications API, often require polyfills—JavaScript shims like those emulating Notification constructors—to enable compatibility, though these may not fully replicate modern behaviors due to engine limitations. Such differences necessitate feature detection, like checking if ('Notification' in window), to fallback to alternative methods. Security measures are integral to prevent abuse, such as malicious pop-ups leading to . The (CSP) header's sandbox directive enforces restrictions on iframes or pages, blocking pop-ups by default unless allow-popups is specified, thereby isolating potentially harmful scripts. Additionally, CSP directives like child-src and frame-ancestors control the origins from which pop-ups or embedded content can load, mitigating risks by whitelisting trusted domains. These controls, combined with browser sandboxing of execution contexts, ensure pop-ups cannot access sensitive APIs without explicit permissions.

Design and Capabilities

Core Features

Pop-up notifications, also known as transient UI elements like toasts or snackbars, incorporate essential features that enable developers to deliver timely information without disrupting the primary . These include customizable duration, which allows notifications to display for short periods (e.g., 2-4 seconds), longer intervals, or indefinitely until user interaction, as seen in Android's Snackbar with predefined lengths like LENGTH_SHORT or LENGTH_LONG. Positioning options typically place notifications in non-intrusive locations such as screen corners, bottom edges, or centers, depending on the platform; for instance, Windows toast notifications often appear in the top-right corner. Content types support a range of elements, including plain text for messages, icons for visual cues, and buttons for immediate actions, enabling concise communication as in iOS banners with title, body, and up to four action buttons. Interaction capabilities enhance by allowing users to engage or dismiss notifications intuitively. On mobile devices, swipe-to-dismiss gestures provide a natural way to clear alerts, a standard in Android Snackbars when anchored to a CoordinatorLayout. Desktop environments often feature hover persistence, where notifications remain visible during mouse-over, alongside click actions that trigger linked behaviors like opening details or performing tasks, as implemented in Windows toasts. The Web Notifications API similarly supports click events to handle user responses. Multimedia support extends pop-up notifications beyond text to richer experiences. Icons and embedded links facilitate quick recognition and navigation, while progress bars indicate ongoing processes, a capability in Windows toasts for updates like downloads. On devices with haptic capabilities, vibration or tactile feedback accompanies notifications for non-visual alerts, as provided by system sounds and haptics. The Web Notifications API includes support for images and vibration patterns. Persistence options ensure multiple notifications do not overwhelm the interface. Queuing mechanisms display alerts sequentially, preventing overlap, while stacking arranges them in accessible areas like notification centers; iOS stacks notifications in the , and Android queues Snackbars. Windows toasts similarly support queuing and stacking for efficient management. Performance aspects prioritize seamless integration to avoid UI disruptions. Lightweight rendering techniques ensure notifications appear without causing lag, as the underlying activity remains interactive in Android implementations. Fallback mechanisms handle low-bandwidth or resource-constrained scenarios, such as simplifying content in Web Notifications under secure contexts. These core features are realized through platform APIs like the Web Notifications API or Android's Snackbar class.

Material Design Integration

Material Design, introduced by Google in 2014, integrates pop-up notifications through components like snackbars and dialogs, emphasizing non-intrusive, layered interfaces with elevation and smooth motion to mimic physical materials. Snackbars serve as temporary, low-priority notifications that appear at the bottom of the screen, providing feedback on app processes without blocking user interaction, while dialogs function as modal overlays for critical decisions requiring immediate attention. These elements align with Material Design's core principles of hierarchy and responsiveness, using shadows for depth and animations for intuitive transitions. Specific components include the snackbar, designed for actionable messages such as undo options after deletions, and dialogs, which appear as elevated modals with rounded corners and subtle shadows to draw focus. Snackbars feature a container with supporting text and an optional action , typically displaying for brief updates like "Item added to cart," while basic dialogs interrupt with urgent prompts, such as alerts, and full-screen variants handle complex tasks on smaller devices. Visual guidelines in specify a maximum width of 560dp for dialogs to ensure readability across devices, with snackbars adopting full-width placement on mobile screens for optimal visibility. Components incorporate ink ripple effects on user taps to provide tactile feedback, and color theming draws from primary and secondary palettes, often dynamically generated from user wallpapers in 3 for personalized yet accessible contrasts. Elevation is standardized at 6dp for both snackbars and dialog containers, paired with 4dp rounded corners on snackbars and 28dp on basic dialogs to enhance perceived depth and modern aesthetics. Behavioral rules dictate that snackbars auto-hide after 4 to 10 seconds if no action is taken, remaining persistent for interactive variants until dismissed, and they stack sequentially rather than overlapping to maintain clarity. Dialogs enforce modality with a semi-transparent scrim, retaining focus until resolved, and support up to two actions aligned to the trailing edge for efficient decision-making. is addressed through roles on web implementations, such as role="alert" for snackbars to announce changes to screen readers, alongside larger touch targets meeting minimum 48dp sizes for inclusive interaction. Updates in 3, released in 2021, refined these integrations by introducing dynamic color theming for adaptive palettes and expanded touch targets to improve on diverse devices, building on earlier versions' foundations for more expressive, user-centric notifications.

User Experience Considerations

Best Practices

To enhance , pop-up notifications should be deployed sparingly to avoid notification , with designers prioritizing critical messages over trivial ones, such as reserving them for irreversible actions or urgent system events rather than routine confirmations. According to research, overuse of intrusive pop-ups leads to user frustration and higher dismissal rates, recommending limits like one pop-up at a time and suppression of non-urgent alerts to the . Apple's similarly advise against alerts for common, undoable tasks, suggesting contextual indicators instead to maintain trust and reduce interruptions. Design tips emphasize brevity and consistency: keep text concise, ideally under two lines for titles and brief for body content, using direct like action verbs in buttons (e.g., "Delete" rather than "Error Occurred"). Animations should be subtle, such as fade-in and fade-out effects, to signal appearance without distraction, while ensuring full mobile by adapting to screen sizes and avoiding content overlap. Microsoft's toast notification guidance reinforces this by advocating for clear, valuable content with optional elements like icons or progress bars only when they add immediate utility, preventing visual clutter. For timing and placement, trigger pop-ups in response to specific user actions, such as after task completion, rather than at app launch or during focused work, and position them peripherally—e.g., at the screen's bottom or corners—to avoid blocking focal areas. Android's Snackbar guidelines specify bottom-screen placement for non-blocking visibility, allowing continued interaction, while cultural testing is essential for icon interpretation to ensure global relevance. To empower users in managing pop-up notifications and reducing fatigue, especially on Android devices, clear options for disabling or customizing them should be provided. Users can disable pop-up notifications with text for specific apps by navigating to Settings > Apps > Select the app (e.g., VK, Telegram, Instagram, WhatsApp) > Notifications. They can then find the relevant notification channel (e.g., Messages, Chats) and set its Importance to Low or Medium, which prevents sounds and pop-ups while allowing notifications to appear silently in the status bar. Alternatively, in advanced notification settings, users can disable "Pop on screen" options where available. Many apps also offer in-app controls: Open the app > Settings > Notifications and sounds > Pop-up notifications > Select None or Only without text. These steps ensure notifications remain informative without intrusive displays. Testing recommendations include A/B variants to measure dismissal rates and engagement, alongside integration with analytics tools to track metrics like open rates and user retention impact. Usability studies, as outlined by , help refine triggers and frequency by observing real-user behavior, ensuring pop-ups align with task flow without increasing cognitive load. Effective implementations, like Gmail's nonmodal overlays for feature updates that appear contextually without halting , contrast with poor examples such as sites' immediate entry pop-ups that demand input before content access, leading to high bounce rates. Slack's toast-style status notifications exemplify good practice by delivering brief, actionable updates (e.g., "User is typing") in real-time chats without overwhelming the interface, fostering over intrusion.

Accessibility and Criticisms

Pop-up notifications present several accessibility challenges, particularly for users relying on assistive technologies. compatibility is a key issue, as dynamic announcements in notifications must be conveyed without disrupting the user's current focus; this is achieved through live regions, which allow screen readers to announce updates like status messages (e.g., "Form submitted successfully") using politeness levels such as "polite" for non-urgent notifications or "assertive" for critical ones. Keyboard navigation in modal pop-ups often fails to provide visible focus indicators, making it difficult for users with motor impairments or those navigating via keyboard to interact with elements like buttons or input fields. High-contrast options are essential to address challenges for color-blind users, as notifications relying solely on color cues (e.g., red for errors) can be imperceptible without sufficient text contrast ratios of at least 4.5:1. Alignment with (WCAG) 2.1 is crucial for inclusive design, yet pop-up notifications frequently violate criteria like 2.4.7 Focus Visible, which requires keyboard focus to be discernible on all interactive components within modals, and 4.1.3 Status Messages, which mandates that brief updates (e.g., toast notifications) be programmatically determinable by assistive technologies without shifting focus. These guidelines ensure notifications do not create barriers for users with low vision or cognitive disabilities, but implementation gaps persist, such as inadequate announcements for dynamic content changes. Criticisms of pop-up notifications center on their overuse, which leads to user annoyance and contributes to the widespread adoption of browser blockers; for instance, intrusive ad pop-ups have prompted tools like ad blockers to mitigate interruptions. concerns arise from tracking mechanisms embedded in notifications, which monitor user behavior across sites and devices, posing risks to and data security. In multi-notification scenarios, cognitive overload occurs as frequent interruptions impair attention and , with research showing that notifications disrupt cognitive control and increase mental strain during tasks. Mitigation strategies include requiring opt-in permissions before sending notifications, which reduces unsolicited intrusions and respects user consent. Customizable settings allow users to adjust frequency, timing, and types of notifications, helping to prevent overuse and as demonstrated in studies on granular controls. Alternatives like in-line messages embedded within the page offer less disruptive feedback compared to pop-ups. from the indicates a strong user preference for non-intrusive notifications, such as passive badges, over modal interruptions for routine updates, as the latter can disrupt workflows without adding value.

References

  1. https://developer.android.com/develop/ui/views/notifications
  2. https://developer.apple.com/design/human-interface-guidelines/notifications
  3. https://developer.mozilla.org/en-US/docs/Web/API/Notifications_API/Using_the_Notifications_API
  4. https://www.nngroup.com/articles/ui-elements-glossary/
  5. https://learn.microsoft.com/en-us/windows/win32/shell/notification-area
  6. https://learn.microsoft.com/en-us/windows/win32/uxguide/ctrl-balloons
  7. https://learn.microsoft.com/en-us/windows/win32/api/shellapi/ns-shellapi-notifyicondataa
  8. https://developer.android.com/guide/topics/ui/notifiers/toasts
  9. https://www.nngroup.com/articles/indicators-validations-notifications/
  10. https://developer.apple.com/design/human-interface-guidelines/notifications#Best-practices
  11. https://www.nngroup.com/articles/popups/
  12. https://learn.microsoft.com/en-us/windows/apps/design/controls/dialogs-and-flyouts/
  13. https://www.classic-computing.org/wp-content/uploads/2016/01/A_History_of_the_GUI.pdf
  14. https://www.obscure.org/~perky/uofr/spring2003/ISYS204U/History_of_GUI.pdf
  15. https://eclecticlight.co/2025/05/24/a-brief-history-of-alerts/
  16. https://rsisinternational.org/Issue0/issue8/673-680.pdf
  17. https://thehistoryoftheweb.com/browser-wars/
  18. https://www.nytimes.com/2014/02/16/magazine/who-made-that-pop-up-ad.html
  19. https://tomasp.net/blog/2021/popup-from-hell/
  20. https://www.braze.com/resources/articles/push-notification-evolution-2009-to-now
  21. https://alertzy.app/articles/the-history-of-push-notifications
  22. https://www.w3.org/TR/2011/WD-notifications-20110301/
  23. https://www.w3.org/TR/2015/REC-notifications-20151022/
  24. https://www.businessinsider.com/reference/what-are-banners-on-iphone
  25. https://developer.apple.com/documentation/usernotifications/generating-a-remote-notification
  26. https://support.apple.com/guide/iphone/change-notification-settings-iph7c3d96bab/ios
  27. https://m2.material.io/components/snackbars/android/
  28. https://blog.logrocket.com/ux-design/toast-notifications/
  29. https://adamsilver.io/blog/the-problem-with-toast-messages-and-what-to-do-instead/
  30. https://developer.android.com/reference/android/widget/Toast
  31. https://developer.android.com/reference/com/google/android/material/snackbar/Snackbar
  32. https://learn.microsoft.com/en-us/windows/uwp/design/shell/tiles-and-notifications/adaptive-interactive-toasts
  33. https://developer.apple.com/documentation/usernotifications
  34. https://www.apple.com/newsroom/2024/06/introducing-apple-intelligence-for-iphone-ipad-and-mac/
  35. https://www.apple.com/newsroom/2024/06/ios-18-makes-iphone-more-personal-capable-and-intelligent-than-ever/
  36. https://www.apple.com/newsroom/2024/06/macos-sequoia-takes-productivity-and-intelligence-on-mac-to-new-heights/
  37. https://developer.android.com/develop/ui/views/notifications/snackbar
  38. https://blog.google/products/android/android-15/
  39. https://developer.apple.com/documentation/usernotifications/unusernotificationcenter
  40. https://www.mobiloud.com/blog/push-notifications-ios-vs-android
  41. https://caniuse.com/notifications
  42. https://sweetalert2.github.io/
  43. https://developer.mozilla.org/en-US/docs/Web/API/Window/setTimeout
  44. https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerRegistration/showNotification
  45. https://www-archive.mozilla.org/press/mozilla-2004-11-09.html
  46. https://developer.android.com/develop/ui/views/notifications/snackbar/showing
  47. https://learn.microsoft.com/en-us/windows/apps/develop/notifications/app-notifications/toast-notifications-overview
  48. https://developer.mozilla.org/en-US/docs/Web/API/Notification
  49. https://m3.material.io/components/dialogs/overview
  50. https://m3.material.io/foundations/material-theming/overview
  51. https://m3.material.io/components/snackbar/guidelines
  52. https://m3.material.io/components/dialogs/guidelines
  53. https://m3.material.io/components/snackbar/specs
  54. https://m3.material.io/components/dialogs/specs
  55. https://m3.material.io/styles/color/overview
  56. https://m3.material.io/components/snackbar/accessibility
  57. https://m3.material.io/blog/material-google-io21
  58. https://developer.apple.com/design/human-interface-guidelines/alerts
  59. https://learn.microsoft.com/en-us/windows/apps/develop/notifications/app-notifications/toast-ux-guidance
  60. https://support.google.com/android/answer/9079661
  61. https://developer.android.com/develop/ui/views/notifications/channels
  62. https://www.smashingmagazine.com/2025/07/design-guidelines-better-notifications-ux/
  63. https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Guides/Live_regions
  64. https://www.w3.org/WAI/WCAG21/Understanding/status-messages.html
  65. https://www.w3.org/WAI/WCAG22/Understanding/focus-visible.html
  66. https://cieden.com/book/sub-atomic/color/system-alerts-for-color-blind-users
  67. https://webaim.org/articles/contrast/
  68. https://www.jefftk.com/p/thoughts-on-ad-blocking
  69. https://epic.org/issues/consumer-privacy/online-advertising-and-tracking/
  70. https://pmc.ncbi.nlm.nih.gov/articles/PMC9671478/
  71. https://vwo.com/blog/push-notification-marketing-strategy/
Add your contribution
Related Hubs
User Avatar
No comments yet.