Get AI summaries of any video or article — Sign up free
The case against toasts thumbnail

The case against toasts

Theo - t3․gg·
5 min read

Based on Theo - t3․gg's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

Toasts often fail because confirmation appears far from where the user’s action occurred, forcing users to search for feedback.

Briefing

Toasts are a weak form of feedback because they break a basic UX rule: the place where the user’s action happens should match the place where the confirmation appears. In practice, toasts often show up far from the user’s attention—typically in a corner—so people click something, wait, and then have to hunt for whether anything actually worked. A common example is YouTube’s “Save” flow: clicking a button triggers a modal in the center of the screen, but the confirmation arrives later as a small toast in the bottom-left corner. On a full screen, that mismatch is easy to miss; when the user has scrolled or the UI is visually busy, it can feel like the click did nothing.

The problem gets worse when toasts are delayed and when multiple actions overlap. In the YouTube scenario, the confirmation toast doesn’t appear immediately and there’s no clear loading indicator tied to the action. If the user changes a checkbox inside the modal, they may have to wait several seconds for the previous toast to disappear before the next one shows up. Rapid interactions—hovering, saving to a playlist, removing, adding to another list—can generate a chain of toasts that the user must mentally reconcile. Even if stacking toasts prevents them from being lost, stacking doesn’t fix the core issue: the confirmation still arrives in the wrong location and at the wrong time relative to the user’s focus.

The alternative proposed is straightforward: use inline feedback where the user is already looking, and treat completion as the signal. Instead of a toast, the “Save” interaction should open the menu right next to the button, show a small loading spinner next to the control, and reveal the updated state directly beneath it. After a checkbox toggle, a loading indicator should appear in place, and when it disappears, the user can infer the action completed—no separate toast needed.

Other examples reinforce the same principle. Gmail’s archiving flow removes the email from the list, which already implies success without extra notifications. Superhuman’s email workflow uses a delayed send window, but its toast-based confirmation still limits what users can do next: if they want to inspect the email before it sends, they can’t click the toast to open it—only “instant send” or “undo” are available. Another critique targets redundant confirmations: if a button already includes built-in confirmation, adding a toast is unnecessary.

The transcript also acknowledges a practical reality: toasts are easy to implement and can look good in demos. A library like Sonner makes it especially convenient by allowing promise-based toast states (loading, success, error). But convenience and aesthetics don’t outweigh usability. The speaker argues that relying on toasts “for everything” becomes especially harmful once they start stacking, and that small, localized UX improvements—like reducing confirmations and making bulk actions possible—can materially improve day-to-day satisfaction, even if they seem minor on paper.

Cornell Notes

Toasts often fail because they confirm actions in a different location than where the user clicked, forcing people to search for feedback—especially on busy or scrolled interfaces. Delays and lack of action-tied loading indicators make the mismatch worse, and overlapping interactions can produce multiple toasts that users must interpret. The recommended fix is inline, local feedback: show loading next to the control, update the UI where the user is working, and treat the disappearance of a local spinner as completion. Gmail’s archiving and a redesigned “Save” flow illustrate how removing or updating content can serve as confirmation without a toast. Even when toast libraries make implementation easy (e.g., promise-driven states), usability still suffers when notifications become the default feedback mechanism.

Why does the “locality” of action matter more than the existence of a toast?

The core complaint is that toasts separate the user’s action from the confirmation. When a user clicks a control, attention is focused on that control and nearby UI. If the confirmation appears in a distant corner (like YouTube’s bottom-left toast after a right-side click), users may not notice it—especially on small screens, when the page is scrolled, or when the interface is visually dense. The result is uncertainty: users wonder whether the click worked and then only later spot the toast.

What specific failure modes show up in the YouTube save interaction?

The transcript highlights several: (1) the toast appears after a delay, (2) there’s no loading indicator tied to the action, (3) changing a checkbox in the modal can require waiting multiple seconds for the previous toast to disappear before the next one appears, and (4) rapid sequences (add/remove/close while toasts are still pending) can force users to wait to know which action actually committed. Stacking helps visibility but doesn’t solve the location/timing mismatch.

How does the proposed redesign eliminate the need for toasts?

Instead of showing a separate toast, the redesign keeps feedback near the user’s action. Clicking “Add” opens the menu immediately under the button. A small spinner appears next to the relevant control while work is in progress. The playlists are displayed directly beneath the button rather than inside a modal, and after checkbox toggles, a local loading indicator appears; when it disappears, completion is implied. The UI state itself becomes the confirmation.

Which examples support the idea that UI changes can replace toast notifications?

Gmail’s archiving flow is cited: archiving removes the email from the list, which already communicates success without a toast. The transcript also notes that if a button already provides confirmation (like a “Poned”/action button with built-in acknowledgment), adding a toast is redundant. In both cases, the interface change communicates the outcome where the user is already looking.

Why does implementation convenience (e.g., toast libraries) not fully justify toast-heavy UX?

Toast libraries like Sonner make it easy to attach loading/success/error states to promises, which is convenient for developers and looks good in tutorials. But the transcript argues that convenience doesn’t fix the fundamental UX problem: toasts still land away from the user’s attention and can pile up during rapid interactions. Even a “pretty stack” doesn’t address the mismatch between where the action happens and where the confirmation appears.

What’s the critique of Superhuman’s toast-based workflow?

Superhuman delays sending for 5–10 seconds and offers “instant send” or waiting, which is a useful feature. But when the toast appears, users can’t click it to inspect the email during the delay window. The only options are instant send or undo, so the toast confirmation doesn’t support the next likely user goal: checking the message before it goes out.

Review Questions

  1. What UX principle is violated when confirmations appear in a screen corner rather than near the clicked control?
  2. List two concrete reasons delayed or stacked toasts can make users uncertain about whether an action succeeded.
  3. Describe how inline loading indicators and immediate UI updates can replace toast notifications in a “save/add to playlist” flow.

Key Points

  1. 1

    Toasts often fail because confirmation appears far from where the user’s action occurred, forcing users to search for feedback.

  2. 2

    Delayed toast notifications without action-tied loading indicators increase uncertainty, especially when users interact with modals or controls repeatedly.

  3. 3

    Overlapping actions can create multiple toasts; stacking improves visibility but doesn’t fix the locality and timing mismatch.

  4. 4

    Inline feedback works better: show loading next to the control, update state near the user’s focus, and treat the end of loading as completion.

  5. 5

    UI changes can serve as confirmation without extra notifications, as seen in Gmail’s archiving behavior.

  6. 6

    Toast libraries (like Sonner) make implementation easy via promise-driven states, but usability still suffers when toasts become the default feedback mechanism.

  7. 7

    Reducing redundant confirmations and enabling faster, localized workflows can produce outsized user satisfaction gains even when changes seem “small.”

Highlights

The central UX critique: action locality and information locality don’t match when confirmations show up in distant corners.
YouTube’s save flow is used as a case study for delayed toasts, missing loading cues, and multi-second waits between successive confirmations.
A better pattern replaces toasts with inline spinners and immediate UI updates beneath the button.
Gmail’s archiving demonstrates how removing content from a list can communicate success without a toast.
Even when toast libraries make demos easy, they don’t solve the core feedback-location problem.

Topics

  • Toast UX
  • Inline Feedback
  • Action Locality
  • Promise-Based Toasts
  • Confirmation Design