VIEW THIS AS

Auto mode follows the Route Engine until you choose a viewpoint.

YOU ARE HERE

ROUTE CHECK

CONNECTED TO

WHAT NEXT

Use the canonical route for this room, or HELP if you are unsure.

Top Ways to Translate Correctly | WAI-ARIA Accessible Names, Form Labels and Error Messages

How do you translate a website’s buttons, form labels and error messages so that screen-reader users understand the same controls as sighted readers? Translate the visible purpose of each control, keep its programmatic accessible name accurate and consistent, connect any additional instructions through appropriate description mechanisms, and test the actual name, role, state and feedback exposed by the browser. Good accessible localisation does not mean translating every hidden attribute indiscriminately; it means preserving the user’s ability to complete the action.

A page can look fully translated while its submit button still announces ‘Continue’ in English, its password field is labelled differently for the screen reader, or its validation error describes the wrong problem. Readers looking for WAI-ARIA translation, accessible name localisation, aria-label translation, aria-labelledby, aria-describedby, multilingual form accessibility, screen-reader error messages and WCAG labels in name need to connect language quality with interaction design. This article teaches the distinct job of translating interactive controls, not the general mechanics of subtitle files, PDF tags or images.

Quick method:

  • Begin with the control’s actual user action, not an isolated label string.
  • Prefer a visible, persistent native HTML label when the control type permits it.
  • Keep accessible names aligned with visible words and distinguish them from longer descriptions.
  • Translate validation instructions and state messages while preserving technical field associations.
  • Check focus, keyboard use, language declarations and the actual screen-reader announcement.
  • Test with a real task, including recovery after a mistake, rather than a screenshot alone.

The visible problem: a translated interface still fails for one reader

Imagine a parent registering a child for a lesson. The page displays a translated ‘Email address’ label, but the input is exposed to assistive technology with a legacy English aria-label. When the parent moves through controls using a screen reader, what they hear differs from what a sighted family member sees. When a required field is missed, a red border appears, yet the spoken feedback never identifies which field is incomplete. This is not only a translation error; it is a failure of the entire interactive experience.

The correct unit of work is not the isolated word ‘Submit’ or ‘Required’. It is the labelled control in context: what it does, which field it names, which instructions apply, what changes when the user acts, how errors are linked, and whether someone can recover. Translators should receive meaningful screenshots, interface context, existing names and representative error states. Developers should receive approved language strings while preserving the DOM relationships that allow browsers and assistive technologies to compute names and descriptions.

One source of confusion is the phrase ‘hidden accessibility label’. Many components need an accessible name, but the best source is often the visible label itself. W3C’s Authoring Practices Guide advises preferring visible text and native HTML naming approaches. Adding an alternative hidden text in another language can create conflicting names, increase maintenance work and undermine voice control if the words users see do not match the words the accessibility layer exposes.

First principles: names, descriptions, roles and states are different information

An accessible name is the concise label by which a control or relevant element is identified to assistive technologies. A button named ‘Save draft’ tells the user the action. An accessible description can add instructions, constraints or consequences, such as ‘You can edit this draft later.’ The name should not carry an entire paragraph merely because that explanation matters. Screen readers may present names, roles, states and descriptions differently.

Native HTML elements often provide sound naming semantics. A label connected to an input gives the field a name; a button’s visible text commonly supplies its name; a table caption identifies a table. WAI-ARIA offers additional ways to name or describe elements when native semantics and visible text cannot meet the need. The sensible principle is to start with the simplest robust option and introduce ARIA deliberately, not to decorate every translated element with extra attributes.

The aria-labelledby property can refer to other elements whose text contributes to a name. The aria-label property can supply a name directly, commonly when a control lacks visible text. The aria-describedby property associates supplemental explanation. These are not interchangeable translation slots. Updating only one may leave the accessible output inconsistent; translating an ID reference itself may break the link unless the code updates both ends correctly.

Visible-label matching matters for people using voice input as well as screen readers. If a visible button reads ‘Send message’ but its accessible name is only ‘Transmit request’, the discrepancy can make the page difficult to operate by speech and can violate the intent of WCAG’s Label in Name requirement. Prefer the visible label words in the accessible name when a visible label exists; avoid inventing grander English phrasing for a short translated button.

Errors and states are part of meaning. A checkbox might be checked, a tab selected, a button expanded or a form field invalid. Attributes communicating these states are not ordinary strings to translate. Human-readable feedback, however, should explain the state and next action in the target language. A message such as ‘Enter an email address in the format name@example.com’ should be linked to the relevant field and presented at a time when the reader can discover it.

Language identification supports pronunciation. Set an appropriate language on the page and use nested language markup when quoted terms or imported names belong to another language. A correctly translated accessible name can sound confusing if the engine assumes the wrong pronunciation rules. Language markup helps, but it does not excuse missing labels or poor wording.

Icons and images require function-based decisions. An icon-only close button needs an understandable name for its action. A decorative image may appropriately have an empty alt attribute. An informative chart needs an accessible explanation of its relevant information. W3C’s alt decision tree helps decide which case applies. This guide concentrates on interactive controls; the visual-media alternatives deserve their own editorial treatment.

The twelve-stage method for translating accessible controls

Stage 1: Map the task before strings

Document what a person is trying to complete: register, search, change language, upload a file, correct an error or close a dialog. A label should help the person complete that action in the target language.

At this stage, the editor must see the rendered interface and the developer must know which text is editorial content rather than a structural identifier. Check both layers after each change. A control can have correct words in a spreadsheet yet announce the wrong name because of attribute precedence or a disconnected reference.

Make the acceptance criterion behavioural: can a person identify the control, predict the action, use it from the keyboard, detect what changed, and recover if something fails? The same question should work in the translated locale without requiring the reader to fall back to English labels or visual color cues.

Stage 2: Inventory visible and programmatic text

For each control collect visible text, existing HTML label, aria-label, aria-labelledby references, descriptions, help text and validation messages. Do not translate attributes blindly without seeing how the browser computes the accessible output.

At this stage, the editor must see the rendered interface and the developer must know which text is editorial content rather than a structural identifier. Check both layers after each change. A control can have correct words in a spreadsheet yet announce the wrong name because of attribute precedence or a disconnected reference.

Make the acceptance criterion behavioural: can a person identify the control, predict the action, use it from the keyboard, detect what changed, and recover if something fails? The same question should work in the translated locale without requiring the reader to fall back to English labels or visual color cues.

Stage 3: Choose clear native semantics

Where possible, use actual buttons, labels, fieldsets and legends rather than custom markup mimicking them. A correctly translated native control is often easier to maintain and test.

At this stage, the editor must see the rendered interface and the developer must know which text is editorial content rather than a structural identifier. Check both layers after each change. A control can have correct words in a spreadsheet yet announce the wrong name because of attribute precedence or a disconnected reference.

Make the acceptance criterion behavioural: can a person identify the control, predict the action, use it from the keyboard, detect what changed, and recover if something fails? The same question should work in the translated locale without requiring the reader to fall back to English labels or visual color cues.

Stage 4: Translate the visible action first

Keep button and field labels concise, familiar and specific. Make verbs clearly distinguish actions with different consequences. A clear visible word is the best anchor for both sighted and non-visual users.

At this stage, the editor must see the rendered interface and the developer must know which text is editorial content rather than a structural identifier. Check both layers after each change. A control can have correct words in a spreadsheet yet announce the wrong name because of attribute precedence or a disconnected reference.

Make the acceptance criterion behavioural: can a person identify the control, predict the action, use it from the keyboard, detect what changed, and recover if something fails? The same question should work in the translated locale without requiring the reader to fall back to English labels or visual color cues.

Stage 5: Align accessible names

If the accessible name comes from visible text, avoid adding a conflicting hidden alternative. If a non-visible name is necessary, translate it in line with the visible meaning. Check label-in-name relationships and avoid mismatched synonyms that hinder voice control.

At this stage, the editor must see the rendered interface and the developer must know which text is editorial content rather than a structural identifier. Check both layers after each change. A control can have correct words in a spreadsheet yet announce the wrong name because of attribute precedence or a disconnected reference.

Make the acceptance criterion behavioural: can a person identify the control, predict the action, use it from the keyboard, detect what changed, and recover if something fails? The same question should work in the translated locale without requiring the reader to fall back to English labels or visual color cues.

Stage 6: Translate descriptions separately

Keep additional instructions in their own appropriate descriptive elements, connected to the control where necessary. Do not turn a two-word name into a seventy-word explanation.

At this stage, the editor must see the rendered interface and the developer must know which text is editorial content rather than a structural identifier. Check both layers after each change. A control can have correct words in a spreadsheet yet announce the wrong name because of attribute precedence or a disconnected reference.

Make the acceptance criterion behavioural: can a person identify the control, predict the action, use it from the keyboard, detect what changed, and recover if something fails? The same question should work in the translated locale without requiring the reader to fall back to English labels or visual color cues.

Stage 7: Preserve technical relationships

Keep element IDs, aria-labelledby references, aria-describedby references, form names, state attributes and code identifiers functional. The values linking DOM elements are not human-readable text to translate casually.

At this stage, the editor must see the rendered interface and the developer must know which text is editorial content rather than a structural identifier. Check both layers after each change. A control can have correct words in a spreadsheet yet announce the wrong name because of attribute precedence or a disconnected reference.

Make the acceptance criterion behavioural: can a person identify the control, predict the action, use it from the keyboard, detect what changed, and recover if something fails? The same question should work in the translated locale without requiring the reader to fall back to English labels or visual color cues.

Stage 8: Design states and errors

Translate required-field indicators, error summaries, per-field messages, success confirmations and next-step guidance. Ensure invalid states, focus and announcements help a person recover from a failed submission.

At this stage, the editor must see the rendered interface and the developer must know which text is editorial content rather than a structural identifier. Check both layers after each change. A control can have correct words in a spreadsheet yet announce the wrong name because of attribute precedence or a disconnected reference.

Make the acceptance criterion behavioural: can a person identify the control, predict the action, use it from the keyboard, detect what changed, and recover if something fails? The same question should work in the translated locale without requiring the reader to fall back to English labels or visual color cues.

Stage 9: Review dynamic messages

Check expanding panels, loading states, timers, live regions and status text that change without a full page reload. Meaningful updates must be available to non-visual readers without creating overwhelming repeated announcements.

At this stage, the editor must see the rendered interface and the developer must know which text is editorial content rather than a structural identifier. Check both layers after each change. A control can have correct words in a spreadsheet yet announce the wrong name because of attribute precedence or a disconnected reference.

Make the acceptance criterion behavioural: can a person identify the control, predict the action, use it from the keyboard, detect what changed, and recover if something fails? The same question should work in the translated locale without requiring the reader to fall back to English labels or visual color cues.

Stage 10: Mark actual language

Ensure page and passage language identification fit the translated interface and any retained original-language examples. Correct pronunciation is an independent quality concern from naming.

At this stage, the editor must see the rendered interface and the developer must know which text is editorial content rather than a structural identifier. Check both layers after each change. A control can have correct words in a spreadsheet yet announce the wrong name because of attribute precedence or a disconnected reference.

Make the acceptance criterion behavioural: can a person identify the control, predict the action, use it from the keyboard, detect what changed, and recover if something fails? The same question should work in the translated locale without requiring the reader to fall back to English labels or visual color cues.

Stage 11: Test keyboard and screen reader

Navigate with the keyboard and inspect the computed name, role, state and description in at least the environments supported by the product. Do not assume that a string existing in source code means a user will hear it.

At this stage, the editor must see the rendered interface and the developer must know which text is editorial content rather than a structural identifier. Check both layers after each change. A control can have correct words in a spreadsheet yet announce the wrong name because of attribute precedence or a disconnected reference.

Make the acceptance criterion behavioural: can a person identify the control, predict the action, use it from the keyboard, detect what changed, and recover if something fails? The same question should work in the translated locale without requiring the reader to fall back to English labels or visual color cues.

Stage 12: Record acceptance scenarios

Keep tests covering successful action, empty field, invalid input, disabled state, corrected input and confirmation. Use the same task in every locale to catch partial translation and broken relationships.

At this stage, the editor must see the rendered interface and the developer must know which text is editorial content rather than a structural identifier. Check both layers after each change. A control can have correct words in a spreadsheet yet announce the wrong name because of attribute precedence or a disconnected reference.

Make the acceptance criterion behavioural: can a person identify the control, predict the action, use it from the keyboard, detect what changed, and recover if something fails? The same question should work in the translated locale without requiring the reader to fall back to English labels or visual color cues.

Twenty-two worked examples: translate the interaction, not merely the word

The situations are illustrative and should be adapted to the language’s genuine grammar and vocabulary. Each example includes a test because a string’s presence in source code is not proof of its actual accessible name.

Worked example 1: Search field with visible label

Visible task: A search form displays the translated word for Search beside the input. Hidden failure: The legacy aria-label still contains an English sentence.

Correct translation and structure: Prefer a properly associated visible label and remove an unnecessary conflicting override. First determine what the user thinks this control does. Then inspect the actual source of its accessible name and any description. Translate the human phrase while preserving the technical relationships by which browsers associate elements. A word in an aria attribute can override visible text; an ID reference is not a phrase to translate without updating its linkage.

Acceptance check: Inspect the computed name, test keyboard search and ask a native reader to review the label. Inspect the computed name, role, state and description, not only the visible string. Test the same action with a keyboard and, where possible, a screen reader. If the reader makes an error, confirm that the target-language recovery instruction identifies the correct field and does not rely exclusively on colour or position. Keep a record of the correct result for future translation releases.

Worked example 2: Icon-only close button

Visible task: A modal dialog has an X icon without visible text. Hidden failure: A screen-reader user cannot tell what clicking the icon does.

Correct translation and structure: Supply an accessible action name such as the target-language equivalent of Close. First determine what the user thinks this control does. Then inspect the actual source of its accessible name and any description. Translate the human phrase while preserving the technical relationships by which browsers associate elements. A word in an aria attribute can override visible text; an ID reference is not a phrase to translate without updating its linkage.

Acceptance check: Verify that the same action closes the correct dialog and focus returns appropriately. Inspect the computed name, role, state and description, not only the visible string. Test the same action with a keyboard and, where possible, a screen reader. If the reader makes an error, confirm that the target-language recovery instruction identifies the correct field and does not rely exclusively on colour or position. Keep a record of the correct result for future translation releases.

Worked example 3: Submit versus save draft

Visible task: A form has two neighbouring buttons with different effects. Hidden failure: The translations use the same generic word for both.

Correct translation and structure: Translate the actual consequences so the actions are distinguishable. First determine what the user thinks this control does. Then inspect the actual source of its accessible name and any description. Translate the human phrase while preserving the technical relationships by which browsers associate elements. A word in an aria attribute can override visible text; an ID reference is not a phrase to translate without updating its linkage.

Acceptance check: Test what happens after each button and check the announced labels independently. Inspect the computed name, role, state and description, not only the visible string. Test the same action with a keyboard and, where possible, a screen reader. If the reader makes an error, confirm that the target-language recovery instruction identifies the correct field and does not rely exclusively on colour or position. Keep a record of the correct result for future translation releases.

Worked example 4: Required email input

Visible task: The email field is required, and the form includes a format hint. Hidden failure: A short name has accidentally absorbed the entire example instruction.

Correct translation and structure: Use an accessible name for Email address and a separate associated description for format guidance. First determine what the user thinks this control does. Then inspect the actual source of its accessible name and any description. Translate the human phrase while preserving the technical relationships by which browsers associate elements. A word in an aria attribute can override visible text; an ID reference is not a phrase to translate without updating its linkage.

Acceptance check: Try invalid input and verify the hint and error can be found. Inspect the computed name, role, state and description, not only the visible string. Test the same action with a keyboard and, where possible, a screen reader. If the reader makes an error, confirm that the target-language recovery instruction identifies the correct field and does not rely exclusively on colour or position. Keep a record of the correct result for future translation releases.

Worked example 5: Password visibility toggle

Visible task: A button switches between revealing and hiding the password. Hidden failure: The accessible name remains Show password after the state changes.

Correct translation and structure: Review action wording and state treatment so the current purpose is apparent. First determine what the user thinks this control does. Then inspect the actual source of its accessible name and any description. Translate the human phrase while preserving the technical relationships by which browsers associate elements. A word in an aria attribute can override visible text; an ID reference is not a phrase to translate without updating its linkage.

Acceptance check: Activate the control twice and inspect name and state each time. Inspect the computed name, role, state and description, not only the visible string. Test the same action with a keyboard and, where possible, a screen reader. If the reader makes an error, confirm that the target-language recovery instruction identifies the correct field and does not rely exclusively on colour or position. Keep a record of the correct result for future translation releases.

Worked example 6: Language switcher

Visible task: A dropdown chooses English, Mandarin or Malay. Hidden failure: The translated interface calls the dropdown only Select without context.

Correct translation and structure: Name the control for its language-selection purpose and keep the options in approved wording. First determine what the user thinks this control does. Then inspect the actual source of its accessible name and any description. Translate the human phrase while preserving the technical relationships by which browsers associate elements. A word in an aria attribute can override visible text; an ID reference is not a phrase to translate without updating its linkage.

Acceptance check: Test keyboard selection and verify which page language actually appears. Inspect the computed name, role, state and description, not only the visible string. Test the same action with a keyboard and, where possible, a screen reader. If the reader makes an error, confirm that the target-language recovery instruction identifies the correct field and does not rely exclusively on colour or position. Keep a record of the correct result for future translation releases.

Worked example 7: Country dropdown

Visible task: The list includes country names and codes. Hidden failure: A translated label is present visually but the custom component has no programmatic name.

Correct translation and structure: Use correct native or ARIA semantics and connect the visible label. First determine what the user thinks this control does. Then inspect the actual source of its accessible name and any description. Translate the human phrase while preserving the technical relationships by which browsers associate elements. A word in an aria attribute can override visible text; an ID reference is not a phrase to translate without updating its linkage.

Acceptance check: Search and select an item without using the mouse. Inspect the computed name, role, state and description, not only the visible string. Test the same action with a keyboard and, where possible, a screen reader. If the reader makes an error, confirm that the target-language recovery instruction identifies the correct field and does not rely exclusively on colour or position. Keep a record of the correct result for future translation releases.

Worked example 8: Checkbox for consent

Visible task: A checkbox asks the reader to agree to a policy. Hidden failure: The translation drops the distinction between receiving news and accepting essential terms.

Correct translation and structure: Keep the scope and consequence of consent precise in both visible and accessible text. First determine what the user thinks this control does. Then inspect the actual source of its accessible name and any description. Translate the human phrase while preserving the technical relationships by which browsers associate elements. A word in an aria attribute can override visible text; an ID reference is not a phrase to translate without updating its linkage.

Acceptance check: Check the announced state and the full accessible policy link. Inspect the computed name, role, state and description, not only the visible string. Test the same action with a keyboard and, where possible, a screen reader. If the reader makes an error, confirm that the target-language recovery instruction identifies the correct field and does not rely exclusively on colour or position. Keep a record of the correct result for future translation releases.

Worked example 9: Radio group for class level

Visible task: The form asks which learning level a parent wants. Hidden failure: Each radio has a name but the group question is missing.

Correct translation and structure: Use a clear translated group label, ideally semantic fieldset and legend when suitable. First determine what the user thinks this control does. Then inspect the actual source of its accessible name and any description. Translate the human phrase while preserving the technical relationships by which browsers associate elements. A word in an aria attribute can override visible text; an ID reference is not a phrase to translate without updating its linkage.

Acceptance check: Move through options and confirm the question remains understandable. Inspect the computed name, role, state and description, not only the visible string. Test the same action with a keyboard and, where possible, a screen reader. If the reader makes an error, confirm that the target-language recovery instruction identifies the correct field and does not rely exclusively on colour or position. Keep a record of the correct result for future translation releases.

Worked example 10: File-upload button

Visible task: An upload control accepts a document and specifies allowed formats. Hidden failure: Only the filename hint was translated; the upload action remained English.

Correct translation and structure: Translate the visible action and place file constraints in the relevant instructions. First determine what the user thinks this control does. Then inspect the actual source of its accessible name and any description. Translate the human phrase while preserving the technical relationships by which browsers associate elements. A word in an aria attribute can override visible text; an ID reference is not a phrase to translate without updating its linkage.

Acceptance check: Select an invalid file and check that the recovery message is translated. Inspect the computed name, role, state and description, not only the visible string. Test the same action with a keyboard and, where possible, a screen reader. If the reader makes an error, confirm that the target-language recovery instruction identifies the correct field and does not rely exclusively on colour or position. Keep a record of the correct result for future translation releases.

Worked example 11: Error summary at top

Visible task: Submitting an empty form shows multiple errors. Hidden failure: A reader sees red borders but receives no clear error summary.

Correct translation and structure: Translate a concise summary and make each error discoverable with the correct field. First determine what the user thinks this control does. Then inspect the actual source of its accessible name and any description. Translate the human phrase while preserving the technical relationships by which browsers associate elements. A word in an aria attribute can override visible text; an ID reference is not a phrase to translate without updating its linkage.

Acceptance check: Tab through the form and confirm focus and messages guide recovery. Inspect the computed name, role, state and description, not only the visible string. Test the same action with a keyboard and, where possible, a screen reader. If the reader makes an error, confirm that the target-language recovery instruction identifies the correct field and does not rely exclusively on colour or position. Keep a record of the correct result for future translation releases.

Worked example 12: Specific validation error

Visible task: The email address omits the @ symbol. Hidden failure: The translated message generically says Something went wrong.

Correct translation and structure: Explain the actual issue in non-blaming language and state how to correct it. First determine what the user thinks this control does. Then inspect the actual source of its accessible name and any description. Translate the human phrase while preserving the technical relationships by which browsers associate elements. A word in an aria attribute can override visible text; an ID reference is not a phrase to translate without updating its linkage.

Acceptance check: Correct the input and verify the error clears without leaving stale feedback. Inspect the computed name, role, state and description, not only the visible string. Test the same action with a keyboard and, where possible, a screen reader. If the reader makes an error, confirm that the target-language recovery instruction identifies the correct field and does not rely exclusively on colour or position. Keep a record of the correct result for future translation releases.

Worked example 13: Live result count

Visible task: A search page updates from five to six results. Hidden failure: The live-region announcement is hardcoded in English.

Correct translation and structure: Translate the meaningful status and verify that updates are announced appropriately. First determine what the user thinks this control does. Then inspect the actual source of its accessible name and any description. Translate the human phrase while preserving the technical relationships by which browsers associate elements. A word in an aria attribute can override visible text; an ID reference is not a phrase to translate without updating its linkage.

Acceptance check: Search twice and check that announcements are not duplicated or excessively verbose. Inspect the computed name, role, state and description, not only the visible string. Test the same action with a keyboard and, where possible, a screen reader. If the reader makes an error, confirm that the target-language recovery instruction identifies the correct field and does not rely exclusively on colour or position. Keep a record of the correct result for future translation releases.

Worked example 14: Accordion help section

Visible task: A button expands a panel about payment information. Hidden failure: The visible translation and aria-expanded state disagree after clicking.

Correct translation and structure: Keep the label stable or intentionally update it and ensure expanded state is correct. First determine what the user thinks this control does. Then inspect the actual source of its accessible name and any description. Translate the human phrase while preserving the technical relationships by which browsers associate elements. A word in an aria attribute can override visible text; an ID reference is not a phrase to translate without updating its linkage.

Acceptance check: Use keyboard activation and check whether the new content is reachable. Inspect the computed name, role, state and description, not only the visible string. Test the same action with a keyboard and, where possible, a screen reader. If the reader makes an error, confirm that the target-language recovery instruction identifies the correct field and does not rely exclusively on colour or position. Keep a record of the correct result for future translation releases.

Worked example 15: Tab interface

Visible task: Tabs switch between timetable, fees and preparation guidance. Hidden failure: All accessible tab names were translated as Information.

Correct translation and structure: Give each tab a distinct action-or-topic label and preserve selected state and tab-panel association. First determine what the user thinks this control does. Then inspect the actual source of its accessible name and any description. Translate the human phrase while preserving the technical relationships by which browsers associate elements. A word in an aria attribute can override visible text; an ID reference is not a phrase to translate without updating its linkage.

Acceptance check: Navigate by keyboard and inspect which panel is announced. Inspect the computed name, role, state and description, not only the visible string. Test the same action with a keyboard and, where possible, a screen reader. If the reader makes an error, confirm that the target-language recovery instruction identifies the correct field and does not rely exclusively on colour or position. Keep a record of the correct result for future translation releases.

Worked example 16: Dialog heading

Visible task: A registration dialog has a translated heading. Hidden failure: The modal’s aria-labelledby still points to the wrong element.

Correct translation and structure: Connect the accessible dialog name to the correct visible heading. First determine what the user thinks this control does. Then inspect the actual source of its accessible name and any description. Translate the human phrase while preserving the technical relationships by which browsers associate elements. A word in an aria attribute can override visible text; an ID reference is not a phrase to translate without updating its linkage.

Acceptance check: Open the dialog and inspect title, focus trap and close action. Inspect the computed name, role, state and description, not only the visible string. Test the same action with a keyboard and, where possible, a screen reader. If the reader makes an error, confirm that the target-language recovery instruction identifies the correct field and does not rely exclusively on colour or position. Keep a record of the correct result for future translation releases.

Worked example 17: Tooltip explanation

Visible task: An information icon opens a brief explanation. Hidden failure: The aria-label describes the icon shape rather than its purpose.

Correct translation and structure: Name the control according to the help action and expose supplementary explanation appropriately. First determine what the user thinks this control does. Then inspect the actual source of its accessible name and any description. Translate the human phrase while preserving the technical relationships by which browsers associate elements. A word in an aria attribute can override visible text; an ID reference is not a phrase to translate without updating its linkage.

Acceptance check: Test with keyboard focus and the accessibility tree. Inspect the computed name, role, state and description, not only the visible string. Test the same action with a keyboard and, where possible, a screen reader. If the reader makes an error, confirm that the target-language recovery instruction identifies the correct field and does not rely exclusively on colour or position. Keep a record of the correct result for future translation releases.

Worked example 18: Translated image button

Visible task: A clickable image represents Download worksheet. Hidden failure: Its alt text describes a blue arrow instead of the download action.

Correct translation and structure: Use a function-based accessible name appropriate to the interactive element. First determine what the user thinks this control does. Then inspect the actual source of its accessible name and any description. Translate the human phrase while preserving the technical relationships by which browsers associate elements. A word in an aria attribute can override visible text; an ID reference is not a phrase to translate without updating its linkage.

Acceptance check: Trigger the download and verify announced meaning matches the actual result. Inspect the computed name, role, state and description, not only the visible string. Test the same action with a keyboard and, where possible, a screen reader. If the reader makes an error, confirm that the target-language recovery instruction identifies the correct field and does not rely exclusively on colour or position. Keep a record of the correct result for future translation releases.

Worked example 19: Non-English teacher name

Visible task: The interface displays a retained Chinese teacher name inside English controls. Hidden failure: Pronunciation differs depending on the markup language.

Correct translation and structure: Preserve the approved name and mark the language change where it can improve pronunciation. First determine what the user thinks this control does. Then inspect the actual source of its accessible name and any description. Translate the human phrase while preserving the technical relationships by which browsers associate elements. A word in an aria attribute can override visible text; an ID reference is not a phrase to translate without updating its linkage.

Acceptance check: Test the full button or list-item announcement with the target screen reader. Inspect the computed name, role, state and description, not only the visible string. Test the same action with a keyboard and, where possible, a screen reader. If the reader makes an error, confirm that the target-language recovery instruction identifies the correct field and does not rely exclusively on colour or position. Keep a record of the correct result for future translation releases.

Worked example 20: Success confirmation

Visible task: After saving, the page updates with a confirmation message. Hidden failure: The visual toast is translated but not announced to assistive technology.

Correct translation and structure: Make the relevant translated status available through an appropriate accessible messaging pattern. First determine what the user thinks this control does. Then inspect the actual source of its accessible name and any description. Translate the human phrase while preserving the technical relationships by which browsers associate elements. A word in an aria attribute can override visible text; an ID reference is not a phrase to translate without updating its linkage.

Acceptance check: Save twice and check that the user knows whether the action completed. Inspect the computed name, role, state and description, not only the visible string. Test the same action with a keyboard and, where possible, a screen reader. If the reader makes an error, confirm that the target-language recovery instruction identifies the correct field and does not rely exclusively on colour or position. Keep a record of the correct result for future translation releases.

Worked example 21: Multi-step form

Visible task: The interface presents Step 2 of 4 and a Continue action. Hidden failure: The progress label was copied from an English template.

Correct translation and structure: Translate the progress context and keep the step numbers and action aligned. First determine what the user thinks this control does. Then inspect the actual source of its accessible name and any description. Translate the human phrase while preserving the technical relationships by which browsers associate elements. A word in an aria attribute can override visible text; an ID reference is not a phrase to translate without updating its linkage.

Acceptance check: Navigate backwards and forwards and confirm the current step is understandable. Inspect the computed name, role, state and description, not only the visible string. Test the same action with a keyboard and, where possible, a screen reader. If the reader makes an error, confirm that the target-language recovery instruction identifies the correct field and does not rely exclusively on colour or position. Keep a record of the correct result for future translation releases.

Worked example 22: Disabled action

Visible task: A button cannot be activated until a required choice is made. Hidden failure: The translation gives no clue why the action is unavailable.

Correct translation and structure: Keep state accurate and provide a discoverable explanation of what needs completion. First determine what the user thinks this control does. Then inspect the actual source of its accessible name and any description. Translate the human phrase while preserving the technical relationships by which browsers associate elements. A word in an aria attribute can override visible text; an ID reference is not a phrase to translate without updating its linkage.

Acceptance check: Check how keyboard and screen-reader users learn the requirement. Inspect the computed name, role, state and description, not only the visible string. Test the same action with a keyboard and, where possible, a screen reader. If the reader makes an error, confirm that the target-language recovery instruction identifies the correct field and does not rely exclusively on colour or position. Keep a record of the correct result for future translation releases.

Common failure patterns and specific repairs

Failure 1: Translated visible text but old aria-label

Symptom: Screen-reader output remains in the previous language. Repair: Remove a redundant override or translate it appropriately while maintaining label-in-name consistency. A good repair changes the experience for the user, not just the text recorded in a localization spreadsheet. Verify the rendered UI, accessible name calculation, keyboard route and recovery message together. If a control’s meaning depends on its state, repeat the test before and after activation.

Failure 2: Translated ID references as words

Symptom: aria-labelledby or aria-describedby no longer points to a real element. Repair: Keep structural IDs stable or update both the referenced element and reference value deliberately. A good repair changes the experience for the user, not just the text recorded in a localization spreadsheet. Verify the rendered UI, accessible name calculation, keyboard route and recovery message together. If a control’s meaning depends on its state, repeat the test before and after activation.

Failure 3: Using placeholder as sole label

Symptom: The field’s purpose may disappear when the user starts typing. Repair: Provide a persistent visible label with sound native association. A good repair changes the experience for the user, not just the text recorded in a localization spreadsheet. Verify the rendered UI, accessible name calculation, keyboard route and recovery message together. If a control’s meaning depends on its state, repeat the test before and after activation.

Failure 4: Making names too long

Symptom: Every control announcement becomes a paragraph. Repair: Keep the name concise and move additional guidance into an appropriate description. A good repair changes the experience for the user, not just the text recorded in a localization spreadsheet. Verify the rendered UI, accessible name calculation, keyboard route and recovery message together. If a control’s meaning depends on its state, repeat the test before and after activation.

Failure 5: Duplicating role words

Symptom: A button may announce as a button twice. Repair: Name the function, not the role already exposed by the element. A good repair changes the experience for the user, not just the text recorded in a localization spreadsheet. Verify the rendered UI, accessible name calculation, keyboard route and recovery message together. If a control’s meaning depends on its state, repeat the test before and after activation.

Failure 6: Hiding error detail in color

Symptom: Users cannot determine what went wrong. Repair: Supply translated text associated with the field and an understandable recovery route. A good repair changes the experience for the user, not just the text recorded in a localization spreadsheet. Verify the rendered UI, accessible name calculation, keyboard route and recovery message together. If a control’s meaning depends on its state, repeat the test before and after activation.

Failure 7: Failing dynamic announcements

Symptom: A success or error appears visually but is unavailable when needed. Repair: Use a suitable accessible status or alert pattern and test the timing of changes. A good repair changes the experience for the user, not just the text recorded in a localization spreadsheet. Verify the rendered UI, accessible name calculation, keyboard route and recovery message together. If a control’s meaning depends on its state, repeat the test before and after activation.

Failure 8: Changing only one state string

Symptom: Show/Hide or Expand/Collapse becomes misleading. Repair: Review the full state transition, not only the initial label. A good repair changes the experience for the user, not just the text recorded in a localization spreadsheet. Verify the rendered UI, accessible name calculation, keyboard route and recovery message together. If a control’s meaning depends on its state, repeat the test before and after activation.

Failure 9: Inconsistent visible and spoken label

Symptom: Voice-command users may be unable to act by the words they see. Repair: Include visible wording in the accessible name and check exact task terminology. A good repair changes the experience for the user, not just the text recorded in a localization spreadsheet. Verify the rendered UI, accessible name calculation, keyboard route and recovery message together. If a control’s meaning depends on its state, repeat the test before and after activation.

Failure 10: ARIA overuse on native elements

Symptom: Unnecessary attributes override robust built-in semantics. Repair: Start from semantic HTML and add ARIA only where needed. A good repair changes the experience for the user, not just the text recorded in a localization spreadsheet. Verify the rendered UI, accessible name calculation, keyboard route and recovery message together. If a control’s meaning depends on its state, repeat the test before and after activation.

Failure 11: Wrong language pronunciation

Symptom: A translated name is spoken with an inappropriate pronunciation system. Repair: Mark actual language changes and test with the intended assistive technology. A good repair changes the experience for the user, not just the text recorded in a localization spreadsheet. Verify the rendered UI, accessible name calculation, keyboard route and recovery message together. If a control’s meaning depends on its state, repeat the test before and after activation.

Failure 12: No task-based review

Symptom: A label passes translation QA but fails a form-completion attempt. Repair: Test an entire successful and failed interaction in the target language. A good repair changes the experience for the user, not just the text recorded in a localization spreadsheet. Verify the rendered UI, accessible name calculation, keyboard route and recovery message together. If a control’s meaning depends on its state, repeat the test before and after activation.

Practice tasks with model solutions

Choose a target language you actually understand or work with a fluent reviewer. For every case, list the visible label, accessible name source, optional description, state changes and the screen-reader task that proves it works.

Practice 1: Search field with visible label

Task: A search form displays the translated word for Search beside the input. The legacy aria-label still contains an English sentence. Write a plain-language diagnosis and explain what you would translate and what you would leave intact as markup or identifiers.

Model reasoning: Prefer a properly associated visible label and remove an unnecessary conflicting override. Inspect the computed name, test keyboard search and ask a native reader to review the label. An effective answer asks whether the translated control’s visible wording and announced accessible name identify the same purpose. It also names the technical relationship that must remain intact and describes how a user can discover or correct a problem. Do not claim success based on a source-string inventory alone; check the browser-exposed result.

Practice 2: Icon-only close button

Task: A modal dialog has an X icon without visible text. A screen-reader user cannot tell what clicking the icon does. Write a plain-language diagnosis and explain what you would translate and what you would leave intact as markup or identifiers.

Model reasoning: Supply an accessible action name such as the target-language equivalent of Close. Verify that the same action closes the correct dialog and focus returns appropriately. An effective answer asks whether the translated control’s visible wording and announced accessible name identify the same purpose. It also names the technical relationship that must remain intact and describes how a user can discover or correct a problem. Do not claim success based on a source-string inventory alone; check the browser-exposed result.

Practice 3: Submit versus save draft

Task: A form has two neighbouring buttons with different effects. The translations use the same generic word for both. Write a plain-language diagnosis and explain what you would translate and what you would leave intact as markup or identifiers.

Model reasoning: Translate the actual consequences so the actions are distinguishable. Test what happens after each button and check the announced labels independently. An effective answer asks whether the translated control’s visible wording and announced accessible name identify the same purpose. It also names the technical relationship that must remain intact and describes how a user can discover or correct a problem. Do not claim success based on a source-string inventory alone; check the browser-exposed result.

Practice 4: Required email input

Task: The email field is required, and the form includes a format hint. A short name has accidentally absorbed the entire example instruction. Write a plain-language diagnosis and explain what you would translate and what you would leave intact as markup or identifiers.

Model reasoning: Use an accessible name for Email address and a separate associated description for format guidance. Try invalid input and verify the hint and error can be found. An effective answer asks whether the translated control’s visible wording and announced accessible name identify the same purpose. It also names the technical relationship that must remain intact and describes how a user can discover or correct a problem. Do not claim success based on a source-string inventory alone; check the browser-exposed result.

Practice 5: Password visibility toggle

Task: A button switches between revealing and hiding the password. The accessible name remains Show password after the state changes. Write a plain-language diagnosis and explain what you would translate and what you would leave intact as markup or identifiers.

Model reasoning: Review action wording and state treatment so the current purpose is apparent. Activate the control twice and inspect name and state each time. An effective answer asks whether the translated control’s visible wording and announced accessible name identify the same purpose. It also names the technical relationship that must remain intact and describes how a user can discover or correct a problem. Do not claim success based on a source-string inventory alone; check the browser-exposed result.

Practice 6: Language switcher

Task: A dropdown chooses English, Mandarin or Malay. The translated interface calls the dropdown only Select without context. Write a plain-language diagnosis and explain what you would translate and what you would leave intact as markup or identifiers.

Model reasoning: Name the control for its language-selection purpose and keep the options in approved wording. Test keyboard selection and verify which page language actually appears. An effective answer asks whether the translated control’s visible wording and announced accessible name identify the same purpose. It also names the technical relationship that must remain intact and describes how a user can discover or correct a problem. Do not claim success based on a source-string inventory alone; check the browser-exposed result.

Practice 7: Country dropdown

Task: The list includes country names and codes. A translated label is present visually but the custom component has no programmatic name. Write a plain-language diagnosis and explain what you would translate and what you would leave intact as markup or identifiers.

Model reasoning: Use correct native or ARIA semantics and connect the visible label. Search and select an item without using the mouse. An effective answer asks whether the translated control’s visible wording and announced accessible name identify the same purpose. It also names the technical relationship that must remain intact and describes how a user can discover or correct a problem. Do not claim success based on a source-string inventory alone; check the browser-exposed result.

Practice 8: Checkbox for consent

Task: A checkbox asks the reader to agree to a policy. The translation drops the distinction between receiving news and accepting essential terms. Write a plain-language diagnosis and explain what you would translate and what you would leave intact as markup or identifiers.

Model reasoning: Keep the scope and consequence of consent precise in both visible and accessible text. Check the announced state and the full accessible policy link. An effective answer asks whether the translated control’s visible wording and announced accessible name identify the same purpose. It also names the technical relationship that must remain intact and describes how a user can discover or correct a problem. Do not claim success based on a source-string inventory alone; check the browser-exposed result.

Practice 9: Radio group for class level

Task: The form asks which learning level a parent wants. Each radio has a name but the group question is missing. Write a plain-language diagnosis and explain what you would translate and what you would leave intact as markup or identifiers.

Model reasoning: Use a clear translated group label, ideally semantic fieldset and legend when suitable. Move through options and confirm the question remains understandable. An effective answer asks whether the translated control’s visible wording and announced accessible name identify the same purpose. It also names the technical relationship that must remain intact and describes how a user can discover or correct a problem. Do not claim success based on a source-string inventory alone; check the browser-exposed result.

Practice 10: File-upload button

Task: An upload control accepts a document and specifies allowed formats. Only the filename hint was translated; the upload action remained English. Write a plain-language diagnosis and explain what you would translate and what you would leave intact as markup or identifiers.

Model reasoning: Translate the visible action and place file constraints in the relevant instructions. Select an invalid file and check that the recovery message is translated. An effective answer asks whether the translated control’s visible wording and announced accessible name identify the same purpose. It also names the technical relationship that must remain intact and describes how a user can discover or correct a problem. Do not claim success based on a source-string inventory alone; check the browser-exposed result.

Practice 11: Error summary at top

Task: Submitting an empty form shows multiple errors. A reader sees red borders but receives no clear error summary. Write a plain-language diagnosis and explain what you would translate and what you would leave intact as markup or identifiers.

Model reasoning: Translate a concise summary and make each error discoverable with the correct field. Tab through the form and confirm focus and messages guide recovery. An effective answer asks whether the translated control’s visible wording and announced accessible name identify the same purpose. It also names the technical relationship that must remain intact and describes how a user can discover or correct a problem. Do not claim success based on a source-string inventory alone; check the browser-exposed result.

Practice 12: Specific validation error

Task: The email address omits the @ symbol. The translated message generically says Something went wrong. Write a plain-language diagnosis and explain what you would translate and what you would leave intact as markup or identifiers.

Model reasoning: Explain the actual issue in non-blaming language and state how to correct it. Correct the input and verify the error clears without leaving stale feedback. An effective answer asks whether the translated control’s visible wording and announced accessible name identify the same purpose. It also names the technical relationship that must remain intact and describes how a user can discover or correct a problem. Do not claim success based on a source-string inventory alone; check the browser-exposed result.

Practice 13: Live result count

Task: A search page updates from five to six results. The live-region announcement is hardcoded in English. Write a plain-language diagnosis and explain what you would translate and what you would leave intact as markup or identifiers.

Model reasoning: Translate the meaningful status and verify that updates are announced appropriately. Search twice and check that announcements are not duplicated or excessively verbose. An effective answer asks whether the translated control’s visible wording and announced accessible name identify the same purpose. It also names the technical relationship that must remain intact and describes how a user can discover or correct a problem. Do not claim success based on a source-string inventory alone; check the browser-exposed result.

Practice 14: Accordion help section

Task: A button expands a panel about payment information. The visible translation and aria-expanded state disagree after clicking. Write a plain-language diagnosis and explain what you would translate and what you would leave intact as markup or identifiers.

Model reasoning: Keep the label stable or intentionally update it and ensure expanded state is correct. Use keyboard activation and check whether the new content is reachable. An effective answer asks whether the translated control’s visible wording and announced accessible name identify the same purpose. It also names the technical relationship that must remain intact and describes how a user can discover or correct a problem. Do not claim success based on a source-string inventory alone; check the browser-exposed result.

Practice 15: Tab interface

Task: Tabs switch between timetable, fees and preparation guidance. All accessible tab names were translated as Information. Write a plain-language diagnosis and explain what you would translate and what you would leave intact as markup or identifiers.

Model reasoning: Give each tab a distinct action-or-topic label and preserve selected state and tab-panel association. Navigate by keyboard and inspect which panel is announced. An effective answer asks whether the translated control’s visible wording and announced accessible name identify the same purpose. It also names the technical relationship that must remain intact and describes how a user can discover or correct a problem. Do not claim success based on a source-string inventory alone; check the browser-exposed result.

Practice 16: Dialog heading

Task: A registration dialog has a translated heading. The modal’s aria-labelledby still points to the wrong element. Write a plain-language diagnosis and explain what you would translate and what you would leave intact as markup or identifiers.

Model reasoning: Connect the accessible dialog name to the correct visible heading. Open the dialog and inspect title, focus trap and close action. An effective answer asks whether the translated control’s visible wording and announced accessible name identify the same purpose. It also names the technical relationship that must remain intact and describes how a user can discover or correct a problem. Do not claim success based on a source-string inventory alone; check the browser-exposed result.

Frequently asked questions

What is an accessible name?

It is the concise label exposed for a relevant control or element, helping users of assistive technology identify its purpose. Browsers can derive it from visible text, native labels or particular ARIA naming mechanisms. The author should check what is actually computed.

In a live interface, verify the answer by inspecting the specific control’s computed accessible output and completing its real user task. A label’s translation is only finished when it identifies the correct action, remains aligned with visible language and supports recovery from common mistakes.

Should every button have an aria-label?

No. A button with clear visible text often already has an accessible name. Adding aria-label unnecessarily can override that text and create translation or voice-control mismatches. Use native semantics and visible text where possible.

In a live interface, verify the answer by inspecting the specific control’s computed accessible output and completing its real user task. A label’s translation is only finished when it identifies the correct action, remains aligned with visible language and supports recovery from common mistakes.

How are aria-label and aria-labelledby different?

aria-label provides a name string directly; aria-labelledby references content of other elements to contribute to the name. Both have specific name-calculation behaviour. Translate human-readable content while keeping reference relationships functional.

In a live interface, verify the answer by inspecting the specific control’s computed accessible output and completing its real user task. A label’s translation is only finished when it identifies the correct action, remains aligned with visible language and supports recovery from common mistakes.

What does aria-describedby do?

It associates additional descriptive text with an element, such as instructions or constraints. A description supplements the accessible name rather than replacing it. Translators should keep the name short enough for the control’s purpose and move extended guidance into suitable explanatory text.

In a live interface, verify the answer by inspecting the specific control’s computed accessible output and completing its real user task. A label’s translation is only finished when it identifies the correct action, remains aligned with visible language and supports recovery from common mistakes.

Why does the visible label need to match the accessible name?

Consistency helps screen-reader and voice-input users, and WCAG’s Label in Name requirement addresses visible text appearing in the accessible name. A translation that looks like Save but announces Send data can create practical confusion even when both phrases are grammatically correct.

In a live interface, verify the answer by inspecting the specific control’s computed accessible output and completing its real user task. A label’s translation is only finished when it identifies the correct action, remains aligned with visible language and supports recovery from common mistakes.

Can placeholder text replace a form label?

It is not a good primary labelling strategy. Placeholder text may vanish as people type and is generally a poor fallback for identifying a field. Provide a persistent, appropriately associated label and use placeholder text only for its suitable supporting role.

In a live interface, verify the answer by inspecting the specific control’s computed accessible output and completing its real user task. A label’s translation is only finished when it identifies the correct action, remains aligned with visible language and supports recovery from common mistakes.

Do I translate aria-expanded or aria-invalid values?

No. Their values communicate technical states to software and must remain conformant. Translate associated human-readable labels and feedback while preserving the state semantics and testing that the correct state is exposed.

In a live interface, verify the answer by inspecting the specific control’s computed accessible output and completing its real user task. A label’s translation is only finished when it identifies the correct action, remains aligned with visible language and supports recovery from common mistakes.

How should translated form errors be announced?

Use clear, specific messages that identify the problem and the correction, and expose them through accessible relationships and appropriate status mechanisms. Test when they appear and whether a keyboard or screen-reader user can find the affected field.

In a live interface, verify the answer by inspecting the specific control’s computed accessible output and completing its real user task. A label’s translation is only finished when it identifies the correct action, remains aligned with visible language and supports recovery from common mistakes.

Is an icon description always the right accessible name?

No. An interactive icon should generally be named for the function it performs, such as Close or Download, rather than its visual shape. Informative and decorative non-interactive images follow different text-alternative decisions.

In a live interface, verify the answer by inspecting the specific control’s computed accessible output and completing its real user task. A label’s translation is only finished when it identifies the correct action, remains aligned with visible language and supports recovery from common mistakes.

Should IDs and CSS classes be translated?

Not as ordinary editorial text. Technical identifiers connect elements and code; altering them without updating their references can break names, descriptions and behaviour. Localize the intended human-readable strings and maintain programmatic integrity.

In a live interface, verify the answer by inspecting the specific control’s computed accessible output and completing its real user task. A label’s translation is only finished when it identifies the correct action, remains aligned with visible language and supports recovery from common mistakes.

What if the control changes meaning after clicking?

Review the whole state transition. The label, state and any instructions should remain accurate before and after interaction. A toggle that shows a password, expands a panel or starts a process must not announce stale information.

In a live interface, verify the answer by inspecting the specific control’s computed accessible output and completing its real user task. A label’s translation is only finished when it identifies the correct action, remains aligned with visible language and supports recovery from common mistakes.

How can parents and teachers practice accessible translation?

Use a small practice registration form with labels, required fields, hints, an error and a success message. Translate it into a known target language, then complete it by keyboard and inspect the announced names and feedback. This turns terminology practice into an actual comprehension task.

In a live interface, verify the answer by inspecting the specific control’s computed accessible output and completing its real user task. A label’s translation is only finished when it identifies the correct action, remains aligned with visible language and supports recovery from common mistakes.

Authoritative sources and next reading routes

Use W3C WAI-ARIA Authoring Practices: Accessible Names and Descriptions, W3C’s alt decision tree for image-related decisions, and W3C’s form-control naming failure guidance. The principles in these materials are relevant beyond English but require actual language and assistive technology testing for each localized interface.

For language learning and precise wording, follow eduKateSG’s Vocabulary Learning Hub and How English Works. For directionality problems in Arabic or Hebrew forms, continue to HTML dir, bdi and right-to-left text. For selecting among actual translated website versions, see HTTP Accept-Language, Content-Language and Vary. For software string context and placeholders, consult GNU gettext translation context and plurals.

Final principle: a correct accessible translation is an interaction someone can understand and finish. Translate the intended purpose, use the right name and description relationships, preserve technical states and IDs, and test both success and failure. Accessibility is not an optional layer of editorial polish: it is part of the meaning the reader receives.