← All writing

Grey Is Normal

A command that lists overdue case reviews exists because one review went three weeks past its date, and it still only speaks when someone remembers to run it. Factories met this long ago with the andon board, which stays dark while work flows and lights only the station where it does not. WALL Pattern (Workflow At-a-glance, Live & Legible) is that board as an open format: one config for the structure, one feed for what is true now, and a single HTML file that keeps the last snapshot and shows where work is stuck and what changed. Its first real wall moved the review report onto a screen without changing a fact, and found the format's first blind spot on day one.

Michael Shatny··8 min read

Two Days Overdue

The StratIQX case library holds 342 published 6D cases, and many of them make calls with a date attached: a window that is open, narrowing or closed, and a day when someone has to go back and check. On the morning of November 15, 2026, a short command answered the only question that matters about those dates.

the report
$ npm run reviews
Review status as of 2026-11-15

✗ Overdue (1)
  UC-083  2026-11-13  2d overdue        The Toxic Flow  [/r/ page · narrowing]

• Due within 30 days (7)
  UC-296  2026-11-15  due today         Two Assemblies, One Autumn  [brief]
  UC-062  2026-11-20  in 5d             The Escape Hatch  [/r/ page · narrowing]
  …

  61 more scheduled; next: UC-327 on 2027-01-05

The report is correct, and it exists because a review was once missed by three weeks. The source file that builds it still carries the reason in a comment.

✗why the report exists
 * Nothing tied these together, so a review cycle could update the /r/ page and
 * leave the index behind (Aug 7 2026 cycle), and nothing said a review was
 * overdue (UC-062 went three weeks past its date).

The command fixed what was missing, which was any signal at all. It left one thing in place: someone still has to remember to run it. A report that has to be run is quiet on exactly the days nobody thinks to run it, and those are the days a date slips past.

The Board Above the Line

Factories solved this long before software. On a Toyota assembly line, a worker who sees a problem pulls a cord, and a board above the line lights up with the number of that station. The andon board does not report on the factory. It stays dark while work flows and lights only where it does not, so that anyone walking the floor can see, without asking, where to go.

Most dashboards are built for a different question. Tiles of totals and trend lines answer “how are we doing?”, which is a manager's question, asked now and then. People who run a process ask something else, all day: where is work stuck, and what changed since the last look? An andon board answers that one, and it does it by being mostly boring.

!

Grey is normal. Colour means look here.

A display that colours everything teaches people to stop looking. A display that stays grey earns the moment it turns amber.

A Wall Made of Two Files

WALL Pattern, short for Workflow At-a-glance, Live & Legible, is that board as an open format and a renderer. Any process becomes a row of connected steps. Each step has one hero number that says whether it is fine, a few supporting counts with their own thresholds, the age of the oldest item against a target, and its exceptions shown where they happen. Steps are joined by connectors that carry counts and turn amber when a handoff stalls. Every change pulses once, with an arrow coloured by meaning, not by direction: blue when the number moved the right way, orange when it moved the wrong way, whichever way that is.

The whole wall is two files. A config describes the structure, and changes rarely. A feed reports the numbers, and changes on every update.

✓structure and numbers, kept apart
// wall.config.json: changes rarely
{ "id": "due", "name": "Due",
  "hero": { "id": "due_n", "label": "Due or overdue",
            "goodDirection": "down",
            "thresholds": { "watch": 6, "act": 10 } } }

// wall.feed.json: what is true now, nothing else
{ "generatedAt": "2026-11-15T05:19:06-05:00",
  "values": { "due_n": 8, "due_7": 2, "due_over": 1 },
  "ages":   { "due": { "oldestHours": 48 } } }

The feed carries no deltas. The source system reports only what is true now; the wall keeps the previous snapshot and the start-of-shift baseline, and works out what changed itself. That one decision is what makes it cheap to connect: an old system that can write a JSON file to a shared folder on a schedule already has everything it needs.

Structured Input, Rendered Output

The shape is older than the wall. Schema-driven code generation, the approach .netTiers took for .NET data tiers, worked from a declared structure to generated output: entities, data access, a full admin interface rendered from the schema, and a cache layer holding the last known state between the database and the screen. Nobody hand-built the admin screens. They followed from the structure.

A wall is the same pattern pointed at a screen on the wall. The config is the declared structure. The feed is the structured output of whatever runs the process. The renderer draws the steps from the structure, and its memory of the last snapshot plays the part of the cache: the reason it can show change, not just state, is that it remembers what the state was.

The First Real Wall

The case-review report became the first real wall. A new command reads the same function the report reads, not a second copy of its rules, for the reason set out in The Validator That Can't Lie, and writes a feed: Library, Scheduled, Due, Reviewed, with reviewed cases looping back to a new review date. Nothing about the reviews became more true. The same facts were moved from a place someone has to visit to a place that is simply there.

On its first run three steps were grey: 342 cases, 61 reviews scheduled beyond thirty days, five reviewed in the last ninety. One was amber. The Due step held 8 reviews, one of them overdue, its frame lit and its footer reading “Most overdue 2d · target 1d”, with UC-083 listed underneath as the exception that put it there. That is the report's first line, now visible from across a room without anyone typing anything.

The connectors needed more care than the numbers. A flow count claims that something moved, so the feed keeps a small record of the cases, review dates and reviews it has already seen, and the very first run only fills that record in. Without it, the wall would have announced 342 newly published cases on day one, which is a confident number and a false one.

The real data also found the format's first blind spot. The baseline toggle was labelled “Shift 07:00”, because the pattern assumed shifts. A review cycle moves in days and has no seven o'clock, so its shift was set to start at midnight. It works, but a process that moves by the day or the week wants its own baseline, and that is now the first item for the next version. Sample data could not have shown it.

One File, Nothing Sent

The renderer is a single HTML file with no build step. Opened directly, it runs on a fictional wholesaler with simulated data. Given a config and a feed, by URL, by dropping the two files onto the live demo, or by watching a file that a system overwrites, it becomes a wall for that process instead. Dropped files are read in the browser and never leave it, and the page sends nothing anywhere: it only fetches what it is pointed at.

It is version 0.1, archived on Zenodo as a software record (DOI 10.5281/zenodo.24244635) that makes no research claim, and the gaps are listed rather than hidden: one layout is drawn as another, a drill-down link exists in the schema but not on screen, and the page checks less than the schemas do. A wall that claims more than it shows would break the one promise the pattern makes.

Lit Where It Is Stuck

An andon board is not interesting to look at, and that is the design. It is grey for hours so that a single lit number can mean something. The case-review report already knew that UC-083 was two days overdue. What it could not do was say so to someone who had not asked.

That is the general shape: a check that has to be run is a pull, and pulls are forgotten exactly when they matter. Moving the same check onto a surface that is always there turns it into a push, without changing a single fact. The work was never in the numbers. It was in keeping everything else grey.

Related

Michael Shatny is a software developer and methodology engineer and founding contributor to .netTiers (2005–2010), one of the earliest schema-driven code generation frameworks for .NET. His work spans 28 years of the same architectural pattern: structured input, generated output, auditable artifacts. WALL Pattern points that pattern at a screen: a declared structure and a snapshot of the numbers in, a wall that shows where work is stuck and what changed out.

ORCID: 0009-0006-2011-3258