Clarity over Cleverness
If it’s hard to read, it’s hard to trust.

The first time I broke a healthcare system, it was with a single line of code.

It was 2004. I was working under the U.S. Army Medical Command, part of a small but scrappy development team supporting military hospitals. We used Oracle—10g at the time, powerful but brittle—and I had written what I considered a masterpiece: a stored procedure that consolidated nurse staffing, patient census, and acuity levels into a real-time dashboard. The logic was dense but efficient, dynamically generating views based on parameters and metadata stored in a config table.

It pulled census data from inpatient wards, cross-referenced it with shift rosters, and flagged units that were either overworked or dangerously understaffed.

At the time, it was brilliant. It ran fast, produced exactly what the Chief Nurse wanted, and got me a handshake from the regional command.

But I had made one mistake. I wrote it to be clever.

I abstracted the logic into reusable, nested views. I compressed business rules into CASE statements so tight they were unreadable without decoding. I skipped inline comments because “the code documents itself.” Worst of all, I stored critical column references as strings in a metadata table, then used dynamic SQL to build the queries on the fly. It was flexible. It was powerful. It was, in hindsight, completely opaque.

Abstraction isn’t the enemy—undocumented abstraction is.

Six months later, I was on leave in Michigan when the call came in.

The dashboards were down.

Not all of them—just the nursing operations dashboards. The ones tracking patient loads, acuity, and overnight staffing levels. At 0600, the shift leads logged in to prep their assignments and were met with spinning icons. No data. Just broken links.

Ward charge nurses couldn’t verify patient ratios. Med-surg units couldn’t balance staff. A few nurses resorted to paper notes and hallway whiteboards. One unit delayed a high-acuity admission because they didn’t have confidence in their staffing availability.

The Chief Nurse at one of the regional medical centers flagged it up. Within hours, the Regional CIO was pulled in.

Now, here’s where the story takes a turn.

While engineers were poring through logs and error messages, the CIO did something no one else thought to do. He didn’t escalate. He didn’t assign a task force. He scanned the metadata table, saw my name, and picked up the phone.

“Andrus, your name’s in the metadata table. You still remember how that dynamic procedure works?”

I didn’t hesitate. “Where did it fail?”

Turns out, the data governance team had made a perfectly logical change: they renamed a column in the patient_census_view from WARD_ID to UNIT_ID to better reflect modern terminology. Unfortunately, my procedure had no validation, no dependency mapping, no graceful failure. Because the column name lived in a metadata table, no one caught the break until the view silently failed and the dashboards collapsed.

And no one—not even the other engineers—could understand how the thing worked well enough to fix it.

The CIO got me VPN access and a terminal. I patched the column mapping, added logging, and—this time—commented every transformation. But I didn’t stop there.

Over the next week, I rewrote the entire procedure.

  • Replaced dynamic SQL with deterministic joins
  • Refactored views into simple, layered logic
  • Removed ambiguous CASE blocks and replaced them with readable functions
  • Documented the dependencies and created a plain-English flow diagram for the support team

The bug was technically small. But the impact was massive.

The revised version was deployed across all five regional medical commands. The Surgeon General’s office picked it up as a standard pattern for nursing dashboards across the Army medical system.

And that was the moment I learned the most valuable lesson of my engineering career:

Clever code fails silently. Clear code saves lives.

These days, when I coach younger engineers or review a pull request, I don’t ask is it efficient? I ask is it obvious?

Because somewhere, right now, a nurse is starting her shift. And the only thing standing between her and chaos might be a dashboard I touched years ago.

And I won’t let it break just because I wanted to impress someone.