ApiaryActiveLive
Try: pause · settings · learn · wipe
← Community / Reading Room
KT
craft · 25 min read

Keep the Units Attached to the Number in a Complex Web Table

A community food hub posts a table comparing warehouse capacity. The page shows two weeks across the top, then inbound crates and total weight below each…

AI disclosure: Drafted with AI assistance for Apiary. The food hub and its measurements are fictional. The markup and automated fixture do not substitute for browser or assistive-technology verification.

A community food hub posts a table comparing warehouse capacity. The page shows two weeks across the top, then inbound crates and total weight below each week. The first row is the North room. Visually, the labels appear clear when the table fits on a desktop. Navigating straight to the last numeric cell, however, gives a reader just “340.” Is that 340 crates, 340 kilograms, the value for the North room, or a total for the whole building? A hover tooltip has the unit, but phone and keyboard users can't reliably reach it. A spreadsheet export drops the combined headings entirely.

This is a semantic design problem, not just a font problem. A measurement is a number plus a unit plus the dimensions that identify the observation. Those dimensions could be time period, place, method, or product. A good table lets a reader recover the meaning of a cell without reconstructing the entire screen. It also lets the editor catch a mislabeled value before the spreadsheet becomes a web page and a CSV and three screenshots of uncertain origin.

Begin with a measure dictionary nobody has to memorize

A table is the last step in a chain. A warehouse report starts with a source field, applies a calculation or grouping, and places the result below a label. The visible top-of-column words cannot rescue a report that never defined what it measures. Assign each measure a plain language label, unit, aggregation rule, expected data states, and display convention. If a source contains packages while the table shows individual pieces, document how conversion is authorized. A well-named value is easier to preserve through sorting, responsive changes, exports and schema migrations.

A measure dictionary shouldn't be a glossary of abbreviations. It should answer the questions a reviewer would ask about one cell. For a fictional equipment library, “7” can represent seven loaned boxes currently out, seven individual kits across those boxes, or seven completed loans during the reporting week. These definitions survive a formatting change; they can be attached to a stable field identity. Changing the word “boxes” to “units” on the screen does not change an upstream denominator. If an internal source renamed a column without changing its meaning, that is a different kind of revision from a genuine change in counting rule.

List display and data representation separately. A stable canonical data record can contain a decimal quantity and a unit code. The rendered table can use normal spacing, appropriate language, and a visible word such as kilograms. A screen reader's pronunciation of a short unit may depend on language and voice. Test with supported readers and choose wording people can understand. Expanding kg in a measure label may be a better fix than creating a new hidden name for every repeated number. Where a measure legitimately switches units by row, plan for the row-level association and explicit value display instead of relying on a fixed heading.

The dictionary also helps when a page must distinguish similar-looking rows. An item called “Unknown weight” is not a source measure called “weight, unknown value.” Assign labels to entities, quantities, states, and bounds. If the table shows a subtotal, name the grouping scope so a user who lands on that row doesn't assume it represents the entire dataset. When naming a field, imagine somebody reading its value out of order and receiving no visual context from adjacent columns.

Keep the dictionary close to the fixtures as the table evolves. When staff decide “weekly count” should mean operations logged in the selected local week instead of operations completed in it, record that definition and update misleading older labels. A change like that affects both screen and export. It can be more consequential than any CSS change because readers can compare old and new outputs that now measure different things. Make that change visible rather than treating it as a copy edit.

Start by naming one cell in plain sentences

Choose the hardest value in the table and write how someone should understand it. The editor's intended answer might be: “For the North room in week 2, inbound mass was 340 kilograms.” That sentence gives you four necessary pieces: room, period, measurement, and unit. If the number is estimated, revised, or missing, there is a fifth piece: the state or quality of the observation.

Now map those parts to the page. The room may be a row header, the week a grouped column header, the measure and unit a leaf header, and the value an ordinary cell. A sentence that cannot be assembled from the available labels is a warning that the design is missing context. Put the unit close to the measure, such as “Inbound mass (kg).” A lone paragraph at the bottom saying some figures are in kilograms may be too remote, especially if neighboring columns use crates or pounds.

Don't fix a heading issue by adding an aria-label to every number. That can duplicate visible text, introduce inconsistencies, or lose the table-navigation relationships that help readers move across a grid. First use native table elements and meaningful header associations. The W3C explanation of Info and Relationships describes why relationships conveyed visually need to remain available in other ways. It doesn't promise a particular audio phrase for every reader or mandate the same technique in every table.

Preserve missing, withheld and inapplicable values

Meaning can disappear even when labels are perfect. In an invented food-hub inventory, one cold room is included in the system but its inspection quantity is not available. A second is known to contain zero boxes. A third does not stock that item under the current program at all. Writing a dash in all three cells makes the surface tidy, but the states are meaningfully different. A small ledger can distinguish measured zero, unavailable, and not applicable, each with an approved visible vocabulary.

Start by deciding whether the table should represent withheld information. If it should, use a clear state label without embedding details that someone viewing the table is not authorized to see. A footnote claiming “hidden because of account X” could expose precisely the relationship being withheld. A missing result from a failed import is yet another state. The point is not to display every reason in the default grid; it is to avoid letting one coded blank mean whichever story the reader expects.

Give meaningful text to exceptional states. A supplement might describe why a numeric range was withheld or how to request an approved correction. Don't require someone to decode punctuation from a legend many screens away. If a visible marker remains useful, it can travel with text or a readily discoverable explanation. Test whether the exact scenario makes sense when navigating one cell at a time. “No figure reported” should not become a heard “zero” in an accessibility label compiled from a coercing formatter.

Make sorting behavior reflect the defined states. Numeric zero belongs in the numeric comparison. Unavailable values can go in a labeled lower group or remain in a predictable location. A column comparing “no data” with 0.00 should not quietly cast one to the other. If a subtotal omits missing readings, disclose which applicable quantities are present. A partial total should not look identical to a complete total when it can shape an operational choice.

Say an invented facility has readings 12 kg and unknown for two eligible rooms; a third room is not applicable. Reporting a measured subtotal of 12 kg for one of two eligible rooms is defensible. Reporting all rooms total 12 kg is not. If the exact outcome can only be found in a data note, move the most consequential caveat into the caption, footer or adjacent summary with reliable reading order. Keep the state distinction in the CSV or accessible alternative too. Exporting all three states as blank reintroduces the same problem one layer later.

Make the simplest table that preserves the comparison

If a data summary has one header row and one set of row labels, native table headers with clear scope may be enough. Avoid forcing a two-level table when simple headings would produce a better reading experience. For a summary with four columns, “Week 1 crates,” “Week 1 mass (kg),” “Week 2 crates,” and “Week 2 mass (kg)” is repetitive visually but semantically straightforward. A table of twelve weeks might benefit from grouping, or might reveal that readers prefer a different structure entirely.

A complex table is justified when several values must be compared together and the hierarchy helps. The food hub needs to compare both rooms and both weeks on one screen. In this case, grouped week headings and two measures under each make a compact desktop result. Use W3C's multi-level header guidance and its irregular-header examples to choose a pattern appropriate to your grid. A headers attribute referring to header IDs is one explicit approach in complicated cases.

When you add sections or totals, ask whether they belong to the same comparison. A monthly report may include a weekly intake grid and a separate monthly cumulative total. Mixing them can complicate unit and period interpretation if the same column suddenly refers to a different concept. Separating the two tables can preserve meaningful boundaries, with an explanatory sentence identifying how the summary relates to the original measure. More compact isn't always easier.

Model a date, zone and unit that can survive a reshuffle

Two periods and two measures can produce a surprisingly complicated set of intersections. Imagine a nonprofit equipment desk tabulating scheduled collection and actual collection for three locations. A group heading says “November 4 to 10”; its leaf columns say planned pickups and collected cases. The first is a count of appointments, the second physical containers. Even identical numbers have different units. If a mobile view suppresses the group header but keeps values, repeated leaf headings do not tell the reader which period they're in.

A reliable display transition names the fields after the layout change. In a stacked view it can put a location heading, then a date-period heading, then labels for each paired value. A screen intended as a real table should retain a structure that behaves as a table with appropriately associated headings. A different rendering intended as a list or a description structure can succeed if it preserves the questions readers must answer about each item. Do not assume a visual rearrangement of cells creates either navigable experience.

Time periods deserve clear conventions at boundaries. If evidence spans different local time zones, the range label must describe whichever reporting basis is authorized. “Week ending Sunday” may be enough for an internal filing table with known practice. A cross-location one may need explicit dates and a note about clock basis. Avoid repeating a long note in every accessibility label if a caption or distinct heading can give the group shared context. Then check that a user entering one group can still locate the important basis.

Try a deliberately awkward counterexample: reorder periods after filtering while a leaf heading preserves its old generated identifier. All the visual words remain in the correct order; an explicit link from a data cell now references the old group's header. A reviewer who scans a screenshot can approve it. A live markup query checking ID existence can also pass because the wrong header still exists. You need a test that validates which owner, period, and measure each data cell resolves to, not simply whether attributes were generated.

A small synthetic matrix helps. Mark one unique cell with an outlier so a tester can find it in both visual and nonvisual navigation. Ask them, “What period and measure does this number represent, and who does it refer to?” Keep a counterpart with identical value under the other date so merely hearing the number won't accidentally pass. Use observed answer context rather than needlessly insisting on an exact speech transcript from every assistive technology.

An explicit association fixture

Here's the core of the food hub table. The headings repeat units intentionally. The example only includes two rooms to keep it readable.

<table id="intake">
  <caption>Inbound delivery by room and week</caption>
  <thead>
    <tr>
      <th rowspan="2" scope="col">Room</th>
      <th id="w1" colspan="2">Week 1</th>
      <th id="w2" colspan="2">Week 2</th>
    </tr>
    <tr>
      <th id="w1-crates" headers="w1">Crates (count)</th>
      <th id="w1-mass" headers="w1">Inbound mass (kg)</th>
      <th id="w2-crates" headers="w2">Crates (count)</th>
      <th id="w2-mass" headers="w2">Inbound mass (kg)</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <th id="north" scope="row">North room</th>
      <td headers="north w1 w1-crates">29</td>
      <td headers="north w1 w1-mass">290</td>
      <td headers="north w2 w2-crates">34</td>
      <td id="north-w2-weight" headers="north w2 w2-mass">340</td>
    </tr>
    <tr>
      <th id="south" scope="row">South room</th>
      <td headers="south w1 w1-crates">24</td>
      <td headers="south w1 w1-mass">258</td>
      <td headers="south w2 w2-crates">0</td>
      <td headers="south w2 w2-mass">Not recorded</td>
    </tr>
  </tbody>
</table>

The HTML table specification describes table header elements and associations. The fixture puts row, period, and leaf measure directly in the cell's explicit association list. It doesn't ask readers to infer that a column called “Inbound mass” belongs under Week 2 because of its position above a decorative divider. A header ID must identify a relevant header in the table, not an arbitrary visible title outside it. IDs should be unique even if a page shows several copies of a component.

Notice the South room's last two values. The sample record says zero crates and no recorded weight. A source-system convention might let you calculate that a validated zero crates means zero weight; the fictional system in this guide makes no such guarantee. Keep “Not recorded” readable rather than using a dash with no visible key. Explicit missing-data language is particularly important in exports. Numeric zero should stay numeric zero and not be conflated with unknown.

Check the generated markup, not just your template

Real table components often build associations from translated labels, row indices, or data fetched at runtime. An example fixture can work beautifully on paper while the component emits a duplicate ID after a filter changes. A basic browser DOM check can detect the simplest mistakes. Paste the example into an isolated HTML file, open it, and run a check like this in the browser console:

const table = document.querySelector("#intake");
const ids = new Map();

for (const h of table.querySelectorAll("th[id]")) {
  if (ids.has(h.id)) throw new Error("Duplicate header ID: " + h.id);
  ids.set(h.id, h);
}

for (const cell of table.querySelectorAll("tbody td")) {
  const refs = cell.getAttribute("headers")?.trim().split(/\s+/) ?? [];
  if (refs.length !== 3 || new Set(refs).size !== refs.length ||
      !refs.every(id => ids.has(id))) {
    throw new Error("Bad table reference for " + cell.textContent.trim());
  }
}

const target = table.querySelector("#north-w2-weight");
const labels = target.getAttribute("headers").split(/\s+/)
  .map(id => ids.get(id).textContent.trim());

if (labels.join(" / ") !== "North room / Week 2 / Inbound mass (kg)") {
  throw new Error("Misassociated example cell");
}

This test is specific to this fixture: it expects exactly three references for each body data cell. Another correct table may need a different count or use normal scope associations instead. The sample does not verify accessible speech, document-wide uniqueness, or whether the source data actually says 340 kg. Production tests can confirm identifier uniqueness across all rendered components and compare more representative values to their intended headers.

Test not only that linkages exist but also that they're correct. Every cell can point at a real ID and still use Week 1 for Week 2. Use expected labels directly from a small known fixture rather than deriving them with the same template helper that might be broken. A deliberate test mismatch, like changing the last cell to headers="north w1 w2-mass", is useful for checking that your tests reject a structurally plausible but wrong result.

Check what happens when a person uses it sideways

Horizontal scrolling can preserve a useful comparison that would otherwise become a long stack of records. It also creates a problem: a user might encounter a value after the row label has scrolled offscreen. A sticky first column can help a visual reader, provided it isn't a second semantically exposed copy of every row header. Test the browser with zoom and narrow width, and check whether the interaction is discoverable without relying on a faint gradient alone.

A sticky group header can overlap the first row or become hidden behind a top bar as zoom changes. That is both a layout bug and a loss of context. Focus a control in the scrolling region and verify it doesn't move the selected row under an opaque header. If a complex widget adds frozen cell replicas for performance, inspect what appears in the reading order. Avoid repeating row data unexpectedly or using offscreen duplicates to create misleading associations.

For a synthetic warehouse report with 16 columns, ask a colleague to answer “which site had the largest inventory of a chosen product last week?” and “what was the value in the following week?” A compact selected-metric view may beat a horizontal table for the first task; the comparison table may still be valuable for the second. The best alternative view may expose a few intentional filters, not require staff to inspect a massive visual grid. Both views need the same unit discipline.

Check whether row labels remain informative under sorts, pagination, filters and edits. A row heading using a visible position like #5 isn't a stable entity. Sorted output can leave #5 on another item. If the interface shows a rank, give it a ranking label and don't use it as the row's identity. Likewise, a row header truncated to the same prefix for every location may be visually fine for people who know the order until a sort changes it. Provide a way to read the complete label and ensure the underlying association doesn't lose the meaningful distinction.

Observe how the table is navigated

After the DOM checks, use a real browser and a screen reader combination you support. Enter the table from a nearby heading, move down a column, then move horizontally across a period boundary. Verify that a reader can recover which room, period, and measure each target corresponds to. Some assistive technologies announce repeated headers only when they change, so don't require an identical spoken string at every movement. Test whether the reader can answer the intended question from the navigation, and record the environment.

Test a narrow viewport with magnification and keyboard input as well as ordinary touch. A horizontally scrollable region may preserve the grid structure, but the reader must be able to reach and scroll it using available input. Visual scroll affordances, text that stays readable, and frozen labels if appropriate can make a big difference. A drop shadow indicating that more columns exist may help sighted readers, but it cannot replace access to the content itself.

Do not assume the browser retains table semantics unchanged after a transformation that turns rows into cards or cells into blocks. If a phone experience needs cards, consider presenting an explicitly designed alternative with real labels. A card that says “North room,” then “Week 2 mass: 340 kg,” may be excellent for lookup, though it gives up some side-by-side comparison. Avoid an alternative that creates a second copy both exposed at once to screen readers, or that displays labels solely through CSS without checking how they are conveyed. A simplified presentation should make its own meaning available.

Make filtering, sorting, and downloads obey the same meaning

Filtering can hide a room while leaving its header ID in generated elements. Sorting may reassign a row index without repainting associated cell references. A translated label may change whereas the ID must remain stable. These are predictable regression targets. Test the before state, apply the actual filter or sort, and repeat the header assertion on the changed table. Keeping stable record identifiers separate from localized heading text helps prevent a display update from changing semantic references.

Be careful with aggregation. If a column changes from inbound mass to combined mass, the heading must change with it. When a cell contains an estimate, show the state in a way that survives contrast choices and export. Don't rely on a pale tint while printing the same number string. If a kilogram figure is rounded in the table and an export carries more precision, say what the display rounds and leave the export unit intact.

A flat CSV can't preserve the nested HTML header relationships by itself. Use unambiguous headings such as week_2_inbound_mass_kg, or use explicit long-form records containing room, week, measurement, unit, and value. Include a status field for unavailable readings when downstream processing needs to distinguish empty from zero. An exported number mass without a unit reintroduces exactly the ambiguity you fixed in HTML.

Prove that export is a deliberate interpretation

A flat CSV does not carry hierarchical header semantics automatically. You can preserve the information using explicit fields such as location ID, label, period start, period end, measure key, unit code, state and value. Or you can generate unambiguous columns when each file has a fixed small set of periods and measures. Pick a design according to how users will actually load it. A file with two columns both named Total and no explanation relies on whatever physical order the recipient assumes.

Think about numeric representation before shipping. A spreadsheet may treat a date-like ID as a date, parse decimal symbols differently, or hide a meaningful leading zero. That is not only a display issue. It can change later joins. Keep clear machine field definitions and a short companion note when practical. Use examples that show the exact nonnumeric item code and at least one precise decimal that should not be rounded to a displayed value in the data export.

For a fictional variant, the page displays 12.3 kg rounded, while the validated source is 12.34 kg. If customers need the exact quantity, exporting 12.34 can be appropriate with an explanation. If exporting the shown value is the intended feature, label that as display precision. Either way, the unit travels. The wrong outcome is exporting 12.34 with no unit and a worksheet that previously used pounds. Use a source-to-screen-to-export fixture so the same datum can be verified through the whole route.

Range and subtotal columns deserve consistent naming too. A subtotal in the exported view can represent the filtered rows if that is its definition. If the download includes all rows while the screen shows five, the two totals can legitimately differ, but the surface should tell people they requested the complete dataset. A print view needs the same attention. Printing a broad table across multiple pages with the group headings only on page one makes subsequent numbers difficult to identify.

Check source transformations before arguing about the interface

The page builder isn't always where the unit changes. Imagine the original data has a unit column but the editor imported two files with the same heading “inbound mass,” one calibrated in kilograms and one in pounds. A presentation component that appends kilograms everywhere can create a wonderfully accessible falsehood. The review should trace one number back through a source row, a documented transformation, and the rendered value. If you want normalization, normalize explicitly and preserve the original unit in the source record. Do not put a conversion only in a CSS-generated suffix or a spreadsheet format string.

A good fixture puts the two possibilities in tension. Give the importer North week 2 with 340 kg and a second test record with a value in a different supported unit. Verify the latter converts under an approved rule, or verify it rejects the row if conversions are out of scope. Test the case in which units are missing as well. An absent unit is more like an unknown observation than an instruction to assume the default. Label duplicate region names with additional record context when they really belong to different warehouses, but don't make the reader learn internal record IDs. IDs are for reproducible joins; labels are for meaning.

The distinction between table totals and null values is another data issue. If the reader sees a total of 340 kg across rooms, it could mean “known sum of recorded values” while the South room weight is unrecorded. A label saying “Hub total” implies completeness this result doesn't have. Say “Recorded total” and include the missing scope, or withhold the sum until you meet the reporting rule. In a demand chart drawn from the same data, don't fill the unknown weight with zero to make plotting easier. An informative label in one view doesn't absolve a misleading transformation in another.

Run two kinds of automated checks before the human review

A structural check can detect duplicate IDs, missing registered headers, unknown units, columns generated with empty labels, and measure associations that differ from the tested fixture. It won't determine whether a spoken route is pleasant or whether a user can find the one number they want. Conversely, a short screen-reader spot check can catch a bad experience without proving all cells stayed correct after a complex sort. Run them together rather than forcing one to substitute for the other.

A cheap semantic check walks expected cells and compares effective context to the declared tuple of row, period, and measure. For explicit associations, it resolves the referenced elements and compares meaningful identifiers. For simpler native tables, use the rendered structure expected under the relevant semantics and test an explanatory path with supported technology. Don't assume a text extraction library calculates browser accessibility relationships exactly. Match the method to what it actually verifies.

In a synthetic test, intentionally build a case with a data cell referencing the wrong found header and another with a missing header ID. The first tests meaning; the second tests structure. If your check misses either, change it before declaring the automated check covers the component. Test the state after paging, sorting, or applying a saved filter, not only its initial static DOM. A first rendered page with no interaction doesn't exercise the code that frequently regenerates header groups.

A small manual record might identify browser, assistive technology, grid revision, entry point, test question and observed context. A difference in speech order may be fine when users can recover the relevant information easily. Document meaningful mismatches such as “month not exposed on entry, cannot identify which repeated weight is current.” Don't try to patch exact pronunciation line by line while the table structure remains wrong.

Put a failure receipt next to the code

A tightly scoped report is more actionable than “screen reader issues.” Example: “On Firefox with the current supported reader, moving right into North W2 mass preserves North and mass (kg), but the transition from W1 to W2 does not reveal the new week after the sort action. Independent DOM assertions show the heading ID exists and the active associated ID is still w1.” This tells the implementer to reproduce the same interaction and inspect the actual reference, not just lengthen every label.

If the DOM maps to w2 and the supported assistive client still doesn't offer the needed context, try the simpler flat header test. A design with less structural cleverness can be more reliable for the audience. Confirm the replacement answers the same lookup task and retains useful comparison. Add one note to the component documentation describing why the simpler approach was chosen so a later style refresh doesn't unknowingly restore the difficult version.

Avoid claiming universal compliance from a single synthetic table. State which table variation was checked, which source values were traced, which viewport and client were used, and which export passed. A very small acceptance matrix is still substantive if the hardest cases were selected carefully.

Give the complaint a small reproduction

A real user might say, “I can't tell which pounds number I'm in.” That is better evidence than a generic promise of future compliance. Reproduce the observed path with the practical fixture, not a screenshot selected because all the labels happen to fit. Note whether the issue happened after a filter, in a pinned view, through navigation, or in a printout someone else generated. Those clues tell the next teammate which surface to repair.

Write the smallest correction that restores the meaning. If a section heading disappeared during responsive rearrangement, put the correct period context in the new logical grouping. If the cart counts were actually cases, correct the label and confirm the data source before changing code that computes the value. If the original measure was ambiguous, ask its owner rather than blindly preserving an incorrect legacy heading. A good fix leaves enough record to explain which interpretation became reliable.

A closeout can say, “Tested two week groups, unit context for both inventory measures, and one not-applicable state after filter and print. Screen navigation checked with the named combination; other combinations not sampled.” That is stronger than “accessible verified” after running a generic checker. Keep the units attached to the work people actually do, and each tool, visual or otherwise, can carry the same meaning forward.

Test a unit change like a product change

A weatherlike dashboard can show one set of measurement values in kilograms and another in pounds. Don't let an interface preference rewrite a stable field or mix units inside a single same-unit column. Start with a literal unit control whose state is visible, then check that applying it changes heading, values, precision, and exports as advertised. Decide whether the exported file uses source units or current display units. Users may want one or the other. The failure is pretending the download has no unit policy.

For a synthetic report, compare one dimensionless count and one measured weight. When switching weight from kilograms to pounds, the number of boxes must stay put. A footer summarizing weight should follow the same conversion and rounding convention as the body, or explain the difference if a trusted source specifies one. Hover hints and saved views need the same inspection. An old example beneath the table can continue to say kilograms while the current field shows pounds; if it isn't clearly an example it will send readers back to the wrong interpretation.

If filtering changes a mixed-unit population into one apparent unit, don't infer that the whole underlying measure changed definitions. A supplier search could show only items priced per case today and reveal pieces tomorrow. In a single shared table, pair a rate with its unit and denominator. The headings should explain that the column contains “unit price with order basis,” not static dollars per piece. Where readers need a true comparable rate, define a separate calculated column with a checked derivation. Do not sort a raw pile of incomparable unit prices as if the highest number is necessarily the most expensive equivalent.

A strong regression fixture contains an intentionally easy false positive: a value exactly 1 that remains the same in the count while another amount visibly changes under conversion. The reviewer has to name which changed and why, not simply see a switched abbreviation. Refresh after saving the preference and read another page or an export. Confirm whether the unit basis persisted or intentionally reset. A screen that remembers filter and sort but silently changes the numeric basis can make a before-and-after comparison meaningless.

A release checklist for one real table

  1. Pick three values: a normal number, a missing value, and a value at the boundary between grouped columns.
  2. State what each value means in an independent fixture.
  3. Confirm native table, caption, and associations or choose a simpler structure.
  4. Verify generated output after one sort and one filter.
  5. Navigate the table with requested assistive technology on a real browser.
  6. Check portrait behavior, zoom, and the corresponding download.
  7. Save an example symptom and result with the actual page revision and environment.

The checklist should tell you where evidence stops. “The DOM links resolve” does not prove correct spoken output. “It sounded right once on desktop” does not prove the mobile version or CSV kept the units. “All figures are labeled” doesn't show the source reporting process was correct. Each claim needs its own check, and a small-team release can record them without pretending every check covers every client.

The final question is the same one we started with: if a member lands on 340, can they discover what the number means? It belongs to the North room, says something about week 2, and measures mass in kilograms. Put those facts into the table's structure rather than asking every reader to piece them together from where the numbers happened to appear.

Frequently asked
What is Keep the Units Attached to the Number in a Complex Web Table about?
A community food hub posts a table comparing warehouse capacity. The page shows two weeks across the top, then inbound crates and total weight below each…
What should you know about begin with a measure dictionary nobody has to memorize?
A table is the last step in a chain. A warehouse report starts with a source field, applies a calculation or grouping, and places the result below a label. The visible top-of-column words cannot rescue a report that never defined what it measures. Assign each measure a plain language label, unit, aggregation rule,…
What should you know about start by naming one cell in plain sentences?
Choose the hardest value in the table and write how someone should understand it. The editor's intended answer might be: “For the North room in week 2, inbound mass was 340 kilograms.” That sentence gives you four necessary pieces: room, period, measurement, and unit. If the number is estimated, revised, or missing,…
What should you know about preserve missing, withheld and inapplicable values?
Meaning can disappear even when labels are perfect. In an invented food-hub inventory, one cold room is included in the system but its inspection quantity is not available. A second is known to contain zero boxes. A third does not stock that item under the current program at all. Writing a dash in all three cells…
What should you know about make the simplest table that preserves the comparison?
If a data summary has one header row and one set of row labels, native table headers with clear scope may be enough. Avoid forcing a two-level table when simple headings would produce a better reading experience. For a summary with four columns, “Week 1 crates,” “Week 1 mass (kg),” “Week 2 crates,” and “Week 2 mass…
References & sources
  1. Apiary Reading Room — Open, cited knowledge base — funded to keep bee & practical research free.
From the Apiary Reading Room. Opinion & editorial — not financial advice. We don't overclaim.
More from the Reading Room