Most dashboard design advice assumes a person sitting seventy centimeters from a monitor, giving the screen their attention for minutes at a time. A home control panel gets none of that. Someone walks past it, glances, taps once, and keeps walking. What survives that?
This extends our dashboard design patterns hub into a domain with constraints no SaaS product has: viewing distance measured in meters, sessions measured in seconds, and devices that can be in four states rather than two. Where the earlier guides argued from principle, this one shows its arithmetic. The sums are short, and you can rerun them with your own distance and your own panel.
TL;DR: Design home control panels around a one-second glance from two meters away. Give every device four states (on, off, unavailable, stale), each marked by more than colour. Group by room. Size text by visual angle rather than by habit, which puts body copy near 45px and primary values near 94px at CSS reference pixels. Make touch targets physical (around 12 mm). Build the dark theme first, and compute its contrast instead of eyeballing it.
Why Four States Instead of Two?
Here's the constraint that catches every designer coming from web products. A toggle in a SaaS app is on or off. A light in a house is on, off, unavailable, or stale, and the last two aren't edge cases. They turn up in any real installation sooner or later.
Unavailable means the panel has lost contact with the device. Home Assistant, a popular open-source hub, defines it as the entity being unable to provide its state: the hub can't reach the device or service, or the integration isn't set up. It also has a separate unknown, which means the entity has no value for its state. Showing either as "off" is a lie, and it's a lie the user discovers by tapping and watching nothing happen.
Stale is different, and it isn't a state the hub hands you. It's something you derive from timestamps. Home Assistant's state object carries last_changed, which only moves when the value moves, and last_reported, which moves whenever the device reports, even with the same value. Measure staleness from the wrong one and a thermostat holding a steady 21.5 degrees for three hours looks dead while it's still reporting on schedule. Use last_reported, and show its age on the card.
There's a catch in the stock Tile card. Its state_content option, as the current docs describe it, takes state, last_changed, last_updated or any attribute of the entity. last_reported isn't in that list, so the one timestamp that proves a device is still talking has to come from a template sensor or a different card. Check the version you run before you promise the "41 min ago" line from the table below.
Why does a design guide care about timestamps? Because the Nielsen Norman Group defines its first usability heuristic, visibility of system status, as how well the state of the system is conveyed to users. A card that says "off" for a lamp the panel can't reach conveys the wrong state, which is a failure of exactly that. NN/g's own example is a wish-list item that becomes unavailable: show its status, don't let it vanish silently. Be fair to the source, though. That article never mentions stale data or offline devices. Carrying the heuristic over to a wall panel is my argument, not theirs.
| State | Visual treatment | Text |
|---|---|---|
| On | Filled card, accent colour, filled circle | Value plus "On" |
| Off | Muted fill, solid border, hollow circle | "Off" |
| Unavailable | Transparent, dashed border, warning mark | "Unavailable" |
| Stale | Muted fill, dotted border, italic value, clock mark | "41 min ago" |
The rule that decides the CSS
WCAG 1.4.1, a Level A criterion, says colour can't be the only visual means of conveying information. The Understanding document is blunt about status cues: a second cue such as text or an icon is required, and a coloured outline that signals valid or invalid needs one even when both colours pass 3:1 against the background. Separately, 1.4.11 asks that the visual information identifying a component's state reach 3:1 against its neighbours. So each state needs a cue that survives a greyscale screenshot, and each cue needs enough contrast to be seen.
Here's the CSS that does it. Every card carries four independent signals: fill, border style, a mark in front of the status word, and the word itself, which sits in real markup so a screen reader reads it. The marks are CSS escapes for plain geometric characters, and they're decoration. The words do the work.
:root {
--bg: #0e1116;
--card: #1b2029;
--ink: #f2f4f8;
--muted: #a9b3c2;
--edge: #7f8a9c;
--on-fill: #ffd166;
--on-ink: #14161a;
--warn: #ff9a8a;
--stale: #c4b5fd;
}
.device {
display: grid;
gap: 4px;
padding: 16px;
border: 3px solid var(--edge);
border-radius: 14px;
background: var(--card);
color: var(--ink);
}
.device__value { font-size: 2rem; font-weight: 700; line-height: 1.1; }
.device__status { color: var(--muted); font-weight: 600; }
.device__status::before { margin-right: 0.4em; }
.device[data-state="on"] {
border-color: var(--on-fill);
background: var(--on-fill);
color: var(--on-ink);
}
.device[data-state="on"] .device__status { color: var(--on-ink); }
.device[data-state="on"] .device__status::before { content: "\25CF"; }
.device[data-state="off"] .device__status::before { content: "\25CB"; }
.device[data-state="unavailable"] {
border: 3px dashed var(--warn);
background: transparent;
}
.device[data-state="unavailable"] .device__status { color: var(--warn); }
.device[data-state="unavailable"] .device__status::before { content: "!"; }
.device[data-state="stale"] { border: 3px dotted var(--stale); }
.device[data-state="stale"] .device__value { color: var(--muted); font-style: italic; }
.device[data-state="stale"] .device__status { color: var(--stale); }
.device[data-state="stale"] .device__status::before { content: "\25F7"; }
Notice what's absent: no opacity. Dimming a card to make it look inactive is the usual shortcut, and it's a contrast trap that the dark theme section puts a number on. Each colour here is a flat value chosen on purpose. Off should look calm, since it's the commonest state in the house, and a panel where half the cards look like errors trains people to ignore errors.
The running version is below, and it's the same declarations, editable. Break it on purpose.
Why Use Room-First Navigation?
Backend data is organised by integration and device type, because that's how the system is built. Almost every first-draft home dashboard inherits that structure, and the structure tends not to survive contact with the people who live there.
People think about houses spatially. "The light in the hallway" is a location before it's a device class. A room-first layout matches that mental model, and it has a second benefit that's easy to miss: rooms are naturally small. A room usually holds a handful of devices, which lands inside the element budget the viewing distance imposes (the next section shows where that budget comes from). Device-type grouping produces a screen with every light in the house on it, which is both too long and useless from two meters away.
Home Assistant's sections view maps onto this almost directly. It lays cards out in sections on a grid, and the docs say a heading card is added to the top of each section automatically, so a section titled "Kitchen" gets its room label for free. The view also has a "Dense section placement" option that fills gaps between cards on its own, at the price of less control over card order. On a panel that people read the same way every day, I'd leave it off and let the kitchen stay where the kitchen was yesterday.
Keep the device-type view, just make it secondary. "All lights off" is a genuine bulk action and deserves a route. It's the wrong front door.
How Large Should Type Be at Two Meters?
Type size is the obvious consequence of distance, but the real effect is on element count, and you can calculate it. At seventy centimeters a dense table with forty rows is legible and useful, which is why data density is a virtue on a desk and a defect on a wall. The sums below show how few things fit instead of just asserting it.
The tool is visual angle: an object of height h at distance d subtends 2 x atan(h / 2d). Start with the floor. The Snellen 20/20 letter is defined to subtend 5 arcminutes overall, so at two meters it's 2000 mm x tan(5 arcmin) = 2.91 mm tall. Anything smaller than that is below the limit of normal acuity, whatever the CSS says.
Now the unit problem. CSS defines the reference pixel as the visual angle of one pixel on a 96 dpi device at arm's length, a nominal 28 inches (about 71 cm), roughly 0.0213 degrees. That's 0.2646 mm per pixel, and, importantly, it's an angle measured at 71 cm, not at two meters. A capital letter in a typical sans-serif is about 0.716 of the font size. I read that from the OS/2 tables of Helvetica, Arial, Verdana and Helvetica Neue on the machine I'm writing this on (0.717, 0.716, 0.727 and 0.714). So a 16px laptop body line has a cap height of 16 x 0.2646 x 0.716 = 3.03 mm. At 71 cm that's 14.7 arcminutes. Move the same line to two meters and it's 5.2.
Read that twice. Ordinary laptop body copy on a wall sits at the 20/20 threshold, with nothing left over for glare, a glance, or a moving reader.
Holding the original 14.7 arcminutes at two meters means scaling by 2000 / 711 = 2.81. Sixteen pixels becomes 45. That's my floor for labels. For the other bracket I wanted a regulatory number, and the closest one I could verify is for signs, not screens: ADA Table 703.5.5 sets the minimum character height for a sign mounted 40 to 70 inches off the floor, viewed from 72 inches or more, at 5/8 inch plus 1/8 inch per foot beyond 72 inches. At two meters (78.7 inches) that's 16 mm + 3.2 mm x 0.56 = 17.8 mm of cap height, or 30.6 arcminutes. It's written for readers with low vision approaching a wall, so treat it as the generous end of the range.
| Case | Cap height | Angle at 2 m | Font size, CSS reference px |
|---|---|---|---|
| Snellen 20/20 limit | 2.91 mm | 5.0 arcmin | 15 |
| Laptop body text, 16px | 3.03 mm | 5.2 arcmin | 16 |
| Same angle as laptop text at 71 cm | 8.52 mm | 14.7 arcmin | 45 |
| ADA sign rule, 2 m | 17.8 mm | 30.6 arcmin | 94 |
Here are the same four rows as bars, so the gap between the acuity floor and the two wall-ready sizes is visible at a glance.
I'd use the third row for labels and the fourth for the one number a card exists to show. Is 94px an absurd size for a value? On a desk, yes. On a wall it's a sign. It also explains the element count. A 10.1 inch 1280 x 800 panel is about 218 by 136 mm. A 94px font is a 24.9 mm em, and at a line height of 1.2 that's 4.6 lines for the whole screen. At the 45px tier it's 9.5 lines. So "six to nine things" isn't taste. It's what the geometry leaves, under these assumptions: two meters, that panel, 1.2 leading.
One warning before you copy any of this into CSS. The 0.2646 mm pixel is nominal. A real tablet may report a scaled pixel, and the 10.1 inch panel above has a true pitch of 0.170 mm (149 ppi) if it renders one device pixel per CSS pixel, which makes the same physical sizes 70px and 146px. Draw a 100px square on the actual panel and measure it with a ruler. Then divide your target millimeters by what you measured.
Two real panels make the point. Amazon's developer documentation lists the Fire HD 10 (2023) as a 10.1 inch, 1920 x 1200 IPS screen at 224 PPI, running Fire OS 8 on Android 11. Shelly's documentation for the Wall Display X2i gives a 6.9 inch, 1440 x 720, 5-point capacitive screen that mounts in a wall box and has a light sensor and a proximity sensor. Neither page states a pixel pitch or a screen area, so the rows marked "computed" below come from the stated diagonal and resolution, and a nominal diagonal means a percent or two of slack.
| Fire HD 10 (2023) | Shelly Wall Display X2i | |
|---|---|---|
| Stated screen | 10.1 in, 1920 x 1200 | 6.9 in, 1440 x 720 |
| Pixel pitch (computed) | 0.113 mm | 0.109 mm |
| Screen area (computed) | 218 x 136 mm | 157 x 78 mm |
| A 12 mm target, in device pixels | 106 | 110 |
| Lines at the 45px tier / the 94px tier | 9.5 / 4.6 | 5.5 / 2.6 |
The generic 1280 x 800 panel above needed 71 pixels for the same 12 mm, and the Fire needs 106, though both are 10.1 inches. Pixel counts describe the rendering budget. The millimeters decide what someone sees from the hallway. The small Shelly screen is the sharper of the two per millimeter and holds about half the lines, so at the 94px tier it has room for a value and a label and nothing else. The line counts are physical sizes, so they only hold if you scale CSS pixels to the nominal 0.2646 mm on that panel first.
How Big Should a Touch Target Be?
Two numbers get mixed up constantly, and the earlier draft of this guide mixed them too. WCAG 2.2 success criterion 2.5.8, Target Size (Minimum), is Level AA and asks for 24 by 24 CSS pixels, with exceptions that include enough spacing between smaller targets. Criterion 2.5.5, Target Size (Enhanced), is Level AAA and asks for 44 by 44. So 44 is the enhanced level, not the legal minimum, and 24 is the floor a conformance audit will actually test.
Neither is a physical size. At the nominal pixel, 24px is 6.3 mm and 44px is 11.6 mm. On the 10.1 inch panel at one-to-one, they're 4.1 mm and 7.5 mm. Google's accessibility guidance works in physical terms instead: 48 dp comes out at about 9 mm, the recommended range for touchscreen objects is 7 to 10 mm, and neighbouring targets want 8 dp of space or more.
A hand reaching out mid-stride is less accurate than a thumb on a phone you're holding, so I'd go past the top of that range. Around 12 mm, with 16 px or more of dead space between controls, is my own judgement and not a published standard. On that panel, 12 mm is 71 px. The cost of a miss is also physical. A mis-tap on a phone opens the wrong page and you go back, while a mis-tap on a wall turns off the wrong light, which someone in another room notices.
The wider rule set for this kind of screen is in designing for wall-mounted tablets.
Should the Dark Theme Come First?
Here's an opinion you can argue with: a wall panel's dark theme should be the real design, and the light one the derivative. A hallway panel can be the brightest object in a dark house, and a white screen is unpleasant to walk past at night. Dim it on a schedule or with an ambient light sensor, and design the dark version first, which is backwards from how most design systems get built. The surface and token side of dark interfaces is in our dark mode design patterns, and the type-specific traps are in typography for dark mode UI.
"Looks fine" isn't a measurement, though. I ran every pair from the CSS above through a short script that implements the WCAG relative luminance formula and the (L1 + 0.05) / (L2 + 0.05) ratio. Here's what came out:
| Pair | Ratio | Needs |
|---|---|---|
| Primary text on page background | 17.17:1 | 4.5:1 |
| Primary text on off card | 14.84:1 | 4.5:1 |
| Secondary text on off card | 7.71:1 | 4.5:1 |
| Dark text on the on-state fill | 12.56:1 | 4.5:1 |
| Unavailable text on page background | 9.22:1 | 4.5:1 |
| Stale text on off card | 8.85:1 | 4.5:1 |
| Off card border against its card | 4.68:1 | 3:1 |
| Stale dotted border against page | 10.24:1 | 3:1 |
Everything clears its threshold with room to spare, so the large-text allowance of 3:1 (18 point, which is 24px) never gets used. Primary text sits at 17.17:1 on purpose, short of the 21:1 you'd get from pure white on pure black. Passing is the floor here, and accessible typography covers where more contrast stops helping.
Now the trap from earlier. Dim the stale card the lazy way, with opacity: 0.5, and the numbers change. Primary text composites to about #878a91 and lands at 4.73:1, a pass by a hair. Secondary text composites to #626a76 and drops to 2.99:1, which fails 4.5:1. One property, applied to the whole card, and the status word that carries the meaning is the first thing to go. That's why every colour above is a flat token.
Check your own pairs the same way. The WCAG contrast checker on this site does the same arithmetic live.
How Do You Design for the One-Second Session?
If you take one thing from this: the primary view should answer a question without any interaction at all.
Is the house locked? Is anything still on? Is the heating running? Someone walking past should get those answers from the layout itself, which means status lives above the fold at the largest type size on the screen, and controls sit underneath. Most home panels do this backwards, leading with a grid of buttons and burying the status someone would actually check. The sketch below shows the order that works instead: status first, rooms underneath, and the device-type view reduced to a strip at the bottom.
Guests are the honest test. Someone who has never seen the panel should be able to turn on a light in the room they're standing in, without a tour. If they hesitate, the navigation is organised for the person who built it, and the designer is the one user who can never tell you whether the layout works. The test is hard to run on your own house, because you already know where everything is.
The designer is the one user who can never tell you whether the layout works.
How Do You Go From Design to a Working Panel?
Two directions from here, depending on which half of this you own.
If you want to build the panel as a custom app, the data layer is its own problem. Our guide to typing Home Assistant data in TypeScript models unavailable and unknown as a discriminated union, so the compiler forces every consumer to decide how to display a missing reading. It doesn't cover stale, which is the timestamp problem above: that part is yours to model, from last_reported.
If you're staying inside Home Assistant's own dashboards, version matters more than usual, because the card editor keeps changing. Release 2026.10, from 7 October 2026, reworked the Visibility tab: it offers the same conditions as the automation editor, plus dashboard-only ones such as Screen and User, and it shows whether a card is visible right now and which conditions pass. The Screen condition takes any CSS media query, and the conditional card's docs use (min-width: 1280px) as the example. That's the cleanest way to keep a dense admin card off the wall: gate it behind a width the panel never reaches, and the two-meter layout stays at the sizes this guide computes. One trap from the same docs, since it costs people an evening: while you're editing, the card is always shown, so exit edit mode before you test a condition.
The constraints here are unusual enough to be instructive even if you never design a home panel. Two meters and one second is a brutal editor. It cuts everything that was on the screen because it fit rather than because it earned its place, which is a habit worth taking back to the dashboards you do design.
Build this grid yourself
A 12-column admin grid is the opposite of a wall panel, which is exactly why it's worth running once. Set the density to Airy and the viewport to 1024px, then look at what the generator calls sparse: a strip of three or four metric cards above two rows of panels. The type sums further down leave room for something like five to nine lines of text on a whole wall panel. The gap between those two counts is the editing job.