Back to blog

How do you design for requirements you cannot predict?

Thắng Đoàn
Thắng Đoàn

Your roadmap assumes you can guess the future, and most long-term software plans do not survive contact with it. IQ Inc's diagnosis is blunt: the biggest failures come from rigid assumptions embedded so deeply that adapting costs more than starting over.

Prediction is the wrong job

The problem is rarely that requirements changed. The problem is that they were written as though change would never come. Every software roadmap starts with a well-intentioned assumption that you know what the future looks like. IQ Inc argues that markets shift, regulations change, and technologies become legacy faster than anyone expects. Victor Font argues that the problem is rarely that requirements changed. The problem, he writes, is that they were written as though change would never come. So stop trying to predict better. Start designing for the fact of change itself.

Split stable policy from volatile detail

Victor Font recommends separating stable policy from volatile implementation details, and isolating business rules that change often. Payment policy is an example: "we must be paid" is stable, while which providers you accept churns. Prioritize requirements by stability and keep traceability, so each change touches a known place. Change then becomes predictable rather than disruptive.

  • Stable policy stays; volatile rules get isolated
  • Rank requirements by how fast they change
  • Traceability tells you where a change lands

Stay open for extension, closed for modification

A system should be open for extension and closed for modification. Bitloops points to the open-closed principle: a system should be open for extension and closed for modification. Their example is an OrderProcessor that never changes when you add a new payment type. You write new handlers instead of editing tested code. This turns unpredictable future requirements into new modules rather than risky edits.

Expect change on a schedule, not by surprise

TechTarget notes that in Agile development, new requirements appear unexpectedly and established ones shift many times, from internal defects to external pressures like a new competitor. Their advice is to grasp which disruptions are most likely and put processes in place before they hit. In other words, treat change as routine operations, not as an exception. Your process for absorbing a new requirement matters more than the requirement itself.

What this does not solve

The biggest mistake is designing for flexibility you don't need. Bitloops warns that the biggest mistake is designing for flexibility you don't need, a premature optimization anti-pattern. IQ Inc echoes this: teams swing between over-engineering and rigid systems that assume tomorrow looks like today. None of these sources give a formula for how much flexibility is enough. You still have to bet on which parts of your domain will change, and you can bet wrong in both directions.

Which of your current requirements are stable policy, and which are guesses about next year dressed up as policy?
Where would a new payment method or regulation force you to edit working code instead of adding a module?

Take one feature spec and mark each requirement as stable policy or volatile guess. Count the volatile ones.

Sources

Victor Font: Designing Requirements That Can Survive Change

IQ Inc: Designing Software for the Unknown Future

TechTarget: How to tame ever-changing requirements

Share:

Recommended for you

Enjoyed this article?

Subscribe for new articles. No spam. Unsubscribe anytime.

By subscribing you agree to receive the newsletter. No spam, and you can unsubscribe anytime.