Software engineering is obsessed with hyper-scale.
We trade war stories about handling tens of millions of concurrent requests. We build distributed clusters, fine-tune CDN caching policies, obsess over latency, and sanitize every payload on the defensive assumption that an anonymous botnet somewhere on the other side of the world is trying to break our system.
Over the course of my career, I’ve operated at both extremes of that spectrum.
On one end, I’ve worked on projects with truly global audiences: an Adidas World Cup campaign, a Samsung Olympics Facebook application, and a Motorola campaign that included Times Square billboards.
On the other end, I’ve spent months building an internal dashboard at a financial services firm where the entire user base consisted of exactly three people.
And then there’s the high-stakes middle ground: the customer portal for another financial services firm. Hundreds of active users. Hardly a blip on an Azure network graph, but those users represented some of the largest pools of capital in the world. Sovereign wealth funds, major pension systems, and university endowments allocating billions of dollars.
Operating across those extremes reveals a surprising truth:
Writing software for three people is often significantly more stressful than engineering for ten million.
The Luxury of the Faceless Crowd
When you engineer for a global consumer audience, users become an abstract statistical blob.
If a retail checkout flow stumbles for fifteen seconds during Spain vs. Germany, maybe you lose a fraction of a percent in conversion. It’s an expensive metric on an analytics dashboard, and someone will absolutely want to know why it happened, but it’s still impersonal.
Nobody shows up at your desk demanding to know why they personally couldn’t buy the Thomas Müller jersey they’d been eyeing all week.
If a public system flakes out and production throws an unhandled exception, Datadog or Sentry catches the stack trace, creates an incident, and the team works through the regression.
In consumer software, scale eventually becomes an engineering problem. A difficult engineering problem, certainly, but still one that’s solved with architecture, monitoring, capacity planning, and guardrails.
The challenge is volume.
The 500-User Power Dynamic
The dynamic changes when you move into institutional software.
Five hundred users won’t stress an autoscaling group. An architecture sketched on a whiteboard over coffee could probably handle the traffic.
The challenge isn’t throughput. It’s leverage.
If an ecommerce platform hiccups during a holiday sale, a shopper refreshes the page or buys their sneakers somewhere else.
If an institutional investor has trouble logging in, can’t access portfolio data, or sees something unexpected on a report, they don’t submit a Zendesk ticket.
They might call a Managing Partner on their personal cell phone.
The operational risk shifts from concurrency to consequence.
You aren’t engineering for throughput. You’re engineering for auditability, zero-defect data integrity, regulatory scrutiny, and institutional trust.
When every user is effectively a VIP, mistakes carry a very different kind of weight.
The challenge is consequence.
The Intimacy of the Three-User App
Then there’s the three-user application.
This is where many of the conventional assumptions about software engineering start to invert.
The first thing you learn is that a three-person application isn’t evaluated by architectural elegance or test coverage.
It’s evaluated by whether it disrupts a workflow habit that somebody built over fifteen years.
Your observability stack suddenly becomes much more important. It’s far better to tell Dave on the bond desk that you’ve already identified a performance issue than to receive a giant Teams message informing you that the application takes too long to load.
The luxury of abstract requirements disappears.
Consumer software can often dictate how users should behave, for better or worse. Internal software starts from a different place: how specific humans already work.
Sometimes you can improve those workflows.
Sometimes you can’t.
Sometimes the technically correct solution loses to a spreadsheet someone has trusted for a decade and a half.
In a three-user environment, technical debt isn’t an abstract ledger entry.
It’s a daily interpersonal negotiation.
You can’t hide behind metrics.
You can’t disappear into aggregate dashboards.
You know exactly who uses the application, they know exactly who built it, and everyone involved can message each other directly.
The challenge is accountability.
The Different Faces of Scale
We tend to measure scale through numbers:
- Requests per second
- Daily active users
- Database size
- Terabytes ingested
But volume is only one axis of complexity.
- Consumer Scale (Millions of Users): The challenge of distributed systems. High volume, low intimacy, low consequence per individual interaction.
- Institutional Scale (Hundreds of Users): The challenge of high leverage. Low volume, moderate intimacy, significant consequence per interaction.
- Micro-Cohort Scale (Fewer Than Ten Users): The challenge of human psychology. Minimal volume, maximum intimacy, immediate personal accountability.
Handling ten million concurrent fans during the World Cup is a distributed-systems problem.
Supporting five hundred institutional investors is a trust problem.
Supporting three colleagues sitting one floor below you is a relationship problem.
Software engineering loves to talk about scale as a matter of volume.
In practice, scale is just as often a matter of consequence and proximity.
Sometimes the scariest production system in the building is the one with three users.