Skip to content

Bulk edit: UX improvements notes #84391

Open

Description

@kellychoffman

While the UI itself is cleaner and more modern, the current application of data view and data forms for bulk editing is a bit of a ux regression from wp-admin and general design best practices. Meaning, when the user clicks Quick Edit, we show them a non editable view. They then have to click or hover on each individual item to actually do any "quick" editing: (This is not quick!)

Image

Compare this to wp-admin, where clicking on Bulk Edit, brings up all the items you are able to edit, in edit mode:

Image

It's a subtle difference, but I think we need to be much more intentional with actions: if someone wants to bulk/quick edit, we should make all the edit action appear on the page without having to do anything further to see or engage this action. To do this properly, I think we might also have to rethink the layout. Is a narrow column sidebar the best? Is it useful to see the page list behind it while doing this action?

wp-admin also includes an additional feature of being able to quickly add/remove the items you are editing. You have to back out of the edit view in order to adjust what pages or items you are editing. It also seems to surface more fields that you can edit.

@verofasulo thoughts?

Activity

  1. verofasulo commented on Oct 12, 2026

    @verofasulo
    Contributor

    So many good points here!

    Meaning, when the user clicks Quick Edit, we show them a non editable view. They then have to click or hover on each individual item to actually do any "quick" editing: (This is not quick!)

    I agree, and we've had several discussions about this. From my understanding (but @jameskoster @jasmussen please correct me if I'm wrong), the main reason for choosing a summary view over inline editing was to maintain consistency with the editor. I agree that this doesn't work well in the context of the admin, where the jobs and workflows are quite different and call for a different UX.

    I explored inline editing for Products and other surfaces. Depending on the use case, we could either group fields into sections or keep them flat. For Products, given the number of editable fields, I went with the former.

    Image Image

     

    wp-admin also includes an additional feature of being able to quickly add/remove the items you are editing. You have to back out of the edit view in order to adjust what pages or items you are editing.

    I explored this a while ago, too, looking at ways to show the selected items directly in the editing panel. The most straightforward approach was to use pills/badges, with one chip for each selected item:

    Image

    That said, I'm not entirely convinced we need this. I think the problem is partly a consequence of the current layout: when we open the modal, the table and its selection are hidden. With a side panel instead, the table would remain visible while editing, making it much easier to understand what you've selected and answer the question, "What exactly am I about to change?". It could also allow users to adjust their selection without having to close the editing interface.
    I'm personally not a big fan of the modal approach. I can't remember why we moved away from the side panel (was it for accessibility reasons?), but I think the previous UX worked better. I also think a wider side panel could work well here. The current 320px is quite narrow, but we used 450px in some of our PoCs and explorations, and that gave us more room to work with.

    Image
  2. jameskoster commented on Oct 12, 2026

    @jameskoster
    Contributor

    I've been saying for a very long time that we should use the regular DataForm layout (rather than the current panel layout) for the majority of quick edit fields. Let's try that!


    A dialog pattern is employed because quick edit is a modal flow; you click edit, focus moves to the UI, then you apply or discard your changes. It also simplifies the small-screen implementation.

    But nothing is written in stone! A side panel can work in theory, it just poses a lot of UX questions that are a bit tricky to answer. Questions that the modal approach inherently handles for us. For instance;

    • What happens to unsaved changes when you update the selection, are they kept or discarded? I worry it's unclear either way.
    • Similarly, if you update a field for the current selection, then add an item to the selection; does it inherit the changes you already applied, or not? Again there's no clear expectation here...
    • If you already made a selection and opened the panel, what happens if you click 'Quick edit' on another row outside (or inside) the selection—does it get added/removed to/from the current selection, or replace it entirely? Once again it's unclear what the expectation would be here.
    • What happens to unsaved changes? Is saving handled entirely by the global save button, or locally within the panel? If saving is local then what happens if you close the panel without saving?
    • How does all of this work on mobile, is it the same? If so how do we fit both the list and the panel on the screen at once? If it's different then are we adding too much complexity?
    • How would it work outside of the site editor environment (imagine for a second that something like Extensible Site Editor: explore direct Appearance entry points with the wp-admin sidebar #83364 comes to pass)?

    I think we need to find good design solutions to all these questions (and likely more) before revisiting the a panel approach.

  3. added
    [Feature] DataViewsWork surrounding upgrading and evolving views in the site editor and beyond
    on Oct 13, 2026
  4. keoshi commented on Oct 16, 2026

    @keoshi
    Contributor

    This is a really thoughtful conversation, and I'm happy to see so many good points come up.

    For what it's worth, my own explorations in this area also use the regular DataForm layout, so I'm glad to see it suggested as the more natural (and immediate) editing option.

    My first instinct was to agree with you, @verofasulo, that a side panel makes for a much better editing surface. But keeping the list visible and editable doesn't guarantee you can see every selected item either. Once the selection runs past the fold, or gets split across pages, you're back to guessing what you're about to change. Maybe the real gap is that the panel should do a much better job of summarizing which items are being edited, whatever container it ends up in. To be fair, the current wp-admin interface isn't great at this either.

    @jameskoster raises a lot of great points, especially around unsaved changes and being careful with data users have already entered. Those questions get much harder once the selection can change while the form is open. On top of that, there's the question of splitting the screen between the list and the panel. It's a smaller concern in comparison, but can't be ignored.

    Either way, I love seeing a full DataForm layout in the explorations above, and I'm excited about where this could go.

  5. jameskoster commented on Oct 27, 2026

    @jameskoster
    Contributor

    @verofasulo I opened #85775 to begin exploring inline fields in Quick Edit.

  6. verofasulo commented on Oct 28, 2026

    @verofasulo
    Contributor

    think we need to find good design solutions to all these questions (and likely more) before revisiting the a panel approach.

    Thanks, @jameskoster! These are great questions. I've been exploring how we could address them in a prototype: https://dataviews-panel-vs-drawer.space.fast/?screen=posts&editView=panel

    posts-panel-hr.mp4

    The principle I've landed on is that the panel follows the same editing model as the modal, just without the backdrop. Changes are still explicit (Save / Cancel in the panel), tied to a specific selection, and never saved or discarded silently.

    I also looked at how other products handle similar interactions. Google, GitHub, Atlassian, and others use panels that keep the background visible and interactive, but they take different approaches to unsaved changes. For example, GitHub asks for confirmation before leaving an edit with unsaved changes, while Google Drive discards them without a prompt. I'd lean toward GitHub's approach here, since I think we should make these actions as explicit as possible.

    To answer your questions:

    1. What happens to unsaved changes when the selection changes?
    They're neither saved nor discarded automatically. If there are unsaved changes, changing the selection (checking or unchecking a row, selecting all, switching tabs, or leaving the screen) triggers a confirmation: "Save changes before leaving?", with options to save or discard.

    2. Do newly selected items inherit changes already made?
    No. Changes apply only to the items that were selected when editing started. Adding another item would first require saving or discarding any unsaved changes.

    3. What happens when someone clicks "Quick edit" on another row while a selection exists?
    It replaces the current selection with that row alone. If there are unsaved changes, the same confirmation appears first.

    4. Should saving be global or local to the panel?
    In wp-admin, we don't have a global save mechanism, so I'd keep Save / Cancel in the panel footer, just like in the modal.
    In the editor, I think both approaches are feasible, and I don't have a strong preference. I generally find contextual saving easier to understand, since it reduces the mental effort of keeping track of unsaved changes. That said, I wouldn't optimize this pattern around the Pages experience in the site editor, since it would be adopted much more broadly across wp-admin.

    5. What happens on mobile?
    The panel stays a panel. Below the admin’s mobile breakpoint it takes the full width of the content area. Same form, same Save / Cancel, same unsaved-changes prompt.

    6. How can users see everything they've selected?
    Kelly and Filipe raised this earlier in the thread. Once the selection extends beyond the visible rows or across pages, it's difficult to tell exactly what you're about to change. I've explored adding a "Show only selected" switch to the bulk actions bar. It appears whenever at least one item is selected and can be toggled at any time.

    • On: The table shows only selected items, including those from other pages. The bar updates to something like "Showing 16 selected".
    • Unchecking an item: It immediately disappears from the filtered list, so what you see always matches what you're about to edit.
    • Off: The full list returns, with the existing selection preserved, so you can continue selecting items.

    This is similar to Shopify's approach. It would need some testing, but I think it could work particularly well for dense tables.


    Also, if we're aiming for a common pattern across products, I think the panel might be the more flexible option, since it also works well for read-only previews.

    Jetpack already uses this pattern in Forms and Subscribers, and we're exploring something similar in WooPayments. Stripe also follows a similar approach. In these cases, users aren't editing anything. They're simply previewing information and moving between items without constantly navigating between the table and individual detail pages.
    Here's an example using the WooPayments payouts table: https://dataviews-panel-vs-drawer.space.fast/. Click "Preview" on a row, then use the arrows to navigate between payouts.

    payouts-preview.mp4

    One small detail I also like is that the panel can be resized, giving users more control over how much space they need.


    For comparison, I've included the same interactions using a drawer instead:

    payouts-drawer.mp4
    posts-drawer.mp4

    cc @jasmussen @oandregal @ntsekouras @annezazu @simison @retrofox

  7. jameskoster commented on Oct 29, 2026

    @jameskoster
    Contributor

    Thanks for exploring this further! Some thoughts:

    triggers a confirmation: "Save changes before leaving?", with options to save or discard.
    Adding another item would first require saving or discarding any unsaved changes.
    the same confirmation appears first.

    So far as I can see, at this point we're effectively recreating dialog mechanics, but with additional interaction complexity. Every change to the selection potentially interrupts the workflow with another confirmation. The dialog already gives us a clear boundary around the editing operation, with explicit Save and Cancel actions.

    I also worry this somewhat undermines the main advantage of the panel approach: being able to interact with the list while editing. If changing the selection requires resolving the current edit first, how much are we actually gaining by keeping the list interactive? We're effectively recreating a modal workflow with different presentation, but without the interaction boundaries and focus management that a modal dialog provides. That seems to introduce additional complexity, particularly for keyboard and screen reader users.

    The panel stays a panel. Below the admin’s mobile breakpoint it takes the full width of the content area.

    Doesn't this mean there's no way to manipulate the selection while the panel is open on mobile? If so, we'd effectively have the same interaction as a dialog, just with different presentation.

    Also, if we're aiming for a common pattern across products, I think the panel might be the more flexible option, since it also works well for read-only previews.

    I think both patterns are perfectly viable, and we don't necessarily need one approach to cover every workflow. It's more about choosing the right pattern for the interaction. Read-only previews are a great example of where a non-modal panel makes sense: users can freely browse between records without committing or discarding changes. Bulk editing is a different kind of interaction, with a defined selection, unsaved state, and an explicit completion step.

    We already use panels extensively in the Editor, so I don't think there's any philosophical objection to the pattern itself. I remain unconvinced that a panel is better suited to this particular workflow.

    I mostly keep coming back to this question: Is modifying the selection while editing genuinely an important user workflow, or are we introducing a considerable amount of complexity to accommodate something people rarely need? My assumption is that for bulk editing folks make their selection then edit in a self-contained flow. Modifying the selection while editing just doesn't seem very useful to me, especially with all these interruptions. Maybe if there was always a global save action it would be more defensible, but that isn't always a given as your prototype demonstrates.

  8. verofasulo commented on Oct 29, 2026

    @verofasulo
    Contributor

    I think both patterns are perfectly viable, and we don't necessarily need one approach to cover every workflow. It's more about choosing the right pattern for the interaction. Read-only previews are a great example of where a non-modal panel makes sense: users can freely browse between records without committing or discarding changes. Bulk editing is a different kind of interaction, with a defined selection, unsaved state, and an explicit completion step.

    Yeah, I agree that different jobs might call for different interaction patterns. We could have a contextual view for anything that needs to stay connected to the current workflow and provide additional information, and a more focused view for tasks that require editing and an explicit completion step.

    What's still a bit unclear to me is how this is currently handled in the Site Editor. If I make changes in the Pages quick-edit drawer and then click outside, I'm taken straight back to the list, with my changes automatically discarded. There's no warning about unsaved changes, no global Save, and no explicit completion step. Was that intentional?

    Site.editor.pages.quick.edit.mov
  9. jameskoster commented on Oct 30, 2026

    @jameskoster
    Contributor

    Was that intentional?

    Good question. I don't recall that being discussed in detail. I suspect it's just the default behaviour of the componentry. It seems reasonable to ask the user before discarding unsaved edits though. Alternatively we could remove the close button and ignore clicks outside the dialog. That way the user needs to intentionally interact with either the Cancel or Save button to conclude the task.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    [Feature] DataViewsWork surrounding upgrading and evolving views in the site editor and beyond

    Type

    No type

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions