The most dangerous handicap for a mature company is its own success. Successful companies polish their leading products, invest deep in narrow niches, and live well off generous profit margins. When conflict comes, successful companies rarely rush to meet it. Not because they lack the technical know-how, but because from the great height of their success, their competitors look so small and inferior.
Clayton Christensen was one of the first to describe this problem in The Innovator’s Dilemma — a business-school staple that’s often described as one of the most influential business books ever written. Christensen wanted to understand why successful companies, with their enviable technology and wide-moat advantages, were cut down by upstart competitors. At first, he suspected that big businesses just couldn’t keep up. In other words, their colossal size turned them into slow, lumbering giants. But as he looked deeper, he found that big companies didn’t fail because they fell behind — at least, not at first. In fact, the big companies often held on to superior products even as they were dying.
Instead, big businesses were losing to “good enough” technologies — new, inferior products that won on a combination of convenience, reach, and cost. These products weren’t clear winners, so they had to chip off the market from the bottom up. First, they’d grab the lower end. This brought in money, and the money fueled growth, and that growth fueled product improvement. Run this cycle long enough, and the second-rate competitor could gain all the capabilities of the market leader. It happened when mini mills defeated integrated steel mills. It happened when transistor radios replaced large consoles. When small-format computer disk drives defeated large ones. When digital cameras replaced film cameras (and when phone cameras replaced digital ones).
When challenged, successful companies spent too long investing in their successful technologies. They saw the competition, but they stuck with the advantages of their product. Film was still better. Large-format disk drives had more capacity and better reliability. Integrated steel mills produced better-quality steel. All of this was true, until it wasn’t. And by the time the second-rate product was challenging the first-rate product on all fronts, it was too late for the established companies to catch up.
Of course, there were exceptions. Intel’s former CEO, Andy Grove, read The Innovator’s Dilemma and was inspired to create a new down-market processor — the Celeron.
When the Celeron was first released in 1998, tech fans scorned the underpowered processor. But it sold wildly and held off competitors like Cyrix and AMD, who had hoped to challenge Intel with cheaper, “good-enough” alternatives. Grove credited it with saving the company.
But Microsoft was a different matter.
The story of the Innovator’s Dilemma is the story of Microsoft’s early success — most obviously, how it turned the second-rate Windows into the world’s dominant operating system, killing off competitors like OS/2 on the way. (OS/2 was a higher-end product by a more established company that failed to run on low-end computers.)
Microsoft won against IBM by focusing on the price-sensitive lower end of the market (consumers). Then, it gradually grew to overtake IBM in its more profitable territory (business). It began as a disruptor, then went on to build an empire.
Microsoft in the early 2000s had a long list of products, but the four pillars were clear. The first was the Windows operating system. The second was Office, the lingua franca of business. The third was made of server-based enterprise tools like SharePoint, but anchored by SQL Server. The fourth was the developer ecosystem, which revolved around Visual Studio.
Many of these pieces began as upstart competitors to better products. For example, Microsoft had tried to compete in office software back in the days of DOS, but its offerings lagged behind the then-dominant WordPerfect and Lotus. Similarly, when SQL Server first appeared, it was a budget-priced upstart against more established players, many who have since died (like Ashton-Tate, Informix, Ingres, and Sybase), and a few that are still alive (Oracle and IBM).
In the late 2000s, Microsoft still seemed almost invulnerable. It was deeply entrenched in the business world. Its four pillars reinforced each other, and boxed in the competition. But this position of strength hid weaknesses on all sides — a classic innovator’s dilemma problem. Each branch of its software empire was expensive. And each branch was bound by the proprietary rules of the Microsoft ecosystem.
Microsoft knew this could someday be a problem. It had already gone to great lengths to stop ordinary customers from jumping ship to Linux, and to stop corporate customers for trying to cut costs with Libre Office (known at the time as OpenOffice). But there was another audience they couldn’t persuade so easily — software developers.
By 2010, open source was becoming a growing threat to Microsoft. The danger wasn’t new — in fact, a quiet, smoldering war had been underway since the early 1990s, when internal Microsoft documents set out the company goal of disrupting open source software. More publicly, Bill Gates was on record calling open source a new communism. Steve Ballmer had called Linux a cancer. It didn’t matter that this die-hard opposition had begun to soften. After years of trying to co-opt open standards (embrace, extend, extinguish) and hobble open source products, the open source community saw Microsoft as a tech version of the Evil Empire.
It was a textbook case for Christensen’s book — the moment where a massive company falls to disruptive change. First it retreats to its most profitable niches, the places where it can still win comfortably. Then it barricades the gates and relies on the strength of its dominant position. And when the threat doesn’t go away, it’s too late to change course.
In an alternate universe, that might have been the end of Microsoft — or at least the beginning of a slow and prolonged decline. But in this timeline, Microsoft made several smart moves.
First, they created free competitors to their own products. Microsoft created a free upgrade path to Windows 10 which still exists to this day. They built free (albeit inferior) web clients for Word, Excel, and PowerPoint. In much the same way that Intel revitalized itself with the Celeron, Microsoft’s changes gave price-conscious consumers the option of staying with Windows and Office. They also gave Microsoft a foothold if the company needed to pivot to a world of web-based software. After all, the innovator’s dilemma tells us that cheap and convenient technologies may begin with limitations (like Google Docs), but they can grow to replace the established powers (Microsoft Office).
Microsoft made more significant changes to its developer tools. They continued creating free alternatives, releasing a SQL Server Express that had the same engine as its grown-up sibling, but an arbitrary cap on database size and number of CPUs. They released a free Visual Studio Community edition with identical capabilities to the licensed version, minus the ability to let large teams manage their projects through Team Foundation Server. But these steps weren’t enough, because the appeal of open source wasn’t just the price. It was the philosophy: community-based collaboration, broad operating system compatibility, and source code that doesn’t hide secrets.
Microsoft could lower its prices, but it couldn’t turn established closed-source software into genuine open source projects — or could it?
Visual Studio Code became one of Microsoft’s most successful developer products. Stack Overflow’s yearly surveys show how quickly the change happened. In 2016, the classic version of Visual Studio held on to solid popularity (preferred by 35.6% of developers), while VS Code grabbed a much smaller share (7.2%). The next year, VS Code had jumped to 24%. By 2019, classic Visual Studio was still holding steady, but VS Code has surged into the top spot, becoming the preferred IDE of a staggering 50.7% of developers.
Many of the developers who use VS Code run it on non-Microsoft operating systems and program with non-Microsoft programming languages. But they remain at least partly in the Microsoft fold. What seemed crazy at first — offering developers two competing paths — has become the company’s most successful strategy, and a way to back down from of its clash with open source.
But VS Code may have just been a trial balloon before a much more dramatic shift — the reinvention of .NET, the company’s core development framework. In 2016, Microsoft released the first version of .NET Core, a version of .NET reimagined as a cross-platform open source project.
At first, .NET Core was also a competitor. It was a parallel track of .NET that would never be able to overtake the classic .NET Framework, because it lacked several features that were tied to the Windows operating system. But version by version, .NET Core shifted. Today, the next version of .NET Core— renamed to .NET 5 — is poised to replace the classic, single-platform .NET Framework when it releases in late 2020. (You can read more about Microsoft’s journey to .NET 5 here.)
With this transformation, the company that once seemed to be creeping toward irrelevancy is suddenly back on the forefront of modern development. And it pulled off this trick not by challenging the dominance of other open source software projects, but by challenging its old habits — and outcompeting itself. The classic world of Microsoft development was disrupted, as Christensen predicted. But the revolt came from within.
For a once-a-month email with our best tech stories, subscribe to the Young Coder newsletter.