Short summary

Conditional logic is the set of rules deciding what a user sees next based on what they have told the service. It is also one of the primary sources of structural fragility in complex journeys. Each condition is an assumption about a user state, and as conditions accumulate, the combinations the design has not explicitly accounted for multiply far faster than any team's ability to check them. The fragility looks like a development problem because the failing conditions were written in code, but it is a design problem, introduced the moment conditions were designed implicitly rather than explicitly.

The multiplication problem

Conditional logic scales badly against human attention. Three yes or no criteria produce 8 combinations, which a team can hold in mind and check. Add a fourth and it is 16. Introduce a criterion with three possible answers rather than two and the count multiplies.

The growth is not intuitive, which is the heart of the problem. A brief that grows from 3 criteria to 7 feels like a moderate increase in scope. In terms of the states the service can produce, it is not moderate at all.

Consider a designer handed a brief for a benefits eligibility checker. The initial scope has three eligibility criteria, each a yes or no, producing 8 possible combinations. That is manageable. By the time the brief is finalised there are seven criteria, some with 3 possible answers, producing 512 combinations. The design team has explicitly tested just 12 of them.

Where the other 500 go

The remaining untested combinations do not disappear. They are handled by conditions the developer authored during the build, based on their reading of the design intent. This is not a criticism of the developer, who is doing the only thing available to them: filling gaps in a design with reasonable interpretation, under delivery pressure, without the research context that produced the design.

In the eligibility checker, the service works correctly for the majority of users. For users in unusual eligibility combinations, which the policy team puts at around 8% of applicants, it produces guidance that is incorrect or internally contradictory.

8% is a small proportion but could be a large number of people. In a service processing tens of thousands of applications, it is a substantial population receiving wrong answers about their eligibility for something that matters to them.

Why this is a design problem

The instinct is to categorise this as a development issue, because the failing conditions were written in code during the build and the incorrect behaviour is technically a logic error.

The fragility was actually introduced earlier than that. It appeared the moment conditions were designed implicitly rather than explicitly: the moment the designer stopped mapping what the service should do and left the remaining gaps to be filled in later by someone interpreting intent.

A developer authoring a condition is making a design decision. If the design did not specify what the service does in a given state, the developer will decide, because the service has to do something. The only question is whether that decision is made deliberately by someone with the research context or pragmatically by someone without it, under time pressure, in the middle of a sprint.

This is why conditional logic sits with design rather than development, even though it manifests in code. The specification of what the service does in each state is a design responsibility, and implementation of that specification is a development one.

What explicit design of conditional logic looks like

Explicit design does not mean drawing all 512 combinations. That would be unmanageable and mostly wasted effort, since many combinations are variations that behave identically.

It means owning the decision about what the service does in each state the logic can produce, including the states the team assumes are unlikely. Unlikely is different from impossible, and the 8% live in exactly those states.

In practice, this involves a few specific moves.

  • Count the states before you design the screens: Multiply out the combinations your criteria produce. The number itself is often enough to change how a team scopes the work.
  • Group states by behaviour, not by combination: Many combinations produce the same outcome. Grouping reduces 512 combinations to a manageable number of distinct behaviours the service needs to support.
  • Name the states nobody wants to think about: Contradictory answers, incomplete data, combinations that policy did not anticipate. These are where the fragility concentrates.
  • Specify the default explicitly: Every service has a behaviour for states nobody designed. Deciding what that behaviour is, deliberately, is better than discovering it in production.

The last of these is the highest-value and the most often skipped. A designed fallback for unhandled states turns an unpredictable failure into a predictable one, which is a substantial improvement even when the underlying gap remains.

Instead of asking whether the conditional logic works, ask whether we have explicitly designed what the service does in every state the logic can produce, including the ones we think are unlikely.

Frequently asked questions

Why does conditional logic make digital services fragile?

Because the combinations of states multiply faster than a team's ability to check them. Three yes or no criteria produce 8 combinations. Seven criteria, some with three possible answers, produce over 500. Teams typically test a small fraction explicitly, and the remaining states are handled by conditions authored during build based on someone's reading of design intent, without the research context that produced the design.

Is conditional logic a design problem or a development problem?

It is a design problem that manifests in code. The fragility is introduced when conditions are designed implicitly rather than explicitly, leaving gaps for someone to fill by interpreting intent during build. A developer authoring a condition is making a design decision, because the service has to do something in that state. The question is whether the decision is made deliberately by someone with research context, or pragmatically under sprint pressure by someone without it.

How do you design conditional logic explicitly without mapping every combination?

Count the states your criteria produce, then group them by behaviour rather than by combination, since many combinations produce identical outcomes. Name the states nobody wants to think about, such as contradictory answers and combinations policy did not anticipate, because that is where fragility concentrates. Then specify explicitly what the service does in states nobody designed, so the fallback behaviour is deliberate rather than discovered in production.

How many users are affected by untested conditional states?

It varies by service, but the proportion is consistently larger than teams expect. In a benefits eligibility example with seven criteria producing over five hundred combinations, the policy team estimated around 8% of applicants fell into unusual combinations. In a service processing tens of thousands of applications, a single-digit percentage represents a substantial number of people receiving incorrect guidance about something that matters to them.