Intel vs Amazon vs Microsoft: three ways to ship software

· career, engineering-culture, lessons

In about 15 years I’ve shipped software at three very different companies: internal applications at Intel, Seller Platform Support (SPS) and then AWS Marketplace at Amazon, and the Microsoft Edge address bar before my current work on AI experiences in Microsoft AI (MSN, Bing, Copilot).

Every one of those teams shipped working software. They just disagreed, sometimes completely, about how. This post compares four things that shaped my day-to-day the most: design reviews, testing, releasing, and on-call.

A caveat before I start: these are the teams I was on, at the time I was on them. Big companies contain multitudes, and someone on a different team at the same company could tell you the opposite story. This post leans on my earlier years; I’ll update it, or write a follow-up, with what I’ve learned more recently in AWS Marketplace and in Microsoft AI.

Design reviews: slides, documents, and code

Intel was where I learned that design is a team activity. As lead developer on an agile team building internal workforce management apps, design happened in planning sessions and at the whiteboard, close to the business people who’d use the tool. Lightweight, fast, and very dependent on who was in the room.

That last part is the catch. Once, two teams planned separate jobs that ran updates against the same HR table at the same time, and nobody in either planning session knew about the other. The jobs collided in a deadlock, and when the dust settled almost every Intel employee was marked as terminated in the HR systems. Nobody had written the change down where the other team would see it, so nobody had asked the obvious question: who else touches this table?

Deadlocks themselves are a well-understood database problem: the engine picks a “victim” transaction and rolls it back so the others can finish (Microsoft’s deadlock guide explains it well). The real failure was in planning, not in SQL. Informal design works until two groups of people make decisions about the same data without seeing each other’s plans.

Amazon is famous for writing things down, and it deserves the reputation. Big decisions start as a written narrative instead of a slide deck: the problem, the options, the trade-offs, and what you recommend. Meetings often begin with everyone reading the document in silence, then the discussion starts. The first time, it felt slow. After a few, I realized the document was the design work. You can’t hide a fuzzy idea in prose the way you can in bullet points.

Microsoft Edge sat on top of Chromium, so a lot of design happened in code review. Changes went through reviewers and owners of each part of the codebase, and a small, well-explained change list often carried more weight than a big doc. For larger features we wrote design docs too, but the culture leaned on prototypes. I prototyped a few browser features as extensions first, just to show they were feasible before anyone committed real time.

What I’d keep: Amazon’s habit of writing the decision down, with Edge’s habit of proving it with a prototype. A one-page doc shared across teams would have saved Intel’s HR table.

Testing: coverage, automation, and real users

At Intel testing was a discipline I practiced daily. We did test-driven development across Angular (Karma and Jasmine) and .NET, pushed code coverage toward 90%, and ran SonarQube on every build. It made me a better engineer early, because writing the test first forces you to decide what “working” means.

At Amazon the emphasis shifted from coverage numbers to safety in production. Unit tests were expected, but the bigger investment went into integration tests, canaries that call your service constantly, and alarms that fire before customers notice. When your service is one of hundreds talking to each other, the question isn’t just “does my code work?” but “what happens when the service I depend on doesn’t?”

At Microsoft Edge the scale changed the problem again. A browser runs on hundreds of millions of machines with every combination of OS, extension, and network you can imagine. Automated tests and the commit queue caught a lot, but the real safety net was shipping behind feature flags and watching the data. I built monitors and dashboards to track feature impressions, engagement, and live-site health, because a test suite can’t tell you how a feature behaves on a machine you’ve never seen.

What I’d keep: Intel’s test-first habit for logic, and Edge’s habit of treating telemetry as part of testing.

Releasing: environments, pipelines, and channels

Intel: we automated delivery across roughly seven environments, from dev to production, with Git, TeamCity, and PowerShell. Releases were planned events. Predictable, but a fix could take days to reach users.

Amazon: deployments were continuous and automated through pipelines that moved a change through stages, one region at a time, with automatic rollback when alarms fired. Shipping several times a day was normal, and the pipeline, not a person, decided whether a change was safe to keep going.

Edge: releases follow channels. A change lands in Canary first, then Dev, Beta, and finally Stable, with feature flags controlling who actually sees new behavior. You could merge code weeks before turning it on for anyone, which separates deploying from releasing more cleanly than anywhere else I’ve worked.

What I’d keep: Amazon’s automatic rollback and Edge’s separation of deploy from release.

On-call: who gets paged

This is where the three differed the most.

At Intel, support was tiered, the classic L1/L2/L3 model. L1 agents handled the first contact and the quick fixes: clearing a cache, a cookie problem, the things a checklist can solve. When a problem needed more, like a database update or re-running a job, L2 stepped in. L3 was my job: developers got involved only when the first two levels couldn’t fix the user’s problem. Each developer took a one-week rotation, and part of it was presenting at the Monday ops meeting, where we reported the week’s incidents and the improvements we’d made. Pretty standard, and it worked: by the time an issue reached me, it was usually a real bug, not a confused user.

At Amazon, there were no tiers between me and the problem. Werner Vogels summed up the philosophy back in 2006: “You build it, you run it.” My team owned our services end to end, which meant a rotating on-call shift where on-call was the job that week. Feature work waited.

AWS Marketplace is where that ownership taught me the most. I learned to deliver code at a much bigger scale and to troubleshoot problems that only show up there: distributed database issues in Redshift, or Java applications running in parallel to produce thousands of records at once until they ran out of memory. And I did it with a tougher, more critical crowd behind me, because when your customers are businesses selling on AWS, every minute of an incident is someone else’s revenue.

After a serious issue we wrote a correction of error (COE) document: what happened, why, and what we’d change so it couldn’t happen again. It’s the same idea as Google’s blameless postmortems, and it’s the most effective learning ritual I’ve seen, because it fixes the system instead of blaming the person. I still write incidents up that way, even for this site: see My site got scanned five days after launch.

At Microsoft, on-call looks familiar on paper: shared across the team, one-week rotations, with a primary and a secondary, a setup the Google SRE book describes too. The difference is ownership. Feature teams own parts of the code, not the entire infrastructure or platform. That makes support feel a bit more fragmented, since an incident can cross several teams’ boundaries, but it also means on-call doesn’t consume your whole week. You share the responsibility with your feature work instead of putting everything else on hold.

Neither is better. At Amazon, owning everything meant on-call took all of your effort, and you knew your service inside out because of it. At Microsoft, you can keep shipping during your rotation, and you lean more on other teams when something breaks. Different cultures, different trade-offs.

What I’d keep: Intel’s tiers so developers see real bugs, Amazon’s ownership and COEs, and Microsoft’s balance that lets on-call and feature work coexist.

The short version

Intel Amazon Microsoft Edge
Design Whiteboard and planning Written narratives Code review and prototypes
Testing TDD, high coverage Integration tests, canaries, alarms Automation plus telemetry and flags
Releasing Planned, multi-environment Continuous, staged, auto-rollback Channels and feature flags
On-call Weekly rotation, L3 behind L1/L2 support You build it, you run it; on-call is the whole job Primary/secondary rotation, shared with feature work

None of these is “the right way.” Intel taught me discipline, Amazon taught me ownership, and Microsoft taught me to ship at a scale where data matters more than opinions. The best team I can imagine would borrow a piece from each.

If you’ve worked at any of these companies and your experience was different, I’d love to hear about it on LinkedIn.

← All posts