# Complexity Has to Earn Its Keep

## Why enterprise decision software should start simple, use AI to eliminate repeated inference, and add infrastructure only when the requirement proves it belongs

I have built systems that I later wanted to simplify, sometimes aggressively.

That matters because this is not an argument from the cheap seats. It is easy to look at somebody else's architecture after the boxes have multiplied and conclude that the whole thing has become absurd. It is considerably harder when some of those boxes exist because you put them there yourself.

I have built software because the problem justified it at the time, handed it forward, watched requirements change, watched engineering add capabilities, watched operational obligations accumulate, and then returned later with a much less comfortable question: why are we still carrying all of this?

There is usually an answer for every component. The database exists because the application needs data. The API exists because the front end needs access to that data. The runtime exists because the API has to execute somewhere. Then come service identities, secrets, deployment pipelines, monitoring, alerting, recovery, patching, dependency management and operational ownership because once the machinery exists, somebody has to keep it alive.

Every answer can be individually reasonable while the resulting system is collectively unreasonable.

The problem is not necessarily that somebody made a bad engineering decision. The problem is that organizations are much better at asking why a component should be added than why it should continue to exist.

**Complexity has to earn its keep.**

## We keep starting with the solution

A surprising amount of enterprise software begins with an architectural reflex.

Someone needs an inventory viewer, readiness console, operational dashboard, evidence browser, architecture assessment, fleet explorer, compliance surface or decision-support tool. The actual requirement is often straightforward: take information the enterprise already possesses, organize it, calculate or correlate some things, make relationships visible, and help a human make a better decision.

Then software culture takes over.

The discussion shifts quickly to databases, APIs, hosting, authentication, service accounts, secrets, deployment pipelines, observability, recovery and support. Before long, a modest decision tool has inherited the operational obligations of a small commercial application.

Sometimes that is exactly right. A transactional system really does need transactionality. Real-time coordination really does need persistent runtime. Privileged integrations, server-side secrets and authoritative mutation need controlled execution somewhere.

Those are requirements.

"It is an application" is not a requirement.

The first architecture question should therefore be more demanding than "what stack should we use?"

> **What requirement exists that the simpler architecture cannot satisfy?**

If we cannot answer that precisely, the complexity has not yet justified itself.

## The enterprise already owns more of the stack than we admit

This becomes especially interesting inside large enterprises because we repeatedly ignore infrastructure that already exists.

The organization may already have durable storage, enterprise identity, group-based access control, retention, version history, auditing, search, information classification, lifecycle management and administrative governance. It has already paid for those capabilities, already operates them and already has people responsible for them.

Then a department needs a bounded decision tool and we recreate much of that machinery beside the systems that already contain the authoritative information.

We copy the data into another store. We create another authorization path. We stand up another runtime. We create another place where information can become stale. We acquire another operational dependency and another thing that needs to survive organizational changes, staff turnover and platform upgrades.

Eventually somebody produces a presentation explaining why the application estate has become too complicated.

There are absolutely cases where the duplication is necessary. The mistake is assuming necessity before proving it.

SharePoint is a useful example because many enterprises already use it for governed document and information storage, but this is not really a SharePoint thesis. The broader principle is simpler: **count the capabilities of the platform you already own before rebuilding them somewhere else.**

If an existing governed information plane can satisfy persistence, identity, retention, access control and distribution requirements, those are real architectural capabilities. They should be treated as such.

That changes the design space considerably.

## The Portable Decision Surface

The pattern I keep coming back to is what I call a **Portable Decision Surface**.

At its simplest:

**governed source plane → controlled reconstruction packet → AI-assisted engineering → deterministic decision surface → controlled refresh**

The authoritative information remains where the enterprise already governs it. A controlled process assembles the bounded information needed for a particular decision surface. AI can help interpret messy inputs, reconcile structures, create transformation logic, improve the interface, generate tests and work through ambiguity.

Then the useful result gets turned into deterministic software.

The resulting surface might be an interactive HTML application, a JavaScript explorer, an evidence browser, an inventory console, a report, a visualization or something more specialized. It may contain a substantial amount of code. It may be sophisticated software.

What it does not automatically require is a permanent service behind it.

**Software is not synonymous with service.**

That distinction is more important than it sounds. We have become accustomed to treating application development and service development as essentially the same activity. They overlap frequently, but they are not identical.

A piece of software does not become more legitimate because a server is continuously running somewhere behind it.

For many bounded, read-oriented decision tools, the runtime can live almost entirely in the portable artifact while persistence, identity and governance remain in platforms the enterprise already operates.

## The packet matters more than the conversation

AI makes this architecture considerably more practical, but perhaps not for the reason people initially assume.

The interesting part is not the chatbot. It is portability.

AI sessions are temporary. Context windows end. Execution environments disappear. Models change. Products change. Licensing changes. Vendors change their minds about what a feature should be called this quarter.

The engineering state does not have to disappear with any of them.

A well-constructed package can carry forward the durable state of the work: source material or governed references, application code, schemas, transformations, assumptions, tests, instructions, provenance and the important decisions already made.

I think of that as a **portable reconstruction packet**.

Sometimes the packet is literally a ZIP file. There is nothing profound about the file format. Humanity solved "put related files together" long before generative AI showed up and started getting credit for discovering folders.

The important part is the discipline. The packet should contain enough state that another capable execution environment can understand what exists, reconstruct it, modify it and validate the result without depending on the memory of the previous conversation.

Once that happens, the AI conversation stops being the unit of continuity.

The work becomes the unit of continuity.

That has important consequences. An ephemeral execution environment can be useful without becoming authoritative. One model can start the work and another can continue it. The intelligence can be temporary while the engineering state remains durable.

That is a much healthier dependency model.

## Use your tokens to burn down inference debt

This is the part of the pattern I care about most.

A lot of AI architecture seems to assume that progress means putting more inference into the finished system. I often want exactly the opposite.

I want to use expensive intelligence aggressively while the problem is messy and then eliminate as much repeated intelligence as practical once the problem is understood.

Use a model to discover structure in inconsistent inputs. Let it reconcile schemas, identify edge cases, write parsers, generate transformation logic, build tests, improve the interface and explain relationships that were difficult to see before.

Then capture that understanding.

Stable decisions should become schemas. Repeatable judgments should become rules. Transformations should become code. Expected behavior should become tests. Important invariants should become deterministic validation.

**Use your tokens to burn down inference debt.**

Inference debt is what we create when a system has to keep reasoning about something we already know how to express deterministically.

If the same judgment will be made fifty thousand times, and we can safely encode it in software after understanding it once, I would rather pay for the reasoning once than pay a model to rediscover the same answer fifty thousand times.

That is not an argument against AI. It is an argument for using AI where its leverage is highest.

Probabilistic systems are extremely useful against ambiguity, synthesis and incomplete structure. But once ambiguity has been reduced enough that stable behavior can be expressed deterministically, the architecture should be allowed to change.

Inference that still earns its keep should remain.

Inference that no longer earns its keep should disappear.

The same standard should apply to every other architectural dependency.

## Refresh is not runtime

A similar category error appears whenever someone says, "But the data changes."

Naturally it changes. Almost all useful operational information changes.

That does not prove that the user-facing application needs an always-running backend.

There is a meaningful difference between a **refresh requirement** and a **runtime requirement**.

If the underlying information changes daily, perhaps the deterministic surface is regenerated daily. If it changes hourly, perhaps the refresh runs hourly. A refresh process can retrieve or receive updated information, validate the structure, apply deterministic transformations, record provenance, build a new package, verify the output and publish the replacement.

If validation fails, the process can stop rather than publishing a bad state.

The decision surface itself can remain portable.

For many internal tools, this is perfectly adequate. Users still receive current information, but the organization does not inherit an always-running application tier whose principal responsibility is staying alive between updates.

There will be cases where this approach is obviously insufficient. That is fine. Those cases have identified a requirement that earns additional architecture.

The point is simply that changing data does not automatically imply persistent runtime.

## "Internal" is not a security model

The security conversation also becomes distorted once AI enters the room.

Suppose a dataset contains employee names, usernames, workstation names, device identifiers or operational metadata. That information deserves appropriate protection.

But none of those information classes appeared when generative AI arrived.

Enterprises have been moving them through spreadsheets, exports, internal websites, reports, ticketing systems, email attachments, shared drives and dashboards for decades. All of those surfaces can be overshared.

An internal website can be overshared. A spreadsheet can be overshared. A CSV can be overshared. A SharePoint library can be overshared. An AI workflow can be overshared.

The governance question remains fundamentally the same: who can see the information, why can they see it, what can they do with it, how long should access remain, and what controls actually enforce those decisions?

That is why "but it contains employee information" is not, by itself, a particularly useful architectural objection. The information classification matters, but so does the actual exposure model.

Consider two designs.

One is an internal dashboard accessible to thousands of employees because that is simply how the site was deployed.

The other is a deliberately permissioned decision surface available to twenty people who have a defined business reason to see the information.

Assuming the controls are functioning as intended, those are not equivalent risk surfaces. The smaller authorized population represents the narrower exposure.

This does not mean that a controlled SharePoint folder or any other repository is secure simply because somebody intended it to be. Permissions still have to be correct. Sharing behavior matters. Downloads matter. Retention matters. Auditability matters. Copies remain copies.

That is ordinary information governance.

AI does not require us to abandon that reasoning. If anything, it gives us another reason to practice it properly instead of relying on the comforting but meaningless label "internal."

**Internal is not the same thing as least privilege.**

## The backend still has a job

None of this means backends are obsolete. That would replace one reflex with another, which is not much progress.

Persistent services earn their keep constantly.

If a system needs transactional consistency across concurrent writers, server-side secrets, privileged service identities, authoritative mutations, durable queues, long-running state machines, real-time coordination, centralized policy enforcement, dynamic querying across very large datasets, hard availability requirements or controlled external integrations, persistent infrastructure is probably the correct architecture.

Then build it.

Build it properly, secure it, monitor it, patch it, recover it and accept the cost of owning it.

The difference is that the requirement came first.

I do not want no backend.

I want **no unearned backend**.

## Every box creates an obligation

Architecture diagrams make components look deceptively inexpensive.

They are rectangles.

Real systems are less accommodating.

Every rectangle creates a lifecycle. A database needs maintenance and recovery. An API acquires compatibility requirements. A service identity requires credential governance. A runtime needs patching. Dependencies need updating. Queues need failure semantics. Monitoring creates response obligations. Caches eventually demand invalidation strategies because software engineering occasionally appears to have been designed as an endurance test.

None of those components are inherently bad.

The point is that **capability and obligation arrive together**.

This distinction becomes more important as AI reduces the cost of producing software.

A coding model can generate another service remarkably quickly. It can generate the tests, infrastructure configuration, deployment scripts and documentation too.

The enterprise may still own that service for a decade.

That means cheap implementation can actually make architectural discipline more important, not less. We are entering an era where organizations can create machinery faster than they can rationally retire it.

The scarce question is no longer whether the code can be produced.

It usually can.

The harder question is whether the thing should exist at all.

## This is not a low-code thesis

Portable and simple should not be confused with primitive.

A Portable Decision Surface can contain serious software. It can support interactive visualization, filtering, search, local analytics, validation, provenance, evidence navigation, accessibility, controlled export and polished user experience.

The simplification is architectural.

We are reducing unnecessary runtime dependencies, not reducing engineering quality.

In some cases I would happily trade more deterministic application code for less infrastructure. Code can be inspected. Code can be tested. Code can be packaged. Code can be versioned. Code can survive the disappearance of the AI system that helped write it.

That is a useful trade.

The goal is not less capable software.

The goal is software whose operational footprint is proportional to the problem being solved.

## The long tail is enormous

Dashboards are only the obvious example.

Large enterprises contain a long tail of internal tools that are primarily projections over information already held somewhere else: audit evidence viewers, migration assessments, fleet inventories, architecture reviews, risk registers, compliance explorers, operational scorecards, capacity tools, readiness packages, historical evidence browsers, portfolio summaries and configuration viewers.

Many are read-heavy. Many serve bounded audiences. Many refresh periodically rather than continuously. Many do not own authoritative transactional state. Their purpose is often to improve human understanding rather than coordinate machines in real time.

None of those properties proves that a Portable Decision Surface is the right answer.

They make it worth asking the question.

That distinction matters because I am not trying to create another architecture religion. Enterprise technology already has a healthy supply of those.

I am proposing a test:

> **What capability does the more complex architecture provide that the simpler one cannot?**

If the answer is concrete, the complexity earns its keep.

If the answer is tradition, familiarity or "this is how we normally build applications," the architecture has not made its case yet.

## Architecture should become simpler as understanding improves

There is also a cultural problem underneath this.

Engineering organizations are good at adding things. Removal feels more dangerous.

A new component solves a visible problem. Removing one creates anxiety about invisible dependencies. Teams change. Original assumptions get lost. Requirements disappear into history. Architecture accumulates through a series of decisions that were often perfectly reasonable when considered individually.

Complexity enters one defensible decision at a time.

Eventually nobody can explain the entire system without an hour-long meeting and three diagrams.

Mature engineering should push in the other direction too.

As understanding improves, architecture should have permission to shrink.

When AI helps turn fuzzy manual reasoning into deterministic software, the system should become simpler. When an existing governed platform already satisfies identity, retention, access and storage requirements, those capabilities should count. When periodic regeneration satisfies freshness, we should not pretend continuous runtime is necessary.

And when a component no longer satisfies a requirement that matters, we should be willing to remove it even if we were the ones who designed it.

Especially if we were the ones who designed it.

There should be no architectural prestige attached to preserving machinery that no longer earns its existence.

## Keep it simple until complexity earns it

I am not arguing for simplistic systems.

I am arguing for systems whose complexity is proportional to their requirements.

That is a much harder standard.

Keep authoritative information in the governed plane when that plane can satisfy the requirement. Carry durable engineering context in reconstruction packets instead of depending on the memory of an AI conversation. Use frontier intelligence aggressively where ambiguity demands it, then capture what it learns and turn stable reasoning into deterministic software.

Separate refresh requirements from runtime requirements. Control the actual audience instead of treating "internal" as a security model. Add persistent services when they provide capabilities the simpler architecture genuinely cannot provide.

And every time another box appears on the architecture diagram, ask the same question:

> **What requirement do you satisfy that the simpler architecture does not?**

If it has a good answer, keep it.

If it does not, take it out.

AI is going to make it extraordinarily easy to build more software.

The harder discipline will be knowing what not to build.

**Complexity has to earn its keep.**
