The Wrong Yardstick

Why building vertical software requires understanding lives you don’t lead.

The five pillars of modern society

It should be intuitive but our experience as a patient does not equip us to understand automatically how a particular clinician does their job day-to-day. That is logic that extends to almost all verticals- I eat daily, but don’t naturally understand how food is researched, regulated, or transported. I am in buildings (more frequently than I’d like), yet actual construction is quite foreign to me. You can extrapolate this out to the many fractal good and services that exist in this world, along with their associated professions.

Software is just a set of tools to solve someone else's problem. You can't build the right tool for a problem you can't feel. Trouble is, it turns out we’re pretty uniformly bad at manufacturing that understanding for lives we don't lead. It’s a function of a fairly straightforward math (and associated role play).

Math:

It takes empathy in tech to understand the user, which is either passively accrued (you live it, so you absorb it for free) or actively hunted down (earned through immersion).

Role play:

1. For consumer software, empathy is native. We are all consumers, so we already understand most of the underlying experiences and jobs-to-be-done. We may not know the particulars, but we rarely need someone to explain to us what it means (and if we do, we can just download the relevant app).

2. For horizontal B2B software, empathy is transferable. Presuming we are or have been gainfully employed, we’ve encountered many of the primitives common across businesses: documents, email, chat, project management, spreadsheets, analytics, etc, etc. Yes, the particulars vary, but the jobs-to-be-done are familiar enough to reason from.

3. For vertical B2B software, empathy has to be acquired. And acquiring it is (technical term here) super fucking hard. You need a large time investment (market research) or lived experience (you did the job).

For this last bullet, because the operator paid that empathy cost long ago, it's invisible to them as an asset. They can see so clearly the situation of their particular industry, but not parallel ones. As an operator in health tech, I know how Netflix works, how Databricks works, and how EHRs work, but I haven’t the faintest idea how a K-12 uses a Student Information System, what the frustrations of a construction company are with Procore, or how a freight dispatcher fights with a TMS like McLeod.

I am not Matt Damon! I have not bought or run a zoo, so consider me deeply unqualified to build or pick a ZMS. If I was an engineer, I'd need someone to tell me what to build that would be useful to zookeepers. Hell, if you want to be cynical, the entire existence of the discipline of product management is somewhat of a tacit corporate admission: a whole job function invented to manufacture that empathy en masse and processize it into bite-sized tickets that can be built against without ever having seen or felt the problem firsthand.

Time to shut down the data centers

None of this is an argument that vertical software is secretly great (or that its shitty interfaces deserve unrestricted absolution). It does suck! The point is that you can’t diagnose why it sucks until you empathize.

So time and time again, we invariably fall back to defaults and benchmark against other experiences we know (the ultra polished consumer experiences, the deep-pocketed horizontal tools). Against those yardsticks their own work looks a decade behind: adoption feels glacial, implementations are a slog, the UI looks downright dated next to Linear, nobody ever self-serves onboarding, and every release ships slower than the consumer apps or horizontal tools they envy.

A theme of this Substack (intermingled sometimes confusingly with legal escapades and vertical specific analysis) has been to look across verticals to actually compare and contrast where we’re ahead and where we can learn:

• The gripes many assume are their industry’s private cross to bear are a find-and-replace away from a landlord’s.

• The AI shakeout maps cleanly to the exact same categories whether you’re looking at EHRs or dealer management systems.

• Healthcare (stunningly) is actually leading across verticals in promoting APIs and coopetition.

I think we do ourselves an unnecessary and disheartening disservice when we don’t compare apples to apples. So the next time you default to a why-can’t-this-feel-like-Superhuman or a Salesforce-solved-this-a-decade-ago, stop and breathe for a second. Reset your bar:

• Benchmark against what your user actually does today. The freight dispatcher isn’t weighing McLeod against Superhuman. She’s weighing it against a whiteboard, a landline, and forty calls before lunch. Half the “decade behind” feeling burns off the instant you measure against real alternatives.

• Buy the empathy you can’t grow. The cheapest, most underused move in vertical software is hiring the person who lived the job. It's easier to teach someone how to use Jira than to speedrun a decade of knowing which claims edit rules everyone actually ignores

• Call someone. I talk to my sister about construction tech, my brother about how cannabis software works, and my cousin about food safety’s supply chain. I’m not expecting you to be a psycho like me, but cursory interest in how other industries work costs you 30 minutes (or maybe a lunch) and pays back for years.

• Steal the consumer world’s craft, but leave its assumptions. The polish that makes Notion feel good travels fine into an EHR. The belief that users will self-serve their own onboarding fits less well in the enterprise world. So take the craft, but perhaps question whether to leave the rest at the door.

So in summary, stop measuring yourself against products built for everyone! The best way to find joy again in creating software is to start measuring yourself against the mess your user is actually in (and maybe fix a thing or two for someone along the way).