Skip to content
← All posts
2 min read

Build for the requirements you have, not the ones you fear

Development time follows real requirements. Inflating them up front doesn't de-risk a hypothesis — it just delays the answer. But speed isn't everything either.

Also available in Русский

Every new project starts with the same temptation: design for a million users before the first one shows up. Kubernetes, sharding, three message brokers, multi-region. It feels responsible. Most of the time it’s just expensive.

Time follows requirements

Development time isn’t a function of how good the team is. It’s a function of what the system has to guarantee. “Handle 50 requests per second with a p99 under 200 ms” and “handle 50,000 with zero downtime across regions” are different products — the second one costs months, not days.

When the initial requirements are inflated, the team pays that price up front, for a load that may never come. And the real question — does anyone want this? — stays unanswered for longer.

A hypothesis needs an answer, not a fortress

A prototype exists to test an idea. For that it needs to be:

  • fast to build — days or weeks, not quarters;
  • honest — real users, real data, real metrics;
  • cheap to throw away — if the hypothesis fails, nothing much is lost.

A single service, PostgreSQL and a simple deploy will carry most products much further than people expect. Scaling a system that has users is a good problem. Scaling a system nobody uses is not a problem at all — it’s waste.

So is speed more important than the product?

Not quite. Speed wins at the hypothesis stage, but some decisions are expensive to change later, and those deserve time even in a prototype:

  • the data model — migrating live data is painful;
  • public API contracts — clients will depend on them;
  • security and personal data — there is no “we’ll fix it later” here;
  • observability — without metrics you won’t know whether the hypothesis worked.

Everything else — the number of services, the broker, caching, autoscaling — can and should grow with real load.

The rule I follow

Design for the next order of magnitude, not for three of them. Know where the system will break first, measure it, and keep a plan for that moment. That way the prototype ships fast, and the product that grows out of it doesn’t have to be rewritten from scratch.