AI disclosure: Drafted with AI assistance for Apiary. The equipment library, sample submissions, and test traces are fictional; they are not reports of live accessibility testing.
At a fictional neighborhood equipment library, visitors go through a three-page form to ask about borrowing a folding workbench. They pick equipment, suggest pickup arrangements, then review. A visitor reaches the last page and submits. By then, the pickup window they chose has been taken. The app knows that the answer is no longer valid. What the visitor sees under Submit is simply “Please review your information.” Nothing identifies the affected answer, and browser Back can bring up a stale view that still shows the old time. On a phone, the generic error may be out of sight by the time the browser stops moving. A sighted mouse user might manage by poking around; someone using a keyboard or a screen reader would need an especially good memory for the page they just left.
The mistake is to treat validation as only a decision at the field or database. The app also has to tell a person what happened and give them a route back to a usable state. When the bad answer is not on the current page, that route crosses both a navigation boundary and a state boundary. You have to decide which page owns the fix, what valid information follows the person, and where the keyboard will land. A well-written sentence is not sufficient if its link goes nowhere. A good link is not sufficient if using it silently abandons the draft.
Map the step that can actually fix each error
Start with three columns on paper: what can go wrong, where the visitor can resolve it, and what should survive while they do. In the equipment example, a missing number of workbenches belongs to Equipment. A pickup window that no longer exists belongs to Pickup. A failure to reach the reservation service is not an error in either answer by itself. A service interruption belongs on the current screen, where the visitor can retry or learn what other channels are available. That last distinction prevents the app from asking people to rewrite correctly entered information just to get another attempt.
Give each class of error a stable internal identifier before arguing about exact wording. For example, pickup.window.no_longer_available should not be deduced by searching an English string for the word “unavailable.” A French translation can change without breaking the destination. The UI maps the identifier to a step and a field or group, then separately supplies a localized title and explanatory message. If the back end can return a new error code before the front end recognizes it, keep a safe generic page-level fallback with a way to try again or get support. Do not lead someone to a field you only suspect is responsible.
A cross-field dependency is different from a missing field. If the library needs a larger vehicle for two workbenches, the visitor may prefer to keep two and change transport, or keep their original transport and request one. The interface should explain the relationship and offer both paths if both really work. A useful formulation is “Two workbenches must be collected separately with that pickup option. Choose another option or change the quantity.” If the application only puts an “invalid quantity” label beside a valid number, it makes the wrong correction look mandatory. If the answer is resolved by staff and cannot be corrected in this form, say that instead of offering a fake link.
The W3C multi-page forms tutorial describes communicating progress with the page title and main heading. That's more than orientation in the success case. After an error link moves the visitor back, a clear destination like “Pickup arrangements, step 2 of 3” establishes that the navigation worked. If an edit path jumps directly from Review to Pickup and then back, describe it as editing Pickup so the visitor does not think the whole process restarted. Keep progress labels truthful even if an optional step appears only for certain answers.
Treat the destination as a product decision, not a line of translated copy
An error normally belongs to the place where the person can act. A message can originate on a Review screen and still point to the source question. It can also originate from a specific field without the correct destination being that field: if the requested pickup branch closes permanently, the person may have to change their selected location before any new window can make sense. The app needs a small map from recognized causes to workable actions. Direction is a decision made by the interface, not a natural consequence of which service first noticed a problem.
Write an action contract with a useful landing state. “Change location” should open the location step with the last entered preference identifiable where appropriate, describe why the old choice can't be used, and return to the review path the person came from. A link that goes to the general branch directory without the form in progress may be an informational link, but it is not a repair action. If staff really are the only ones who can resolve it, don't impersonate a form edit. Provide the appropriate route and say what can happen to the draft meanwhile.
Occasionally two prerequisites form an ordered choice. A selected equipment size may depend on membership level, which is read from a record the visitor cannot directly change. If there's a legitimate option to choose a different size, offer it. If a membership error must be sorted with staff first, explain that without asking the person to type their existing membership value again. Test both situations with realistic outcomes. The objective is a usable next decision, not the maximum number of errors conveniently attached to currently rendered controls.
Build translation review into that map. A summary line may start with a short verb, while an inline explanation supplies the detail. Both still need to name the same answer and expose the same practical remedy. In a long translation the summary action should not become a wall of prose that makes scanning all fixes impossible. Conversely, a short label like “Update” repeated for three different failing sections gives little information in an assistive technology link list. Include the distinctive answer or section in the link's accessible name. Resist treating design constraints as a reason to give everyone the same unhelpful affordance.
Make the summary, inline error, and focus agree
A good error summary gives an overview once and the field gives the local context when a visitor arrives. Mechanically, the two are easiest to keep in sync when both derive from the same validated error record. In the fictional form, the summary might have one action named “Choose an available pickup window.” On the Pickup screen the matching inline message can explain what happened, alongside the radio group and its choices. If the wording diverges so far that the summary says “Select a day” while the field says “Confirm a branch,” visitors cannot tell whether the same problem was fixed. Choose words that name the answer, describe the issue, and avoid demanding action unrelated to the failed rule.
The GOV.UK Design System error summary guidance provides one concrete pattern: a summary with links that take people to the answers, paired with errors beside those answers. The pattern is not simply a red box. It works by offering a useful focus target and using the same meaningful error copy to connect the whole page with the local form control. Your implementation can use different styles. The functional questions are whether a keyboard user can reach and use the links, whether the destination is exposed with a useful accessible name, and whether moving there makes the local context available.
For a server-rendered step, the error response can reload the page with the summary at the beginning of the main content and a title identifying the failure. If you then move focus to the summary, do it once, intentionally, rather than on every rerender. For a single-page application, wait until the new DOM is present, move focus when transitioning to the error state, and ensure the next Tab takes the visitor somewhere sensible. If the inline validation message changes as a person types, that is not by itself a reason to seize focus. Decide how the user will encounter the updated message when they choose to continue. The same element does not have to serve as both a constantly announcing status region and the destination after every submit.
An error beside a text field can be programmatically associated with that field in the same way a hint can be associated. If you use aria-describedby, include the existing hint identifier when adding the error identifier rather than replacing the hint accidentally. Reserve an invalid state for an actual invalid answer. A choice group needs a label and problem explanation that make sense as a group; dumping the identical error on all five options can make navigation needlessly repetitive. The W3C form labeling and validation guidance explains why visual cues alone do not identify the invalid value. A bold border can remain a design choice, but the words describing the problem are part of the interface, not explanatory fine print.
If an error link jumps inside the current step, do not assume that native fragment scrolling and your app's focus behavior are equivalent. Check which element receives keyboard focus, which comes next in tab order, and whether a sticky header obscures the target. For cross-step links, route to a resilient step URL where appropriate, use an app identifier rather than exposing draft content in the URL, and restore only the information that visitor is entitled to access. Test a link opening in the same tab and ordinary browser Back. A repair flow that only works when the visitor clicks it in the exact scenario the developer imagined will be hard to diagnose later.
Verify what happened to focus at four different boundaries
A failed submission on the same step, a cross-step error landing, a manual return to Review, and a normal browser Back are not the same action. Sketch which element should receive ordinary focus in each. A failed submission may land at a meaningful summary. A cross-step edit may open a new document with an explanatory heading or intentionally take the person to a specified repair target. A return to Review can start where a visitor would expect to review the changed proposal. A browser history traversal should not necessarily replay the first summary announcement merely because the application rerendered.
Watch focus move and watch the scroll position separately. A component can cause the field to enter the viewport and still leave keyboard focus on the link some distance away. Conversely, setting focus can scroll behind a sticky header if the template hasn't taken the actual geometry into account. In test notes record the focused object, visible local explanation, and which control is reached on the next forward navigation. That separates the functional check from how a particular browser happened to animate the transition. Neither a screenshot nor a DOM assertion alone shows the whole experience.
A group needs special care. If no radios are available because the underlying list is empty, there is no appropriate option to focus. Given that state, the error path might land on a heading explaining the missing choices and an action to change another condition. Avoid an invisible phantom radio added solely to satisfy a test selector. If actual choices exist, reach the group in the normal interaction and verify that its label and relevant error reach the visitor. Test the current case in a supported browser and assistive-technology combination rather than presenting one event listener as universal proof.
Keep status announcements event-based. A retry may say the request is being checked, then present a distinct result. Don't use a live region for every render that happens while returning valid fields, and don't duplicate a summary via two simultaneous announcement mechanisms without checking the actual outcome. The viewer may hear a repeated first sentence and miss the important location. A concise useful state such as “Pickup options updated” is different from the focus event on a repair target. Test the two separately, including the case where only status changes while the person is typing.
Decide what to preserve and what to clear
An invalid response shouldn't make a visitor repeat unrelated work. If changing the pickup time does not change the number of requested tools, retain the number. If switching library branches changes which time windows exist, the old window cannot be treated as selected; explain why it disappeared. This approach sounds simple until your changes are encoded as page loads, client-side transitions, and server writes made by different teams. Make a dependency list before adding a convenience feature like “restore all previous answers.” The list should show which answers become tentative, which remain valid, and which are removed for privacy or because their meaning no longer holds.
For the example, an edit to branch invalidates the pickup window and any accessibility notes attached to that individual appointment—not necessarily the user's general preference about how staff should contact them. Those are different kinds of facts. Staff notes can also be sensitive; do not automatically put them in browser history state, a URL, logs, or analytics just so it is easy to reconstruct the draft. If the form retains a draft for a session, document where it resides, when retention ends, and which interaction clears it. The visitor's notion of “Back without losing my work” shouldn't quietly become “Anyone using this public kiosk can reopen my answers tomorrow.”
One practical acceptance rule: if Review reports one stale answer, the repair page presents the valid subset, the visitor makes the smallest necessary edit, and Review reappears with a clear before-versus-now explanation where useful. Avoid automatically retrying final submission as soon as the visitor supplies a replacement choice. They are making a different arrangement and should have a chance to review it. The exact same principle explains why it is unhelpful to quietly choose the next available time: it may be convenient for the tool library and impossible for the visitor.
Sometimes the visitor wants to return to Review with no change, perhaps to check the other proposed time with somebody. Give a route back if it is useful, but continue to mark the original submission as unresolved. That can be a readable heading or a description near the review row, not only a disabled button. If no other option remains, do not leave the user stranded in a compulsory question with an empty list. Distinguish “These times changed while you were here” from “This service currently has no pickup times,” even if the API uses one shared resource to represent both facts.
Keep a dependency map for choices and for the evidence that validated them
A preserved answer can have changed meaning even when its characters are unchanged. Suppose the user entered two book stands and selected pickup at Branch A. A later move to Branch B may leave the count meaningful while invalidating the prior appointment. If a local internal note was written for staff at A, blindly attaching it to B can also expose information or create an instruction the visitor did not intend to send to the new location. List those relationships before deciding which fields survive an edit. Clearing an obsolete selection is not the same as clearing every choice on its step.
Make tentative values visible where they can help but do not submit them as confirmed. Some designs can show “You originally selected Thursday at four. That choice is no longer available.” The original value explains why a field appears empty, although it shouldn't remain checked. Decide whether that detail should be shown at all for the information and audience in question. Use approved privacy and retention policy; do not place sensitive contents in URLs or logs. Under that distinction, a replayed Review page can be helpful without becoming an unauthorized snapshot of a past session.
Cross-step editing is easiest to reason about if the validated object has a coherent revision or equivalent mechanism to tell what the service actually checked. Suppose the app receives an availability answer for the former branch after the visitor has selected a new branch. It cannot assume that answer clears the new selection. Attach validation to the relevant proposed choices, not just the name of the field. Use a synthetic delayed response in a safe fixture and check that it doesn't restore the old appointment. There is no need to model every network implementation to make this editorial distinction concrete.
A genuine expiry should get its own message and supported recovery path. Losing an entire draft after a timeout is not proof that every value is invalid. Depending on the service, the person may need to restart, resume securely, or contact staff. Do not promise restoration if none exists. An accurate short statement can say that the previous answers are no longer available and identify what they need to start over. Test that beginning again does not leave people with a stale error summary linked to fields from the former submission. Old validation notes should not rewrite new work.
Work a whole failure through, not just a screenshot
Here is a synthetic test. Start on Equipment, choose one workbench, and continue to Pickup. Choose Thursday at 4 p.m., then proceed to Review. For the fixture, remove Thursday 4 p.m. from the test data without changing the draft. Submit. Expected result: the request is not recorded as complete; Review shows exactly which answer failed; a keyboard user encounters that feedback without hunting through the page; the link goes to Pickup; and the field group explains why its choices changed. Wednesday 2 p.m. and Friday 10 a.m. are offered. Pick Friday, review the updated entry, and submit. Only then does the form report success. This is a product-level test trace, not a claim that a specific framework, browser, or screen reader has passed.
Now keep the same steps but change one variable. Build a fixture where the availability service returns an error instead of actually removing a slot. The expected outcome is not “Choose another time.” The application could not determine whether the choice was valid. Its feedback should say the request could not be completed, describe what the visitor can try, and keep the draft if safe to do so. In another fixture the final response is lost after the reservation was actually recorded. In that case it is dangerous to announce “No request was made” based solely on the missing response. Make the distinction explicit in product language and give people a way to look up what happened without generating another ambiguous request.
Change another variable by letting a stakeholder turn on native browser validation for just one upstream input. Browser validation can work well for some forms, but the team needs to test the combined behavior. If one engine does not execute your application's submit handler because native validation stopped it first, the focus, discussion of the problem, and repair route may be different from the default design. An acceptance criterion that covers only custom validation is not enough to describe what the real form does with mixed constraints. Write down which layer is meant to issue feedback at which moment, and make all layers accept the same values.
You can exercise related failures by deliberately opening two draft tabs in a test environment, submitting with delayed JavaScript, or navigating with browser Back between review and correction. None of those requires test participants to enter real information. Use distinct synthetic answers so a lost or incorrectly restored value is obvious. “A” on every input is harder to reason about than a workbench count of two, a branch labeled East, and a pickup preference that changes once. If your draft persists through a long delay, test what happens when the session expires during the repair step. An understandable loss message isn't as good as preserving everything safely, but it is better than allowing a visitor to believe an expired edit is still saved.
A different failure: an optional step disappears after a legitimate edit
Imagine a neighborhood arts center accepting requests for a meeting room. The fictional form asks for a room, then an optional equipment question when projection is requested, then scheduling and Review. The applicant initially requests projection and selects a particular equipment arrangement. On Review they change to a room without projection to gain a suitable date. The equipment step should no longer be part of the route. A flawed app still mentions an unresolved projector question on Review and its link opens a page with no active control. The program accurately remembered a validation failure, but no longer understands the choice to which it belonged.
Work through the intended state rather than favoring either hiding or keeping all answers. The supported result is room changed, date rechecked, projector choice no longer part of this request. The form can mention that the projector arrangement was removed with the room change and avoid embedding it in the final request. Don't report that the person answered the projector question merely because the old value still exists in a test fixture. Conversely if the applicant returns to one of the earlier rooms, explain which supported arrangement must be confirmed again. Presenting a default as if already chosen is not a neutral shortcut.
The human test has several independent outcomes. The current step count reflects the real path. A summary link points only to an editable, relevant answer. Review describes the submitted configuration without showing stale implied extras. Back from a visible step respects a valid route even if its predecessor used to be different. One schedule may support a direct route to a particular step; another may bring the user back through an ordinary starting screen. Choose the policy before QA. The recovery problem is not fixed merely by removing “step 2 of 4” from the header.
Now introduce a service interruption during the edit. If no updated availability can be obtained, keep the last confirmed record separate from the new choice in progress. A preview of the new room is not a confirmed reservation. Do not restore old availability with a cheerful success message, and don't create a new generic error link pointing at the removed projector field. The right result may be a retry or pause on the review or scheduling surface with a description of what is unknown. If a customer support route exists, point to it without sharing details beyond the service's approved practice. By testing the failure after a genuine branch change, the team learns whether the error model describes present choices rather than just storing a queue of strings.
Test how someone recovers, not how often they fail
A form that catches more mistakes may temporarily show more errors. An error count alone does not tell you whether navigation has improved. Useful signals include whether the visitor gets to the repair step, whether the same issue comes back on their next attempt, whether unrelated data was reentered, and whether review and submit remain distinct. Those signals must be collected with proportionate privacy controls: coarse error classes and step identifiers are often enough. You do not need raw addresses or the exact values that users typed to learn that Pickup is failing repeatedly. Also watch for aggregate metrics obscuring a broken path: a high completion rate can coexist with a blocked keyboard route if most other people use the mouse.
Manual testing still matters. Start from an unfilled form and operate with a keyboard. Validate one visible field and then repeat from Review when the problem is in an earlier step. At each point name your current target, where focus went, what entered values survived, and what you expect the next key to do. Then use a screen reader with a browser your team supports. Look for information that is available only after exploring several unrelated controls, announcements that interrupt each other, and link text that makes no sense outside the summary. Check a narrow viewport and zoom separately. Automated checks are useful for invalid markup, missing associations, and regression coverage. They do not tell your team whether the story told by a sequence of messages is accurate and comprehensible.
A release checklist can be short when the product decision is clear. Know which screen owns each correction; match localized summaries to stable destinations; preserve unrelated answers without exposing them; keep review after meaningful change; and test the actual failure route with keyboard and assistive technology. If you can perform only one first improvement, choose the highest-volume discouraging error and make its path complete. Do not start by adding decoration to every invalid field. Start by making it possible for a visitor to know what happened, make the smallest useful correction, and finish without paying for the software's mistake in repeated work.
Make a regression test small enough to run whenever the form changes
Start with the cases that stress independent behavior. One fixture starts on Review and has an invalid earlier answer. A second has a service interruption rather than an input fault. A third changes an answer which removes another step. A fourth leaves the draft in a known supported expired state. The test notes should give an expected start state, concrete action sequence, destinations, preserved facts, verification and what was intentionally not tested. A pass means someone can complete the recovery as described, not just see that every styled component mounted. Write the smallest complete recovery in ordinary language so the next tester needn’t infer the expected route.
Simulate no guessing. Hand an internal reviewer a link into a fictional failed session and the error explanation, without briefing them on the original branch behind the scenes. Ask what they believe failed, where they can fix it, and which answers appear safe to retain. If the reviewer thinks “Submit failed” means none of their inputs were saved, but the draft visibly remains available, refine the language. If they think the appointment was definitely never created after an uncertain response, examine how the service communicates evidence and how to check for a confirmed result. User-facing verbs need as much review as color and placement.
For an engineering regression, separate visible copy, document position, observed focus, next keyboard step, and persistence after repair. Each is one measurable result, and each can fail on its own. A user who sees the right branch but lands outside the form after Back is still blocked. If focus is correct but the prior branch's state reappears on review, that isn't an accessibility pass for the overall task. Use a representative browser and assistive technology pairing with manual observation instead of treating an automated accessibility score as proof of successful repair.
Preserve failed checks narrowly enough to take action. “After the optional step remained absent, the summary's projector link resolved to no relevant control” identifies a decision. “The browser is broken” names a platform without proving causation. Record the exact fixture and intended state so a maintainer can retest the affected transition. If the same interface handles other form types, don't claim they're all fixed because one test changed color. Add scope only when you have evidence for it.
Explain success without erasing the repair history
When the visitor gets to the final confirmation, show which proposal was actually accepted. That summary should reflect the corrected time or changed branch, not the earlier outcome left behind in a draft. If the form sent a request rather than securing a booking, use the corresponding word. If verification is still pending, say so and describe the next known contact or status rather than providing a false receipt. People rely on these distinctions when arranging transport and deciding whether to repeat an action.
The internal correction history has a smaller purpose. It may tell support that one submission hit a stale time and the user returned to repair it. It does not require replaying personal answers in a diagnostic record or accumulating unrelated information about the visit. Retain only the cleared facts you are authorized to keep. This also matters during an accessibility audit: share a synthetic trace of the route and focus problem instead of a real applicant's case when the reproduction doesn't need their data.
Decide what the visitor can prove when they resume from another surface
A visitor may reach a failed form from an email reminder, an ordinary bookmark, or a second tab. That doesn't imply that the app can recover all prior draft state from the address. Write down what a route can display with no recognized draft and how the person understands it. The next step might be starting again, signing into an already supported account, or resuming through an approved workflow. A short understandable landing screen is more useful than displaying a stale summary whose repair links refer to an unrelated validation state. The receipt should say what the particular test covered, not imply that all cross-device restoration was verified.
If a draft is scoped to one intended visitor, an ordinary URL may still identify a particular public step without containing private answers. The service determines whether a draft is authorized and current. Avoid confusing visible route identity with trusted persisted data. In an approved synthetic environment, open a plain step link without a draft and confirm you get the supported empty or recovery state, not a misleading late-stage summary. Then repeat with a verified authorized fixture. The expected outcomes should differ where the service contract requires it. That comparison is about what the app offers legitimately, not a reason to pass local data around by unsafe channels.
A second-tab scenario can expose stale editing even with a valid draft. One tab shows a correctable error tied to an old pickup plan. Another shows an approved new plan. If the first tab opens its error link after the second tab updates the draft, decide whether it lands on fresh evidence or presents a safe conflict to resolve. Don't let the old tab announce that a time failed after the person already changed it to a different available time. Conversely, don't hide a genuine problem if the underlying proposal is still the same. Match the repair prompt to the actual state the person may change.
In review, be careful with the language around drafts. “Your changes were saved” can mean temporary input retention, a completed staff request, or a final booking depending on the surrounding context. State which operation the service actually confirmed. An old browser content snapshot after Back may display text from a former state of the form. Use an authorized fixture to see what the supported browser shows, update the status according to reliable evidence, and verify ordinary re-entry still works. Holding a draft safely and explaining which state persists can save more user effort than any particular animation, color, or summary placement.