# The Seven Dimensions of Impact

# The Seven Dimensions of Impact

What ten landmark systems teach us about building software that matters in the AI era

— — -

Every product review I sit in now opens the same way: ”…and we’re adding AI to it.”

Here is the thing nobody wants to say out loud. AI is not a strategy. It is a capability. The real question is whether the thing you are building deserves to exist at all.

So I went back and asked a harder one: what do the IT systems that genuinely changed the world have in common at the architectural level?

I picked ten — Salesforce, WhatsApp, Google Search, AWS, the iPhone, Facebook, Windows and Office, Visa, Linux, and Stripe.

Different decades. Different categories. Same seven dimensions, every single time.

Miss one and your system might launch. Miss two and it will not scale. Miss three and it will not survive contact with reality.

— — -

What these ten systems actually changed

Not features. Friction removed.

Salesforce made software a subscription, not an install. WhatsApp made global messaging free and encrypted by default. Google replaced keywords with link-graph authority. AWS turned infrastructure into an API. The iPhone collapsed five devices into one with an SDK. Facebook built the first persistent identity layer for the open internet. Windows and Office standardized productivity across every enterprise. Visa built a trust fabric that clears a cross-border card payment in two seconds. Linux proved open beats closed — it now runs most of the cloud. Stripe turned six weeks of bank integration into seven lines of code.

Notice the pattern. None of them are famous for a feature. They are famous for what they removed from the user’s path.

— — -

Dimension 1: A non-negotiable wedge problem

Each of these systems solved one painful, frequent, measurable problem before attempting a second.

Salesforce started as hosted sales automation. WhatsApp started as a way to avoid SMS charges. AWS started with S3 and EC2. Stripe started with seven lines of code.

The trap today: teams start with “we have an LLM” and look for the problem after. If your AI feature cannot be described in one sentence as “this replaces X painful, frequent, measurable task,” you are decorating, not building.

— — -

Dimension 2: Radical simplicity at the surface

WhatsApp’s UI was a list of conversations. Google’s home page was a logo and a text box. The iPhone had one button.

All the complexity got pushed backward into the architecture so the user-facing surface could stay almost insultingly simple.

The trap today: a chat box is not simplicity. A blinking cursor in front of a non-deterministic model is the least simple interaction ever invented. Real simplicity in AI means narrowing the scope so the user knows exactly what the system will and will not do. The AI features that won the last two years — Copilot’s tab-complete, Cursor’s inline edit, Agentforce inside specific workflows — all expose a job, not a model.

— — -

Dimension 3: Trust as architecture, not policy

Visa’s fraud liability, dispute mechanism, and settlement guarantees are baked into the rails — not bolted on as terms. WhatsApp’s end-to-end encryption means even WhatsApp cannot read your messages. Salesforce’s multi-tenant isolation lets a regulated bank and a startup run on the same hardware without leaking into each other.

Trust is a structural property of the design. You can point to the code that makes it true.

The trap today: “We have a responsible AI policy” is not trust. Trust is whether the system can refuse, whether you can audit it three months from now, and whether one tenant’s error can touch another’s. If you cannot answer those with a diagram, you have a policy, not a trust model.

— — -

Dimension 4: A compounding loop

Google gets better the more queries it serves. WhatsApp gets more valuable the more contacts of yours are on it. AWS gets cheaper per unit as it scales — its prices dropped more than 100 times in its first 12 years.

The architectural question is whether each new user makes the next one cheaper, faster, or better — or whether each new user is just another linear cost.

The trap today: most enterprise AI is linear. Each new use case demands another integration, another fine-tune, another eval harness. The companies that will dominate the next decade are building loops — data improves models, models improve products, products drive usage, usage improves data. Most enterprises are not, and they should be honest about it.

— — -

Dimension 5: A platform others can build on

Salesforce became Salesforce when AppExchange launched. AWS is platform all the way down. iOS without the App Store would have been a footnote. Visa is a platform for issuers and acquirers.

The test: could someone outside your company build a real business on your API? If yes, you accumulate an ecosystem that defends you better than any moat. If no, you are competing on features, and features are easy to copy.

The trap today: most “AI products” are demos with no extensibility. No webhook, no SDK, no surface for partners. If you have not designed your AI system as something others can extend, you are building a feature.

— — -

Dimension 6: Resilience the user never sees

WhatsApp moves roughly 100 billion messages a day with a tiny engineering team. Each session is an isolated process — when one crashes, nothing else notices. S3 targets eleven nines of durability. Visa’s network survives entire data center failures without a merchant noticing.

The pattern: failure is assumed, not feared. Blast radii stay tiny. Recovery is automatic. The system degrades gracefully — typing indicators may drop, but messages never do.

The trap today: most AI systems are wired to fail loudly. A hallucinated JSON crashes the call. Production AI needs the same old disciplines — bulkheads between agents, circuit breakers on tool calls, idempotent retries, and graceful degradation when the model is uncertain. None of this is glamorous. All of it is what separates a demo from a system.

— — -

Dimension 7: Economics aligned with usage

Salesforce’s per-seat subscription aligned vendor revenue with adoption. AWS’s pay-per-second billing did the same for infrastructure. Stripe’s percentage-of-transaction model aligned with the merchant’s growth.

The architecture and the economics must reinforce each other. If your unit economics need high usage and your architecture makes high usage expensive, no amount of growth will save you.

The trap today: this is the single most underappreciated dimension in AI. If a feature costs forty cents per invocation and gets invoked thirty times a day per user, your math at one million users is a very different story from one thousand. Model the unit economics at 100x scale before you ship. If it breaks, redesign before you build.

— — -

The checklist

Before your next architecture decision, run the proposal through these:

One. Wedge. Can you state the problem in one sentence?

Two. Simplicity. Is the surface narrower than the engine behind it?

Three. Trust. Can you point to the structure, not the policy?

Four. Loop. Does each new user make the next one better?

Five. Platform. Could a partner build a business on your API?

Six. Resilience. What happens at the 99.9th percentile of failure?

Seven. Economics. Do the numbers still work at 100x volume?

Score well on five or more, it is probably worth building. Three or fewer, no AI will save it. All seven, and you may be looking at the next entry on the list above.

— — -

Closing

The temptation in 2026 is to believe AI rewrites the rules. It does not.

AI expands what is possible. It does not change what makes a system endure. WhatsApp’s 2009 principles — clarity over cleverness, isolation, asynchronous everything — apply unchanged to a 2026 agentic system. Salesforce’s 1999 insight that software should be a service, not a shipment, is the same insight Stripe applied to payments in 2010 and Anthropic is applying to intelligence today.

The seven dimensions are not technology-specific. They are architectural truths about how durable software gets built.

Build the wedge. Keep the surface simple. Make the trust structural. Compound the value. Open the platform. Engineer for failure. Align the economics.

Then, and only then, add AI.

— — -

The author writes independently on enterprise architecture, distributed systems, and the realities of building AI into production. The views here are his own.