No-code solution complexity
‘No-code’ doesn’t mean simplistic 2021-08-31 #NoCode
People sometimes expect or hope to find a way to make automation simplistic, especially with no-code solutions. In practice, no-code solutions decline to exhibit several kinds of simplicity, while the subject matter experts who build them don’t care.
Process complexity
We mislead ourselves with simple business process examples, such as a vacation request process that illustrates key concepts with only a few process steps. Higher value business processes such as banking customer onboarding or insurance claims adjustment have far more steps.
In general, workflow examples’ box and arrow diagrams show the 5-10 steps that fit neatly on a page. While that might be appropriate for a high-level business process, successful automation takes care of details and edge cases, typically resulting in 50-100 steps.
Subject matter experts build complex solutions when they keep going until something works, and sometimes go way beyond what their tools intend to support. Although it doesn’t happen often, they sometimes add 1000 steps to a graphical workflow, because they can and perhaps because nobody told them they couldn’t.
Data complexity
The data used in automation solutions tells the same story. A vacation request requires little information: who wants to go on holiday, and when. But an insurance claim or opening a bank account requires an order of magnitude more.
In no-code automation, this corresponds using form builders to 50-100 fields on a form (usually split across multiple pages), rather than a simplistic example’s half-dozen fields. These examples are easier to spot when the previous solution was a spreadsheet with hundreds of columns.
Domain complexity
Subject matter experts build complex solutions when they work in a complex domain whose processes and data outgrow simple examples. The people we call experts have become comfortable in their domain’s essential complexity, which only surprises people whose arrogance leads them to assume that other people have easy jobs because they appear simple.
Subject matter experts also build complex solutions when they happily start building them without worrying about maintenance, which exactly mirrors what professional programmers do at first. Keeping things working for a group of people over the course of several years corresponds to a different kind of challenge.
Acceptable complexity
Subject matter experts’ comfort with complexity creates opportunities for no-code tools to offer complex functionality. To be successful, builders need a good user experience, not simplicity.
In the end, the benefit of no-code platforms lies not in avoiding complexity, but in avoiding the accidental complexity of legacy programming.
In his 1986 essay No Silver Bullet – Essence and Accident in Software Engineering, Fred Brooks discusses the difference between essential complexity and accidental complexity, and explains why we cannot expect a ‘silver bullet’ that will reduce automation effort by a factor of ten. He remains optimistic, however:
Although we see no startling breakthroughs, and indeed, believe such to be inconsistent with the nature of software, many encouraging innovations are under way. A disciplined, consistent effort to develop, propagate, and exploit them should indeed yield an order-of-magnitude improvement.
No-code automation continues previous decades work on reducing accidental complexity, and improving the usability of building solutions to automation problems’ essential complexity.
