Ulfhednar Labs Article

Complexity Is Not the Same as Sophistication

A complex industrial system with tangled redundant components contrasted against a cleaner engineered system performing the same function.

The smartest system is not the one with the most parts. It is the one that accomplishes what it needs to accomplish with the least unnecessary burden.

Complex systems can be impressive.

Sometimes they have to be.

Modern aircraft are complex. Electrical grids are complex. Global logistics networks are complex. Operating systems, semiconductor manufacturing, financial markets, hospitals, telecommunications networks, and large-scale software platforms all solve problems that genuinely require enormous coordination.

Complexity itself is not the problem.

Unnecessary complexity is.

Somewhere along the way, we began treating complexity as evidence of sophistication.

A product has more features, so it must be better.

A business process has more approvals, so it must be more controlled.

A government program has more rules, so it must be more thorough.

A software platform has more settings, dashboards, integrations, menus, and configuration options, so it must be more powerful.

Sometimes those additions are justified.

Sometimes they are evidence that nobody has been willing to remove anything.

A system does not become sophisticated merely because it is difficult to understand.

And making something harder is not the same as making it better.

Necessary Complexity and Accidental Complexity

There are two very different reasons a system can become complicated.

The first is that the problem itself is difficult.

The second is that the solution was allowed to become difficult.

That distinction matters.

Some complexity is unavoidable.

A system may need to account for:

  • safety;
  • security;
  • regulation;
  • reliability;
  • competing user needs;
  • scale;
  • failure recovery;
  • unusual edge cases;
  • interoperability;
  • or physical constraints.

Removing those protections in the name of simplicity can create a worse system.

That is not what good simplification means.

Good simplification removes complexity that does not contribute enough value to justify its cost.

That cost can appear as:

  • more training;
  • more maintenance;
  • more errors;
  • more support requests;
  • slower decisions;
  • more opportunities for failure;
  • more dependencies;
  • more cognitive burden;
  • and more difficulty changing the system later.

A sophisticated system knows where complexity is necessary.

A poorly designed system simply accumulates it.

Every Addition Has a Cost

Adding something to a system is usually easier than removing it.

That creates a predictable problem.

A customer requests a feature.

Add it.

A manager wants another report.

Add it.

An unusual failure occurs.

Add another rule.

Someone wants visibility into a decision.

Add another approval.

Two departments need slightly different workflows.

Add another branch.

A regulation changes.

Add another form.

A vendor introduces a new platform.

Connect it to everything else.

Each individual decision may appear reasonable.

But systems are not experienced one decision at a time.

They are experienced as the accumulated result.

After enough additions, the organization has built something nobody would have intentionally designed from the beginning.

This is how complexity grows quietly.

It rarely arrives with someone announcing:

“We are going to make this system unnecessarily difficult.”

It arrives as a hundred individually defensible decisions.

Software Makes This Especially Easy

Software has a dangerous advantage:

Adding another layer can be cheap.

At least initially.

A developer can add:

  • another menu;
  • another setting;
  • another notification;
  • another dashboard;
  • another permission level;
  • another integration;
  • another confirmation screen;
  • another workflow state;
  • another data field.

The immediate cost may appear small.

The long-term cost is different.

Every new feature can introduce:

  • code that must be maintained;
  • interactions with existing features;
  • new failure states;
  • more documentation;
  • additional testing;
  • more security considerations;
  • more interface decisions;
  • more user confusion;
  • and more technical debt.

Eventually the software may have tremendous capability while becoming increasingly unpleasant to use.

That is not necessarily sophistication.

It may simply be accumulation.

The question should never be only:

Can we add this?

It should also be:

Is this addition worth making the entire system more complicated forever?

More Features Can Produce a Worse Product

Feature lists are easy to market.

Simplicity is harder to advertise because simplicity often consists of things that are no longer there.

A product with fifty capabilities may look more impressive on a comparison chart than one with fifteen.

But the customer does not use a comparison chart.

The customer uses the product.

If the fifteen-feature product allows users to accomplish their goals quickly, reliably, and without unnecessary instruction, it may be the more sophisticated design.

Good design often hides enormous technical complexity behind a simple interaction.

The user does not need to understand:

  • every internal service;
  • every database transaction;
  • every protocol;
  • every authentication exchange;
  • every dependency;
  • every validation step;
  • or every recovery mechanism.

Those systems may be extremely complicated internally.

But if they are designed well, much of that complexity is absorbed by the system instead of transferred to the user.

That is an important distinction.

Real sophistication often makes difficult things feel simple.

Business Processes Accumulate Complexity Too

Software is not unique.

Organizations do the same thing with procedures.

Consider how an ordinary business process can grow.

Someone makes a mistake.

A manager creates an approval step.

Another mistake occurs.

A checklist is added.

Leadership wants visibility.

A report is required.

Another department becomes involved.

A handoff is created.

An audit asks for documentation.

Another form appears.

Nobody wants responsibility for removing any of it because every step once had a reason.

Eventually a simple decision requires:

  1. a request;
  2. a form;
  3. manager approval;
  4. department review;
  5. data entry;
  6. another approval;
  7. status reporting;
  8. final verification;
  9. documentation;

The organization may call this governance.

Some of it may genuinely be governance.

Some of it may be organizational sediment.

The correct question is not whether each step once had a justification.

The question is whether each step still earns its place in the system.

Control Is Not Measured by the Number of Approvals

Organizations frequently respond to risk by adding approval.

That can feel responsible.

It is also possible to build a process containing so many approval points that nobody feels personally responsible for the outcome.

Everyone touched it.

Nobody owned it.

Additional approvals can also produce a dangerous illusion:

If more people reviewed the decision, the decision must be safer.

Not necessarily.

Three people quickly clicking Approve may provide less meaningful oversight than one person with:

  • clear authority;
  • relevant expertise;
  • good information;
  • defined accountability;
  • and enough time to actually evaluate the decision.

Good controls should reduce meaningful risk.

They should not merely demonstrate that a process occurred.

There is a difference between control and the appearance of control.

Complex systems often blur that distinction.

Government Has the Same Problem at a Larger Scale

Government systems face legitimate complexity.

They must often serve enormous populations while balancing:

  • law;
  • due process;
  • public accountability;
  • accessibility;
  • fraud prevention;
  • privacy;
  • competing political priorities;
  • budget constraints;
  • and different levels of government.

That guarantees some complexity.

But necessary complexity can become a convenient shelter for unnecessary complexity.

  • Rules accumulate.
  • Forms accumulate.
  • Programs overlap.
  • Exceptions create new exceptions.
  • Temporary procedures become permanent.
  • Different agencies collect the same information.

Citizens are expected to understand organizational structures they had no role in creating.

Eventually the burden of navigating government becomes a problem independent of whatever service the government was originally trying to provide.

That burden has consequences.

Complexity can make systems harder to:

  • understand;
  • access;
  • audit;
  • improve;
  • challenge;
  • and hold accountable.

A system that nobody can clearly explain is difficult to govern well.

That should matter regardless of political ideology.

Everyday Technology Shows the Same Pattern

Complexity also appears in smaller places.

Consider how many ordinary devices now require:

  • an account;
  • an application;
  • a Wi-Fi connection;
  • firmware updates;
  • permissions;
  • cloud services;
  • registration;
  • subscriptions;
  • or online authentication.

Sometimes those capabilities create meaningful value.

Sometimes you wanted the light bulb to turn on.

Connectivity is not automatically improvement.

Digitization is not automatically improvement.

Automation is not automatically improvement.

Artificial intelligence is not automatically improvement.

Adding technology creates value only when the benefit is greater than the new burden.

If a smart device takes longer to configure, fails when a remote service goes offline, collects unnecessary personal data, and loses functions when the manufacturer abandons its software, the word smart deserves some scrutiny.

A more technologically complicated product can still be a worse tool.

Complexity Can Hide Weak Design

Complexity has another convenient property:

It can make poor design difficult to challenge.

When a process becomes complicated enough, almost any problem can be blamed on the complexity itself.

Users do not understand the system.

Employees need more training.

Customers need better instructions.

Another support article needs to be written.

Another exception needs to be added.

Another tool needs to be purchased.

The system grows again.

Eventually people begin assuming the problem is their inability to understand the system.

Sometimes it is.

But sometimes the correct explanation is simpler:

The system is badly designed.

A good system should not require users to understand unnecessary internal complexity.

When ordinary tasks consistently require expert knowledge, undocumented workarounds, extensive training, or memorized exceptions, that is information about the design.

Simplicity Is Not the Same as Removing Things

There is an opposite mistake worth avoiding.

Simplification does not mean blindly deleting features, regulations, safeguards, controls, or steps.

A superficially simple system can hide enormous risk.

Removing a verification step may save thirty seconds while enabling fraud.

Removing redundancy may reduce cost while creating a single point of failure.

Eliminating documentation may accelerate work while destroying accountability.

Reducing security controls may improve convenience until somebody gets compromised.

So the objective cannot be:

Make everything simpler.

The better objective is:

Make everything no more complicated than it needs to be.

That requires understanding what each component contributes.

Before removing something, ask:

  • What problem was this created to solve?
  • Does that problem still exist?
  • Does this component actually solve it?
  • What happens if we remove it?
  • Can the same protection be achieved more efficiently?
  • Does another part of the system already perform the same function?
  • Who benefits from this step?
  • Who carries its burden?

Simplification without understanding is just another form of poor design.

Complexity Should Have to Defend Itself

Organizations often require justification before something can be removed.

Perhaps complexity should face the same standard before being added.

For every new layer, feature, process, requirement, or dependency, ask:

What Value Does It Create?

Not what activity does it create.

What outcome improves?

What Complexity Does It Add?

How many new interactions, failure modes, decisions, and maintenance requirements follow?

Who Carries the Burden?

The developer?

The employee?

The customer?

The taxpayer?

The support team?

Someone will.

Is There a Simpler Way to Achieve the Same Outcome?

A sophisticated solution may eliminate the need for the new layer entirely.

How Will We Know When This Is No Longer Necessary?

Systems need a way to forget.

Otherwise temporary solutions become permanent architecture.

The Best Systems Absorb Complexity

There is an important pattern in good engineering.

Complexity does not always disappear.

Sometimes it moves.

A well-designed system often takes complexity away from the person using it and handles that complexity internally.

The user performs one action.

Behind that action the system may:

  • authenticate identity;
  • validate information;
  • check permissions;
  • coordinate multiple services;
  • recover from transient failures;
  • maintain an audit record;
  • secure the transaction;
  • update several data stores;
  • and confirm the final state.

That is still a complex system.

But it is complex where complexity belongs.

The user does not need to perform nine separate tasks merely because nine internal operations occur.

That is sophistication.

The system carries the burden.

Measure the Burden, Not the Architecture Diagram

Complex systems often look impressive in presentations.

  • Boxes.
  • Arrows.
  • Departments.
  • Platforms.
  • Layers.
  • Integrations.
  • Approval paths.
  • Data flows.

The diagram grows until the size of the system itself becomes evidence of importance.

But the architecture diagram is not the outcome.

What matters is whether the system:

  • works;
  • remains understandable;
  • can be maintained;
  • can recover from failure;
  • can change when requirements change;
  • protects what matters;
  • and allows people to accomplish what they came to accomplish.

A system should be judged by the problem it solves.

Not by how much machinery was required to describe it.

Sophistication Is Disciplined Complexity

The objective is not minimalism for its own sake.

Some problems really are complicated.

Some solutions genuinely require thousands of moving pieces.

The goal is discipline.

  • Every part should have a reason.
  • Every dependency should justify the failure modes it introduces.
  • Every process should justify the time it consumes.
  • Every control should reduce a meaningful risk.
  • Every feature should create enough value to justify maintaining it.
  • Every abstraction should make the system easier to use or understand.

And anything that no longer earns its place should be eligible for removal.

That is a very different philosophy from endlessly adding more.

Better Systems Are Not Always Bigger Systems

There is a tendency to equate progress with expansion.

  • More features.
  • More automation.
  • More data.
  • More controls.
  • More integrations.
  • More intelligence.
  • More technology.

Sometimes progress is exactly that.

Other times progress looks like:

  • fewer steps;
  • fewer dependencies;
  • fewer decisions;
  • fewer forms;
  • fewer places to make a mistake;
  • fewer tools;
  • fewer unnecessary features;
  • fewer things the user needs to understand.

Good systems thinking requires knowing which direction is actually improvement.

Because complexity can be necessary.

Complexity can even be beautiful.

But complexity by itself proves nothing.

A system is not sophisticated because it has many moving parts.

It is sophisticated when every moving part earns the right to be there.

Ulfhednar Labs

Software Without Limits.

Professional writing, development perspective, and ideas from the work behind Ulfhednar Labs.

More Articles ↗
All Articles