In a recent meeting, a coworker told me I needed to change my dislike for Microsoft.

It stuck. Not because it offended me — but because it forced a question I hadn’t asked out loud: Is this a dislike?

The honest answer is no. What looks like skepticism toward one vendor is something older and more structural. It’s the instinct I carry into every architecture decision, regardless of whose logo is on the slide: design for exit first, and vendor value second. And that instinct didn’t come from nowhere. It came from open source. From Linux. From watching what happens when communities refuse to let a single company own the foundation.

This is the reflection that comment triggered.

The Pattern Has a Name — and Every Giant Runs It

Let me start by saying what this isn’t: a case against Microsoft specifically. Microsoft is the sharpest example, and the most documented one — but the behavior is universal.

Every enterprise software giant competes on the same axis. Become essential. Then make leaving expensive. It’s not malice. It’s how enterprise software businesses survive. Salesforce builds Flow automations, Apex code, and custom data objects that embed so deeply that the exit cost isn’t the software license — it’s the tribal knowledge your team built on top of it. AWS creates proprietary services — Lambda event sources, DynamoDB streams, Step Functions — that have no portable equivalents outside their cloud. VMware’s answer to an acquisition by Broadcom was to end perpetual licenses, collapse 160+ products into four bundles, and restructure pricing in a way that multiplied costs 8 to 15 times overnight for enterprises that thought they owned what they’d bought.

The playbook has a name: Embrace → Extend → Lock In. The details differ. The pattern doesn’t.

Recognizing this pattern across all vendors — not just the ones you’re personally skeptical of — is a core responsibility of a good architect. Not a philosophical stance. A professional one.

Linus Wasn’t Wrong — He Was Precise

Microsoft is worth examining in depth specifically because they are the most documented case.

In 1998, leaked internal memos — later published as the Halloween Documents — revealed Microsoft’s internal strategy toward open source: identify it as a threat, spread uncertainty, and prevent it from competing with Windows. Embrace, extend, and extinguish was documented internal thinking, not external criticism from open source advocates. In 2001, CEO Steve Ballmer made the position explicit: “Linux is a cancer that attaches itself, in an intellectual property sense, to everything it touches.” That wasn’t a metaphor. That was the official position of one of the most valuable companies on earth.

Linus Torvalds fired back that Microsoft was the real cancer and that open source was the immune system. The media painted him as the angry guy who couldn’t let go.

What gets missed in that framing is the precision of his argument. He never said Microsoft couldn’t change. He said they wouldn’t. That distinction matters enormously when you’re deciding whether to build on a vendor’s platform. A company constrained by technical debt can’t change. A company executing a strategy won’t. One tells you to be patient. The other tells you to map your exits.

The Nadella Pivot Was Real. And It Wasn’t.

I want to be fair here, because the post loses credibility if I pretend the last decade didn’t happen.

Satya Nadella took over in 2014 and made genuine product bets on openness. They open-sourced .NET. They shipped Windows Subsystem for Linux. They bought GitHub for $7.5 billion and ran it with a light touch for several years. These were real decisions, not just branding. Nadella deserves genuine credit for them.

But the pivot and the pattern coexist without contradiction.

The goal was never to join open source. It was to become the indispensable layer above it. Open-sourcing .NET makes the runtime portable — but Azure becomes the natural deployment target. Embracing Linux on Azure makes the OS a commodity — but the control plane, the identity layer, the AI fabric, and the productivity suite remain proprietary. The value extraction point moves up the stack. It doesn’t disappear.

“The goal was never to compete with open source. It was to make open source irrelevant by controlling the layer above it.” That framing is worth sitting with — not because it makes Nadella’s pivot cynical, but because it tells you exactly where to look when you’re doing architecture.

GitHub Copilot Is the Exhibit

The clearest signal is GitHub Copilot — not because it was dramatic, but because the mechanism was legible.

Microsoft bought GitHub. Developers uploaded billions of lines of code under open source licenses. Microsoft trained an AI on that code. Then they sold that AI back as a proprietary subscription service. Developers were furious. Microsoft’s response: fair use, the code is public, not breaking any laws.

Legally, they may have had a case. Ethically, it was the clearest proof of concept for what those 1998 internal documents described: taking community work, wrapping it in proprietary infrastructure, and monetizing the output without giving anything back. The Embrace → Extend → Make Irrelevant playbook, updated for the AI era.

The difference is that the community is now responding with coordination instead of frustration. More on that in a moment.

The same playbook now runs at the agent layer. In The Agent Control Plane War, I covered how Microsoft and Salesforce are both racing to own the agent control plane — if Copilot as training extraction is the exhibit, agent control plane capture is the trial.

Recall Was Not a Bug. It Was a Posture.

In 2024, Microsoft announced Recall: an AI productivity feature that screenshots everything you do on your computer, runs it through AI, and lets you search your full history.

Security researcher Kevin Beaumont discovered it stores everything in an unencrypted local SQLite database. Researcher Alexander Hagenah published an open source tool called TotalRecall demonstrating how trivially the data could be extracted — passwords, banking info, private messages, medical records — by any process running in the user’s context. Recall was set to ship on by default to enterprise Copilot+ PCs.

Microsoft pulled it after backlash. They later added encryption and made it opt-in.

The story isn’t the rollback. It’s that they were ready to ship it. The unencrypted database design, the default-on decision, the initial “we’re protecting users” framing — those were product decisions that cleared internal review. The posture is: ship, capture value, respond to public pressure. That posture is the real signal, not the specific feature that exposed it.

An architect cannot outsource their risk posture to a vendor whose risk posture is structurally different from their own. That’s not an opinion. That’s a constraint.

So Why Do I Keep Recommending Them?

Here is the honest part.

Microsoft’s compliance story is real. In a heavily regulated environment — banking, healthcare, federal government — “we run on Azure with Microsoft 365” answers a specific set of auditor questions that you cannot easily answer any other way. SOC2, ISO 27001, FedRAMP, HIPAA BAA, the full indemnification stack, the support SLAs, the incident response framework — these are genuine enterprise assets that small vendors can’t match and open source communities don’t even try to provide.

The auditor question “who issued the identity?” is much easier to answer when the answer is “Microsoft Entra.” The vendor governance question “who’s responsible when something goes wrong?” has a cleaner contractual answer with Microsoft than with a collection of open source tools and smaller SaaS providers.

This is risk mitigation, not vendor capture. The distinction is whether you know the trade-off you’re making. As I explored in The Architect’s Dilemma, even Microsoft’s strongest governance story develops holes when you start mixing AI ecosystems inside a regulated environment — particularly when you ask them to govern identities across platforms they don’t fully control.

The dichotomy is real: a vendor with a documented history of strategic lock-in also provides the clearest answers to your compliance department. Both things are true simultaneously. Collapsing either one into the other produces either bad architecture or a bad audit.

The Open Source Counter — And Why History Is Repeating

Linux didn’t beat Windows by being louder. It won by becoming too useful to ignore.

Nobody owns Linux. Microsoft, Google, and Amazon all run on it. That’s not an accident — it’s what happens when a sufficiently good open foundation exists and nobody can fence it off. The lock-in pressure moved up the stack. But the foundation stayed free.

We’re in an analogous moment at the agent layer. At NVIDIA GTC in March 2026, Jensen Huang said something worth writing down: “OpenClaw is the new Linux.” He called it essentially the operating system for agentic computers and said every company needs an OpenClaw strategy. The parallel is explicit: just as Linux became the open foundation for the internet era, OpenClaw is the community’s bid to own the open foundation for the agentic era — before any single vendor can close it off.

Microsoft’s Agent 365, Azure AI Foundry, and the broader Copilot platform are all bets on controlling the agent runtime layer. If the open source movement wins at that layer the way it won at the OS layer, the proprietary platforms become commodity wrappers. That’s not guaranteed. But it’s the fight.

This is what I mean when I say open source isn’t ideology. It’s the structural counter-pressure that keeps the lock-in from being permanent.

Design for Exit, Not for Comfort

The resolution isn’t choosing a side. It’s having a discipline that applies to every vendor — not just the ones you’re skeptical of.

When I review architecture decisions involving enterprise vendors, a few questions come up every time:

On identity: Does this workflow function if we change identity providers? If the answer is no, you’ve handed your exit to your IdP vendor. Federation standards exist for a reason.

On infrastructure: Are you locked to the underlying resources or to the orchestration layer above them? Cloud compute is relatively portable. The proprietary managed services layered on top are where the exit bill accumulates.

On AI: Which vendor’s AI layer have you made load-bearing? Using Copilot as a productivity tool is fine. If the AI layer becomes the only path to your institution’s architectural knowledge, you’ve made a lock-in decision that won’t be visible until you try to leave.

On data: Every enterprise analytics platform shows you your data in open formats. The question is whether the intelligence accumulated on top of that data can leave with you. As I covered in Open at the Bottom, Locked at the Top — “open formats” and “portable” are not the same statement.

On SaaS: The exit cost isn’t the license fee. It’s the integration surface, the automation logic, and the workflow knowledge your team built inside someone else’s platform. Map that before you’re locked.

None of this is anti-Microsoft. It’s the same checklist I run for Salesforce, AWS, ServiceNow, and every other vendor with a subscription and a product roadmap.

The Dilemma Doesn’t Resolve

My coworker wasn’t wrong to flag the perception. From the outside, consistent skepticism about a vendor can look like a grudge. The distinction is whether the skepticism is applied uniformly or selectively.

An architect who trusts Salesforce but not Microsoft, or trusts AWS but not Azure, isn’t practicing architecture — they’re practicing preference. The discipline only works if it’s consistent.

What I keep returning to: every enterprise giant has a business model built around making the exit expensive. That’s an accurate description of how subscription software works, not a conspiracy. The job of a good architect is to build systems that use vendor value without surrendering vendor control. The job of the open source movement — from Linux in 1991 to OpenClaw in 2026 — is to make sure there’s always a foundation nobody can close off.

I’ll keep using Microsoft. I’ll keep watching what they build on top of the things I care about. And every system I design will have a door I can walk out of.

That’s not paranoia. That’s the job.

---

If the lock-in pattern resonated, Open at the Bottom, Locked at the Top shows exactly how the strategy works at the data platform layer — open formats at the bottom, proprietary intelligence at the top.

Find me on X @orestesgarcia or LinkedIn /in/setsero.