Skip to content
Interface language: English
Design / Signal

Reordering cards without dragging: make every move work

Design card reordering for clicks, taps and keyboards, with clear feedback and a reliable distinction between draft and published order.

Article language: English

In a garden at night, a woman examines an illuminated white petal beside a sleeping cat.
In this article

An editor drags the “Directions” card above “Program.” On a large screen, it takes a second. On a phone, the card moves down, the list scrolls up, and a finger covers the place where it should land. By the third attempt, a printed leaflet starts to look appealing. At least its order stays put.

The intention is simple: change the order. An interface can turn it into a task that demands precise hand movements, a good memory, and knowledge of a hidden save rule. Start with what needs to go where and when the new order should take effect. The gesture is just one way to carry out that decision.

Imagine a fictional event website called Przejście. Editors arrange six information cards and publish the page for visitors after approval. The design needs to let them move one card, see the result, and carry on. The same result should be possible on a phone and with a keyboard, without dragging.

What changes when a card moves?

At Przejście, an editor is arranging information on the home page. They are not changing its editorial status. Make that distinction explicit: a similar gesture on a task board could mean something quite different. Moving “Directions” up should not accidentally approve its content or make it public.

Decide whether the order applies to one list, a selected section, or the whole site. An editor might be looking at a filtered list with two items hidden. What does “move to top” mean there: the top of the visible group or before every other item? If the interface cannot make the result clear in a filtered view, you could make moving available only after the editor returns to the full list, and explain why.

Do not combine selection with grabbing, either. A checkbox might prepare items for a batch action, a handle might change their order, and the title might open the editor. When the entire row does all three depending on the smallest movement of a finger, mistakes become part of the daily routine. The scope of multiple selection is a separate question in what “Select all” selects (see the guide to the scope of selection (in Polish)). Here, the editor needs to identify the one card they mean to move.

If an editor has already selected several cards for another task, starting a move on one should not silently move the whole group. The design must make the scope of the action clear. For this panel, we will move one card at a time. Moving several would need its own rules for how the group behaves and how its internal order is preserved.

For a short list, “Move to top,” “Move to bottom,” and a choice of position relative to another card may be useful. Not every project needs all of them. Choose for the actual tasks: moving one place, crossing the whole list, and abandoning a change are different actions worth testing in context.

Watch for similar titles. If two cards are called “Information,” provide a way to tell them apart when choosing a destination, such as their section names. A position number can change during the work. The user should be able to choose a recognizable item, not remember what happened to be in row four a moment ago.

Distinguish a manual order from sorting by title or date. If the view always sorts cards alphabetically, a drag may appear to undo itself moments later. In that mode, explain why manual ordering is unavailable, or let the editor deliberately switch to a custom order. They should know which rule is currently in effect.

The alternative should achieve the same result

In its explanation of WCAG 2.5.7, W3C distinguishes keyboard operation from an alternative that uses a single pointer without dragging. Keyboard access alone does not establish that this criterion is met. Exceptions cover dragging that is essential, and functionality determined by the user agent (such as a browser) and not modified by the content author. This one criterion is not an assessment of the entire site's conformance.

One design for Przejście could put a visible “Change order” button beside each card. The editor then chooses a destination with simple clicks or taps. The same command is available by keyboard. A phone user does not need to connect a keyboard or drag across several screens to do it.

For a short list, buttons that move an item one place may be enough. With dozens of cards, pressing “Up” over and over gets old. Choosing “Before Program” may fit the intention better. Compare the number of decisions and the clarity of the result for both approaches rather than declaring one the permanent winner.

Someone using a screen reader (a tool that reads the structure and content of an interface) should be able to identify both the action and the card it affects. Several buttons announced only as “Move” do not provide that information. The accessible name can include the card title while the visible label stays shorter. Check how both pieces of information are conveyed in the working component.

The state at the edge of a list needs to be clear, too. A card already first cannot move any higher within the same group. Show that this action is unavailable while keeping the other actions available. Do not direct someone to a command that changes nothing and gives no explanation.

Aeneia conceptual photography

If the editor cancels the choice of destination, the existing order should remain clear. Closing the menu should not look like accepting the change. If the interaction has a preview stage, name it and show how to confirm or discard it. That is especially useful on a longer list, where the editor may want to see neighboring cards before deciding.

In a test, use unambiguous commands such as “before” and “after” a named card. After the move, compare the actual neighbors with the user's intention, especially when the item came from earlier in the list. Moving removes it from its old position, so a number selected beforehand may need a different interpretation in the finished order. The user should not have to do that calculation in their head.

Accessibility for a company website (see the article on company website accessibility (in Polish)) covers more than one gesture. For this particular feature, keep one test narrow: move the same card to the same place in different ways and compare the results. The mere presence of an alternative button does not prove that it performs an equivalent operation.

When testing the gesture itself, check ordinary phone scrolling as well. An editor trying to scroll the page should not accidentally rearrange its content. Show where a drag begins and how to cancel it. Decide what happens when the drag ends outside an allowed destination, and make the result visible after the animation ends too.

The editor still has work to do after the move

After changing a card's position, the editor should be able to recognize where it went. If the whole list suddenly jumps, they may lose their place even when the order is correct. Keep the moved item recognizable and show its new neighbors. A visible highlight should help someone find the card, not put on an animation show after every click.

Atlassian's accessibility guidance for dragging covers three parts: triggering an equivalent action, communicating the result, and letting the user continue. Its guidance on results considers the item's name and change of position; for continuation, it addresses keeping or restoring focus. Focus identifies the element a keyboard user is currently working with.

A message for Przejście might say, “Directions moved before Program. Position 2 of 6.” The message needs to match the actual result and reach assistive technology too. Writing it beside a list in a mockup is not enough. The implementation must communicate the information at the right time without sending the user to an unrelated place on the page.

After closing the move menu, the editor should be able to continue working with the same card. If focus returns to the beginning of the entire panel, every subsequent change requires finding the item again. Also test what happens if the card disappears from the current view after moving to another group. In that case, choose deliberately where the person can continue.

If undo is available, name its scope: the last move, the whole unsaved arrangement, or the last save. After several moves, those commands lead to different results. Prepare a short sequence of two moves and test undoing each one. That way the button does not unexpectedly send the editor back to the start of their work.

Website microinteractions (see the article on website microinteractions (in Polish)) can support the transition by indicating movement and the system's response. They should not be the only way the result is conveyed. Someone who does not see the animation, or who reads the interface another way, still needs to recognize the new order and save status.

Moved, saved, and published

At Przejście, the editor first changes a draft. Visitors see the new order only after publication. The interface should make that boundary visible while the editor is working with the list. “Order changed,” without more context, may suggest that the public page has already changed too.

If saving is automatic, show its actual result, including an interrupted connection. If it requires a button, distinguish the arrangement on screen from the saved draft. In either case, decide what happens after a refresh and after reopening the panel. The editor should not discover the next day that a carefully arranged list existed only in an open browser tab.

If a save is rejected, show what state the arrangement is in. Depending on the agreed behavior, you might keep the working arrangement for another attempt or restore the last confirmed state. If the working arrangement remains, show how to retry; if the old one is restored, make it clear that the new order was not saved. A silent return to the old order looks like user error. Leaving the new order in place without an error message looks like success.

For shared work, decide what happens when a second person saves a different order. Design and implementation both have a part to play: a mockup of a warning does not enforce a save rule. The CMS content publication process (see the guide to CMS publication (in Polish)) should say who can change a draft, who approves it, and which state reaches the site.

For acceptance, prepare a short list with similar titles, a full list longer than the screen, and an item at a boundary position. Ask someone to move a specified card before another named card, save, and check it after returning. Research with people who use assistive technology (see the article on research with assistive technology users (in Polish)) can show whether the names, result, and continuation actually form an understandable action.

Start a conversation with Aeneia Design around an editor's task like this one and an agreed publication rule. Then the design does not end with a card that follows the cursor nicely. Acceptance depends on an order the user can deliberately arrange, save, and publish. Check it both on returning to the panel and in the visitor view after publication. Those are separate checks: a draft can be saved correctly while the public page still shows the earlier order.

Aeneia / Aeneia editorial

Editorial article. Source links are included in the text.

About Aeneia

Brands we have worked with

  • L’Oréal
  • Garnier
  • Netflix
  • Carrefour
  • Warner Bros. Discovery
  • Biedronka
  • HBO Max
  • Wolt
  • Żabka
  • COSRX
  • Embassy of China in Poland
  • Mixa
Aeneia / Initium

From knowledge to a decision

Tell us what you want to put in order. We will agree on where to start.

Contact Aeneia

We partner with and use solutions from:

  • Google
  • OpenAI
  • Microsoft
  • Stripe
  • Anthropic
  • Linear