In one line

Functional requirements describe behaviour (“import labels from V7”). Non-functional requirements (NFRs) describe qualities and constraints (“import 10,000 labels in under 2 minutes, with no data loss”). Architecture is driven mostly by the second kind.

The idea

FunctionalNon-functional
AnswersWhat does it do?How well, under what limits?
ExampleUsers can search images by site and dateSearch returns in < 500 ms p95 for 50M images
Verified byFeature tests, acceptance criteriaLoad tests, chaos tests, monitoring, audits
Changes architecture?SometimesAlmost always

NFR categories map to 04 Quality Attributes: performance, scalability, availability, reliability/durability, security, maintainability, cost, compliance, observability.

Constraints are a third kind worth listing separately: things you can’t choose (“must run on Azure”, “data stays in the EU”, “team of six”, “go-live by March”).

How it works

Start every design by clarifying both

flowchart TD
  Q[Problem statement] --> F[Functional:<br/>who does what?]
  Q --> N[Non-functional:<br/>how much, how fast,<br/>how reliable?]
  Q --> C[Constraints:<br/>tech, budget, time,<br/>compliance]
  F & N & C --> S[Scope for v1<br/>+ explicit out-of-scope]

Make NFRs measurable

Weak → strong:

WeakStrong
”Fast""Upload accepted in < 2 s p95 for files up to 20 MB"
"Highly available""Ingestion API 99.9% monthly availability (≈ 43 min downtime)"
"Scalable""Handles 5× current daily volume without redesign"
"Secure""Only managed identities access Blob; no secrets in code; images encrypted at rest"
"Cheap""Storage cost < €X per TB per month after 90 days”

Useful words: p50/p95/p99 latency, throughput, RPO (how much data can you afford to lose) and RTO (how long can you be down), SLO (internal target) vs SLA (contractual promise).

Availability cheat sheet

AvailabilityDowntime per month
99%~7.3 hours
99.9%~43.8 minutes
99.99%~4.4 minutes

Every extra nine roughly multiplies cost and complexity. Ask: what does an hour of downtime actually cost?

On the platform

Example requirement set for an image ingestion capability:

Functional

  • Robots/cameras upload images with site, robot ID and timestamp metadata.
  • Each image is validated (format, resolution, not corrupt, not duplicate).
  • Valid images are searchable by site, date and robot.
  • Invalid images are quarantined with a reason.

Non-functional

  • Peak 300 images/min per site during commissioning; 20 sites.
  • Zero silent data loss (durability over latency).
  • Validation result available within 60 s of upload (p95).
  • Raw images retained 2 years; moved to cool tier after 30 days.
  • Ingestion availability 99.5% (uploads can retry on the robot side).

Constraints: Azure, Python, existing MongoDB, data residency in the EU.

These numbers are placeholders

The exercise is to replace them with real figures from the team. Getting real numbers is often the most useful outcome of the exercise.

Common mistakes

  • Jumping to a solution (“we need Kafka”) before agreeing on volumes and latency.
  • NFRs that nobody measures after go-live.
  • Gold-plating: designing for 99.99% when 99.5% is fine.
  • Forgetting operational requirements: backups, monitoring, on-call, cost reporting.

Check yourself

Apply it

  • Write functional + non-functional requirements for one platform capability (ingestion is the easiest). Get real numbers from the team.
  • Turn three of the NFRs into draft platform KPIs (month-1 deliverable).

Go deeper

Related: 02 Back-of-Envelope Estimation · 04 Quality Attributes · 09 Trade-off Analysis