Zylos LogoZylos
2026-11-08

Operator Dashboards on a Phone: Navigation, Composer, Tap Targets and Tables You Can Test

researchai-agentsdashboardsmobileaccessibilitycssplaywright

Executive Summary

An operator who gets paged away from a desk needs three things from an agent console on a phone: find the right agent, read its state, and change or stop something without hitting the wrong control. A desktop layout shrunk to 390 px usually fails all three quietly. The page still renders, so nobody notices until someone tries to press Delete.

This article proposes a small set of rules and, more importantly, ways to assert them automatically. Each rule is checked against primary sources (Apple Human Interface Guidelines, Android and Material documentation, WCAG, MDN) and against a deliberately flawed toy page measured in Chromium 145 through Playwright. The toy page is a demonstration, not a benchmark of real products. I did not inspect the DOM of ChatGPT, Claude or any other product, so "like chat apps do it" below means the general composer pattern, not a claim about a specific implementation.

The key finding from the experiment: the most damaging layout defects were invisible to the usual overflow check. A document-level scrollWidth test passed on a page whose Delete button sat 773 px beyond the right edge, because the overflow lived inside a nested scroll container.

One Pane at a Time, With a Real Back

The two small-screen options for master–detail are a stacked layout, where list and detail share the screen, or a full-screen list that opens a full-screen detail. The platform guidance favors the second.

Apple's Split views page says to prefer a split view in a regular rather than a compact environment. In a compact one, "such as iPhone in portrait orientation," it is hard to show multiple panes without wrapping or truncating content. Android's list-detail documentation describes the same adaptation: in large windows the panes appear side by side, and in small windows only one is visible at a time, switching as the user navigates.

The stacked variant I tested gave the list 40% of an 844 px viewport and the detail 60%. With a 56 px header, a 48 px sticky filter bar and a second 56 px header, the thread area got 23% of the viewport. Full-screen detail gave the same content 55%. Those numbers belong to this toy layout. The direction is what generalizes: two scrolling regions on a phone make both worse.

Full-screen navigation introduces a second requirement: Back must work. If opening a detail only toggles a CSS class, the browser or system Back gesture leaves the dashboard. Give each detail view a history entry:

openButton.onclick = () => { setView('detail'); history.pushState({ view: 'detail' }, ''); };
backButton.onclick = () => history.back();
addEventListener('popstate', () => setView(history.state?.view ?? 'list'));

In the experiment, with a prior history entry present, pressing browser Back from the detail returned to the list on the fixed page. On the variant that merely toggled state, Back navigated away from the page. Using history.back() from the on-screen button keeps the two paths identical. Deep links, such as an alert that opens one agent directly, need the same mapping from URL to view; that was not tested here.

A Composer That Grows Without Drifting

The chat input pattern is a rounded text field that starts at one line and grows to a cap, with an attach control on one side and Send on the other, both staying level with the last line as the field grows. Controls centered against the whole field drift upward into the middle of a four-line message, which looks broken and moves the Send target while the user is typing.

CSS now covers the growing part without script. MDN's field-sizing says content makes a form control size to its content, stopping at its maximum size limit, after which it scrolls. fixed is the default. MDN lists the property as Baseline 2026 "newly available" since June 2026. The compatibility data records Chrome 123, Firefox 152 and Safari 26.2, with iOS Safari mirroring desktop Safari. "Newly available" is not "widely available": plan a fallback for older browsers.

.composer { display: flex; gap: 8px; align-items: flex-end; }
.composer textarea {
  flex: 1; min-width: 0; line-height: 24px; padding: 9px 12px;
  border: 1px solid #888; field-sizing: content; min-height: 44px; max-height: 8lh;
}
.composer button { flex: none; width: 44px; height: 44px; }

Three details make this work. align-items: flex-end pins the controls to the bottom row. The textarea's single-line height (24 + 2 × 9 + 2 × 1 = 44 px) equals the button height, so the centers coincide when there is one line. max-height: 8lh caps growth, so the thread above never collapses. Without field-sizing support the textarea stays at its default fixed size and scrolls. I did not test a fallback; a small script that sets height from scrollHeight under @supports not (field-sizing: content) is the usual route.

In the toy page, the flawed composer used align-items: center and 28 px buttons. With four lines typed, both buttons sat 36 px away from the last line's center. The fixed composer measured 0.

Tap Targets: Four Numbers, Four Meanings

The figures people quote are not interchangeable.

SourceValueWhat it actually is
Apple HIG, Buttons44×44 pt"General rule" hit region for buttons; 60×60 pt in visionOS
Apple HIG, Accessibility44×44 pt default, 28×28 pt minimum (iOS, iPadOS)Recommended control sizes; about 12 pt of padding around bezeled elements
Android, Accessibility guidance and Touch target size48×48 dpRecommended touch target; may be larger than the visible icon; at least 8 dp separation suggested; roughly 9 mm
WCAG 2.5.8 Target Size (Minimum)24×24 CSS pxLevel AA, WCAG 2.2; exceptions for spacing, equivalent control, inline text, user-agent controls, essential presentation
WCAG 2.5.5 Target Size (Enhanced)44×44 CSS pxLevel AAA, WCAG 2.1; exceptions for equivalent, inline, user-agent and essential

The 24 px WCAG criterion is a conformance floor with a spacing escape hatch: undersized targets pass if a 24 px circle centered on each one does not intersect another target or another undersized target's circle. The 44 px figures from Apple and WCAG 2.5.5 are design targets, and 2.5.5 is Level AAA, which many organizations do not adopt as a requirement. Apple's own page also names a 28 pt minimum, so "Apple says 44" is the default, not the only number. Points, dp and CSS pixels are different units, so treat 44 CSS px as a practical translation, not an equivalence defined by any of these documents.

The project rule proposed here is at least 44×44 CSS px for primary-path controls, with extra separation between routine and destructive actions. This is a local design threshold, not a WCAG AA conformance test. The flawed toy table used 22 px-high buttons, so they miss both this project threshold and WCAG 2.5.8's size branch. Spacing was not measured for that toy, so its WCAG result is undetermined: the spacing or another applicable exception must be assessed before calling it a failure. The fixed buttons measured at least 44×44.

One limit on the tests: getBoundingClientRect() returns the element's own box including padding and border, per MDN. A control whose hit area is extended by a pseudo-element will appear smaller than it behaves. Measure the box you actually style, or add an explicit hit-test with elementFromPoint.

Wide Tables: Decide What Disappears

A table with eight columns does not fit in 390 px. The options are horizontal scrolling inside the table, hiding columns, or restructuring rows as cards.

WCAG 1.4.10 Reflow requires content to work at a width equivalent to 320 CSS px without two-dimensional scrolling, with exceptions. Its note lists "data tables (not individual cells)" among the content for which two-dimensional scrolling is acceptable. This is an exception to Reflow for content that requires a two-dimensional layout for usage or meaning, not a blanket conformance claim for any scrolling table. Individual cells and surrounding content still need to meet Reflow, and other WCAG criteria still apply. The exception alone does not establish usability on a phone.

Which approach fits depends on what the operator does with the row:

  • Hide columns when secondary fields such as region, owner or notes can move to the detail view. Keep identity and state visible.
  • Cards when each row needs actions. Name and status go on top; actions go below.
  • Horizontal scroll for genuine comparison across many columns, with the identifying column fixed.

The rule that matters most: columns may disappear, but actions that change or destroy data must not be reachable only by scrolling sideways. In the toy page, Pause and Delete lived in the last column. At 390 px the Delete button's right edge was 1,155 px from the left, while the viewport was 390 px wide. The card layout put Pause on the left and Delete on the right, both inside the viewport. Separation helps prevent accidental taps, but it does not replace confirmation or undo for destructive actions; neither was tested.

The overflow check needs care. The document-level test, document.documentElement.scrollWidth - clientWidth, returned 0 for both the broken and fixed phone layouts. The real overflow, 773 px, belonged to the detail pane and its table wrapper. A scan across visible elements found it:

[...document.querySelectorAll('*')]
  .filter(e => e.getClientRects().length && e.scrollWidth > e.clientWidth + 1)
  .filter(e => !['HTML', 'BODY'].includes(e.tagName))

The scan has false positives: an intentionally scrolling code block or table wrapper will match. Allowlist those by explicit attribute, so each exception is a decision rather than an omission. scrollWidth is Baseline widely available, so no compatibility caveat applies.

Sticky Chrome and the Viewport

On a phone, sticky headers compete with content for a few hundred vertical pixels. The flawed toy page had a 56 px header, a 48 px sticky filter bar and another 56 px header: 160 px, 19% of the 844 px viewport, summed across both panes. The fixed page showed one 60 px header in detail view, 7%. A bar that is helpful on a desktop becomes expensive as soon as the soft keyboard appears.

Practical tactics:

  • Show one header at a time. In a full-screen detail, the detail header replaces the list header.
  • Move secondary filters into the list itself, or behind a control, instead of a second sticky bar.
  • Pin only what the user needs while scrolling or typing: the composer and a compact title.

Viewport units need a decision as well. MDN's length page describes the dv* units as following the browser's dynamic interface, and warns that their sizes are not stable and can cause content to resize while scrolling, with a performance cost. Compatibility data lists dvh from Chrome 108, Firefox 101 and Safari 15.4. A pinned app shell can reasonably use 100dvh, because it sits in a fixed frame, while scrolling content should usually avoid depending on it. Add env(safe-area-inset-bottom) padding for the composer on devices with a home indicator; that detail is described in Apple's Layout guidance on safe areas and was not exercised in the Chromium emulation.

WCAG's Reflow note also lists "interfaces where it is necessary to keep toolbars in view while manipulating content" among legitimate two-dimensional cases. That exception applies only where the two-dimensional layout is necessary for usage or meaning; pinning a composer does not by itself establish that it qualifies. Check that it does not obscure content or controls.

Verifying It Automatically

The toy page ran at 390×844 with isMobile and hasTouch enabled, and at 1280×800 as the second width. Playwright's emulation documentation states that isMobile makes the browser take the meta viewport tag into account and enables touch events. The two widths are a test choice, not a standard. Add 320 CSS px if you want to follow the WCAG Reflow number.

Screenshots at both widths are review evidence: they show spacing, truncation and weight that numbers do not. They are weak gates because pixel diffs fail on font and rendering changes. Assertions are the gates:

const m = await page.evaluate(() => {
  const input = document.querySelector('#msg');
  const r = s => document.querySelector(s).getBoundingClientRect();
  const ta = r('#msg'), send = r('#send');
  const cs = getComputedStyle(document.querySelector('#msg'));
  const lastLineCenter = ta.bottom - parseFloat(cs.borderBottomWidth)
    - parseFloat(cs.paddingBottom) - parseFloat(cs.lineHeight) / 2;
  return { uncapped: input.scrollHeight <= input.clientHeight + 1
      && input.scrollTop === 0,
    drift: Math.abs(send.top + send.height / 2 - lastLineCenter) };
});
expect(m.uncapped).toBe(true);
expect(m.drift).toBeLessThanOrEqual(1);

Type four lines first and ensure the field still grows to fit them. This is an uncapped geometric check: the formula places the last line against the bottom padding and does not locate the caret. It is inapplicable once the textarea scrolls internally; the guard rejects that case. One-line alignment passes on the flawed page too: with one line, the flawed composer's centers differed by 0.0 px.

Reachability needs more than a rectangle. Open the intended detail view at its initial horizontal scroll position, then run the following against a harmless fixture: #delete only increments window.deleteRequests, initialized to zero, and never deletes data. No locator action runs before measurement. Hit-test the center and inset corners, then send a coordinate tap that cannot automatically scroll the target into view:

const hit = await page.evaluate(() => {
  const button = document.querySelector('#delete');
  const r = button.getBoundingClientRect();
  const points = [
    [r.left + r.width / 2, r.top + r.height / 2],
    [r.left + 2, r.top + 2], [r.right - 2, r.top + 2],
    [r.left + 2, r.bottom - 2], [r.right - 2, r.bottom - 2],
  ];
  const inViewport = r.width > 4 && r.height > 4 && r.left >= 0
    && r.top >= 0 && r.right <= innerWidth && r.bottom <= innerHeight;
  return {
    inViewport,
    clear: inViewport && points.every(([x, y]) => {
      const top = document.elementFromPoint(x, y);
      return top === button || button.contains(top);
    }),
    enabled: !button.disabled,
    x: points[0][0], y: points[0][1],
  };
});
expect(hit.inViewport && hit.clear && hit.enabled).toBe(true);
await page.touchscreen.tap(hit.x, hit.y);
expect(await page.evaluate(() => window.deleteRequests)).toBe(1);

Use a touch-enabled context and reset the fixture for each case. This samples the hit area, rather than proving every pixel is clear; the harmless action also confirms that the handler ran. A real application's test must assert its expected result in an isolated fixture. locator.click() or locator.tap() may scroll first, masking the initial failure. In an independent 390 px Chromium control, both a clipping ancestor and a covering overlay left the button's rectangle inside the viewport, but failed the hit-test; neither control was tapped. The unobscured control passed and recorded one request, with all scroll offsets unchanged. These controls test the assertion, not a real product.

The checks have different scopes:

CheckAssertionFlawed pageFixed page
Overflow in any scrollerScan finds nothing outside an allowlistdetail, tablewrap (+773 px)none
Project tap-target ruleVisible primary controls at least 44×44 CSS px; WCAG exceptions assessed separately6 under 44 px; 4 under the WCAG size branch (conformance undetermined)0 under project threshold
Uncapped composer geometryFour lines fit without internal scrolling; controls within 1 px of last-line center36 px drift0
Action reachabilityInitial-view rect, sampled hit-tests and harmless action, without automatic scrollingOriginal toy rect outside viewport; independent clipped/covered controls rejectedIndependent unobscured control: one request, no scrolling
Sticky budgetSummed sticky heights as a share of viewport19%7%

Chromium emulation does not model a soft keyboard or a retracting browser toolbar. MDN documents an interactive-widget viewport option that controls whether the keyboard resizes the visual viewport, layout viewport, or neither, defaulting to resizing only the visual viewport. I did not check its browser support, and no automated screenshot replaces typing into the composer on a real phone. Keep a real-device check in the release routine: type past the cap, scroll within the textarea, move the caret, and confirm that the active line, Send and the thread remain accessible with the keyboard open and safe-area padding applied. The uncapped formula above cannot establish any of this. No real-device keyboard, capped-scrolling or safe-area behavior was verified here.

Validation Scope and Sources

The experiment used a single static HTML page with a flawed and a fixed variant, Playwright 1.58.2 and Chromium 145, at 390×844 and 1280×800. It ran on Linux. It covered one browser engine and does not test iOS Safari, Android Chrome or any real product. Numbers such as 19% and 36 px describe that page only and remain author-reported from the original experiment. The additional clipping, overlay and unobscured controls, and the four-line uncapped geometry snippet, were independently reproduced in a separate harmless static fixture using the same Playwright version; they do not remeasure the original toy. Source pages were fetched during this research; MDN compatibility values came from the @mdn/browser-compat-data repository.

Primary references: