Send the firefighters to the fires
Enterprise software keeps forgetting a century of good advice about what deserves our attention.
If a user’s job is to fix what’s broken, the screen should show what’s broken first. Sounds pretty obvious. It’s also not new. Frederick Taylor argued for it in 1903. Xerox PARC designed for it in the ’90s. Industrial control rooms wrote it into a standard. Yet enterprise software keeps forgetting this.
Imagine a fire department that dispatches trucks in the order houses were built. Or by date last renovated. Every house gets a visit eventually, and some of them happen to be on fire. That’s pretty absurd, right? Yet I’ve seen the equivalent more times than I care to remember.
A lot of enterprise work boils down to one job: here’s a collection of things, some of them have problems, go fix the problems. Devices out of compliance. Certificates about to expire. Invoices that failed to reconcile. Tickets breaching SLA. The KPI is simply “issues resolved.”
The UI has one job: get the user to the fires and hand them the hose.
So how did we forget? Not because the ideas are hard. Enterprise software just has a habit of designing for everyone except the person actually using it. It’s designing for the buyer in the demo, for the team racing to ship, for the data model that sorts things for free. None of them pay for it. But the user does, every shift, one scroll at a time.
Start with the job
Clayton Christensen had a simple idea: people don’t buy products for their features. They hire them to get a job done. It’s now known as Jobs to Be Done, or JTBD (Christensen et al., 2016; open-access overview). In enterprise triage, the job is about as plain as it gets: fix what’s broken. Finding it should be the product’s job.
So why do so many screens ignore this? Here’s the pattern I see over and over again. A screen lists 400 objects, and twelve need attention. They’re scattered somewhere between page 3 and page 17. It’s Where’s Waldo, except Waldo is a production outage.
Sometimes there’s a status column. Maybe a small red pill, sitting politely in column six of a list sorted by anything but what matters. A human can work out which items are broken. But the interface is acting obtuse and unhelpful.
Consider the following twenty services. I’ll keep coming back to them.
Before: 20 rows, sorted by last updated, every column visible

After: focus on the fires

In the first table, the two critical services sit in rows sixteen and nineteen, and nothing calls them critical. You have to cross-reference Health and Tier yourself: search-index is only Degraded, but it’s Tier 1; mail-relay is Failing, but it’s Tier 3. Meanwhile, Uptime reads 99.92% for payments-gw, which is failing right now. The fires-first view does that math for you. Same data, different job.
Now imagine hearing that table instead. If the headers are marked up properly, a screen reader announces which column you’re in as you move through it (W3C, F91). So a screen reader user can walk down the Health column one cell at a time. That’s still twenty announcements to find six problems, plus a hop to the Tier column for each one. And that’s the best case: many enterprise data grids are built from divs, virtualized, or paginated, and those shortcuts break. Many enterprises don’t hire people who can build accessible tables (Brad Frost calls them front-of-the-front-end developers), but that’s another story. For every column of noise we leave in, someone has to sit through it.
None of this is malicious. Nobody in the review said “hey, let’s bury the critical issues!” The order happened by default, because nobody dug into the JTBD.
The table as a design cop-out
Bad sort order is an outcome of enterprise’s unfortunate love affair with the table as a magic bullet.
The reasoning goes: we don’t know exactly what users want, so let’s give them all the data and let them search, filter, and sort. It sounds like giving users control. In reality, it’s an abdication.
Those are tools for exploring and hunting: browsing to see what’s there, or tracking down something you know exists. But when they become the main interface for task work, the product team has handed its job to the user. Every session, someone sorts by health, scrolls past the Passing rows, cross-checks the tier, and finds payments-gw. Again. Multiply that by every user, every day. That’s triage the product could have done once.
At some point, some smarty-pants will suggest saved filters: let users build and save their own “To-dos” view (health is failing, sorted by tier). Problem solved, right? Not quite! That’s a workaround stacked on the cop-out. Users end up designing the default screen for you because you shipped the wrong one.

Why smart teams keep doing this
To be fair, the people shipping these screens aren’t careless. The forces pushing them toward the table are real, and a lot of them trace back to one thing: in sales-led enterprise software, the buyer isn’t the user.
Jason Lemkin said it bluntly back in 2012: “you, the end user, aren’t the customer for most true enterprise software” (Lemkin, SaaStr). A year later, Martin Eriksson made the same distinction for product managers: “the user and the purchaser are different people with different needs” (Eriksson, Mind the Product).
The buyer’s worst case is a boring demo. The user’s worst case is an outage with their name on it. Guess who the screen gets designed for. Not every lazy sort comes from sales, but a sales-led motion makes lazy sorts easier to ship and harder to undo.
Defaults feel safe. Every record has a created_at and an updated_at, so sorting by them is free. “Severity” doesn’t exist until someone designs it. Meanwhile, stakeholders worry that if healthy items aren’t visible, users will assume they’re missing, and on an RFP checklist, a hidden column might as well not exist. So everything stays on screen.
Nobody talks to each other. Taiichi Ohno’s 5 Whys only works if you can reach the person with the answer. In enterprise, there are too many layers between the people willing to ask and the people able to answer. The only two people reliably talking are the salesperson and the buyer. The salesperson is paid for the close, and asking why five times only gets in the way. Conway’s law predicts the result: systems mirror how their makers communicate. A neutral sort is what that silence looks like on screen.
“Ask ‘why’ five times about every matter.”
— Taiichi Ohno, Toyota
Dashboards are built for the demo. People love dashboards that look like command centers in movies. Walls of screens! Scrolling numbers! Blinking maps! Stephen Few was criticizing exactly this two decades ago, arguing that dashboards should support real-time situation awareness for decision making, not impress the room (Few, 2007; Information Dashboard Design, 2006). Density still wins sales calls, which is the sales motion showing up in the UI. Developers and PMs love it too: every widget and column is a feature someone built.
Tables are cheap and familiar. Every component library ships one, and every IC has built a dozen, so it’s what everyone reaches for first. Inline editing is one prop away, so someone will eventually float turning every cell into a form field. Cheap to build, expensive to use.

Notice what these have in common? Each one optimizes for the team’s comfort or the buyer’s first impression, not the user’s job. The table can never be wrong, because it never commits to anything.
Tables aren’t the enemy
To be clear, I’m not anti-table. Reporting, analysis, and bulk admin are table work. User questions can change week to week, and pinning them down takes the kind of conversations we’ve already seen are rare. Designing for that is tough, so a flexible table is an honest answer.
The line I draw is this: open-ended questions need flexible tables. Known jobs need opinionated ones.
Yet sometimes the best table is the one you don’t build! Think about what people actually do with a big table, and where that work belongs:
- Slice and pivot? Let them export to (or integrate with) the BI tools they already know.
- Report up to leadership? Send a scheduled summary, not a screenshot of 400 rows.
- Reconcile against another system? That’s an integration or an API. Please don’t subject a human being to comparing two systems row by row.
- Hand evidence to auditors? Send an export instead of buying them a seat, which only gets them a login they’ll barely use, to a worse BI tool.
Excel, Tableau, and Power BI are established, they’re good at analysis, and your users already know them. Your product doesn’t need to compete. Just keep the fires list live and in-app.
So the question isn’t table or no table. It’s what goes in it, and in what order. If you can write the user’s job in one sentence, and “resolve the issues” is that sentence, you know enough to decide: fires first, ranked by severity, healthy rows summarized. A table sorted by last updated with every row at equal weight is just an inventory. It tells users what exists, not what needs their attention.
Management by exception, a century later
One of my core design principles fits in four words: no news is good news. I didn’t invent it. In 1903, Frederick Taylor called it the exception principle: a manager shouldn’t be swamped with every report, only with what deviates from the standard (Taylor, Shop Management).
“The manager should receive only condensed, summarized, and invariably comparative reports.”
— Frederick Winslow Taylor, Shop Management (1903)
Swap “manager” for “user” and it’s a design brief. There’s no reason to emphasize what’s working. Working is the expected state; it’s what the customer pays for. But there’s every reason to emphasize what isn’t, because that’s the only part that needs a human.
Every pixel that gives a healthy object the same weight as a broken one is friction against the KPI. If the metric is issues resolved, a screen that hides issues isn’t neutral. It’s working against the business. And noise isn’t just visual. For a screen reader user, it’s time.
So design as if the user’s job performance depends on your decisions. Because it does! When issues slip through the cracks, nobody blames the designer who picked the default sort. They blame the user who didn’t spot payments-gw in time. They inherit our defaults, our clutter, and our shallow thinking, and they’re the ones who get penalized for it.
That’s the bar. It’s not “does it follow the design system” or “did stakeholders sign off.” It’s “does this make the person using it better at their job?”
What control rooms already know
Ironically, real control rooms don’t look like the movies. In refineries and power plants, operator screens are guided by the ISA-101 standard for industrial interfaces (ISA, 2015), which builds on the high-performance HMI work of Bill Hollifield and colleagues (The High Performance HMI Handbook). Normal operation stays gray and calm. Color is saved for when something’s wrong.
https://medium.com/media/3a2b27bedfc398539b462d0027464e6c/href
The unsexy truth is that sometimes, that’s all a dashboard needs to be: a prioritized list of what’s on fire and the means to put it out, not a bunch of widgets fighting for the user’s attention. Many may not like it, but that’s what peak performance looks like. Operators knew it long before enterprise SaaS did.
Silence has to be earned
Here’s a fair objection: users need reassurance. If I only show problems, how does anybody know the rest is fine?
Sure, Jakob Nielsen’s first usability heuristic covers it. Systems should keep users informed about what is going on, through appropriate feedback within reasonable time (Harley, NN/g). No news is only good news if the silence is trustworthy. An empty screen could mean everything is healthy, or that the sync broke an hour ago. If users can’t tell the difference, they’ll go back to scanning the full table.
So design the quiet state as deliberately as the loud one. Don’t list the healthy items. Summarize them with confidence.


Just a count, a timestamp, and a way to dig deeper. You’re still reporting the good news. You’re just not giving it top billing.
Mark Weiser and John Seely Brown described this balance in 1995 as calm technology: information that sits in the periphery of our attention and moves to the center only when it matters (Weiser and Brown, 1995). In their words, the periphery is “informing without overburdening.” That’s the quiet state. It gives users permission to stop looking. Giving users their time back might be the most underrated thing an enterprise tool can offer.
What fires-first actually looks like
A fires-first approach isn’t just the same table with a different sort. Here’s what separates it, with credit where it’s due.
- Severity, not just status. A small fire next to a gas station beats a big one in an empty lot. An expired certificate on payments-gw outranks one on a test server, even if both say “Failing.” Health tells you what broke. Tier tells you how much it matters. Severity needs both. Remember that severity doesn’t exist until someone designs it? This is what designing it looks like.
- Urgency and importance are separate axes. The idea is usually traced to a 1954 Eisenhower speech, and Stephen Covey, A. Roger Merrill, and Rebecca Merrill turned it into four quadrants in First Things First (Hoang, Rework). Plot issues on that matrix, and users can make meaningful choices about what to fix now, schedule, delegate, or snooze.
- Lead straight into investigation. Fires seldom have a one-click fix. The real job is usually figuring out what went wrong, so each item should invite investigation.
- Notify, so nobody has to watch. People have better things to do than babysit your app. When payments-gw catches fire, tell the person who can fix it, wherever they already work: email, Slack, Teams. The fires list is where they go to act, not where they sit and wait.
- Restraint on alerts. Healthcare has studied the opposite failure for years. When clinicians are flooded with warnings, they become desensitized and start overriding the critical ones along with the trivial ones (AHRQ PSNet, “Alert Fatigue”). If 300 of 400 items say “Warning,” your users will do the same. A severity model that can’t say “this doesn’t matter now” isn’t a severity model.
- Let users snooze. Some fires can’t be fought today: a vendor hasn’t replied, or the fix needs a maintenance window. Snoozing dials down the noise without pretending the issue is solved, and it comes back on schedule.
- Resolution is visible. When a fire goes out, it leaves the list and the count drops. That feedback loop makes the KPI real to the person doing the work.
- Everything is still one click away. The full table, healthy rows included, for the audit, the export, and the curious.

“I have two kinds of problems, the urgent and the important.”
— Dwight D. Eisenhower, quoting J. Roscoe Miller, 1954
The top-right quadrant leads the fires list. Everything else still has a home.
Not sure where to start? Watch how users triage today: what they sort by, what they scroll past, what they export. Your users have already mentally drafted the spec.
Dispatch, not census
A census counts everyone equally. That’s its job. A dispatch center decides who needs help first and sends people there.
Most enterprise dashboards are built like a census: complete, neutral, accurate. And no help to someone whose job is putting out the fires.
Taylor got there in 1903. Weiser and Brown in 1995. Few in 2006. The ISA-101 committee in 2015. Same direction, a century apart. The knowledge isn’t missing. What’s missing is defining what “on fire” means, ranking it, designing the quiet state, and wiring up the notifications.
Do the extra work so your users don’t have to. That’s the job.
Further reading
In order of appearance:
- Clayton M. Christensen, Taddy Hall, Karen Dillon, and David S. Duncan, “Know Your Customers’ ‘Jobs to Be Done,’” Harvard Business Review, September 2016. Open-access overview: Kelsey Miller, “The Jobs to Be Done Framework Explained & Real-World Examples,” Harvard Business School Online, 2020 (updated 2026)
- W3C, “F91: Failure of Success Criterion 1.3.1 for not correctly marking up table headers,” WCAG 2.2 Techniques
- Brad Frost, “Front-of-the-front-end and back-of-the-front-end web development,” bradfrost.com, 2021
- Jason Lemkin, “Real Ent Software Don’t Need No Stinkin’ UI/UX,” SaaStr, 2012
- Martin Eriksson, “Consumer vs Enterprise Product Management,” Mind the Product, 2013
- Melvin E. Conway, “How Do Committees Invent?” Datamation, April 1968. Overview: “Conway’s law,” Wikipedia
- Taiichi Ohno, Toyota Production System: Beyond Large-Scale Production, Productivity Press, 1988. Overview: “Five whys,” Wikipedia
- Stephen Few, “Dashboard Design for Real-Time Situation Awareness,” Perceptual Edge, 2007; and Information Dashboard Design, O’Reilly, 2006
- Frederick Winslow Taylor, Shop Management (1903). Context: Management by exception, Rework
- International Society of Automation, ANSI/ISA-101.01-2015, Human Machine Interfaces for Process Automation Systems, 2015
- Bill Hollifield, Dana Oliver, Ian Nimmo, and Eddie Habibi, The High Performance HMI Handbook, PAS, 2008
- Aurora Harley, “Visibility of System Status (Usability Heuristic #1),” Nielsen Norman Group, 2018
- Mark Weiser and John Seely Brown, “Designing Calm Technology,” Xerox PARC, 1995
- Victor Hoang, “The History of the Eisenhower Matrix: From a 1954 Remark to Covey’s Four Quadrants,” Rework, 2026
- Agency for Healthcare Research and Quality, “Alert Fatigue,” PSNet, 2019 (reviewed 2024)
Send the Firefighters to the Fires was originally published in UX Collective on Medium, where people are continuing the conversation by highlighting and responding to this story.
