---
title: "Microsoft 365 Outage: Why Every Reboot Failed"
description: "Microsoft 365 went down for 1.5 days with no extra traffic. How health checks, TLS handshakes and reconnecting clients kept knocking servers over."
canonical: "https://aayushbharti.in/blog/microsoft-365-outage-system-design-lessons"
---

# Microsoft 365 Outage: Why Every Reboot Failed

> Microsoft 365 went down for 1.5 days with no extra traffic. How health checks, TLS handshakes and reconnecting clients kept knocking servers over.

- Author: Aayush Bharti
- Published: 2026-11-15
- Reading time: 7 min
- Tags: system-design, reliability, incidents, cloud
- URL: https://aayushbharti.in/blog/microsoft-365-outage-system-design-lessons

**TL;DR:** On November 12, 2026, Microsoft 365 went down in 70+ countries with no rise in traffic. Servers failed health checks and were removed, and the remaining servers were overwhelmed by expensive secure-connection setup. Rebooted servers looked healthy, then failed again as clients reconnected all at once. Microsoft recovered by changing how health was checked, reintroducing traffic gradually, and rolling back a network change that lined up with the start of the outage.

---
On November 12, 2026, Outlook, Teams and Copilot stopped working in offices across more than 70 countries, for about a day and a half. The [NHS cancelled some operations and Singapore's courts ran into trouble](https://en.wikipedia.org/wiki/2026_Microsoft_outage), because their calendars and mail ran on it too.

The strangest part showed up in Microsoft's own updates. Engineers restarted servers, and the servers came back healthy. Then, as Microsoft put it, they ["can become unresponsive again once they begin receiving traffic."](https://www.theregister.com/saas/2026/11/12/microsoft-struggling-to-fix-massive-cloud-outage-thats-taken-down-email-and-intune/5309531) **Reboot, green, dead.** Over and over.

And it wasn't a traffic spike. Microsoft said the load ["isn't driven by an increase in traffic, but by a number of servers being unexpectedly unavailable."](https://www.cnbc.com/2026/11/12/microsoft-outage-outlook-aws-google.html) It wasn't an attack either: Microsoft found [no evidence of malicious activity](https://www.epifive.com/blog/microsoft-365-outage-november-2026-root-cause-it-admin-lessons). So what knocks servers over when nothing outside has changed?

> **Before the official report**
>
> Microsoft hasn't published its Post-Incident Report yet. The facts come from its status updates during the incident; how the pieces fit together is my reading. I'll update this post when the report is out.

## Healthy servers get kicked out

Every big service sits behind a load balancer, and load balancers follow a simple rule: ask each server "are you OK?" every few seconds, and stop sending it traffic if it misses a few answers in a row.

```ts title="load-balancer.ts"
if ((await healthProbe(server)) === TIMEOUT) {
  pool.remove(server);
}
```

On November 12, servers started to ["fail automated health checks and become unavailable."](https://www.theregister.com/saas/2026/11/12/microsoft-struggling-to-fix-massive-cloud-outage-thats-taken-down-email-and-intune/5309531) Microsoft's early read was that the failures ["may originate from a specific component that's responsible for processing server health"](https://www.theregister.com/saas/2026/11/12/microsoft-struggling-to-fix-massive-cloud-outage-thats-taken-down-email-and-intune/5309531), and the start lined up with a recent network configuration change. Microsoft later said the disruption stemmed from ["an issue during an earlier network capacity upgrade."](https://www.cnbc.com/2026/11/12/microsoft-outage-outlook-aws-google.html)

In other words, **servers that may have been fine were being marked as broken**, and the rule pulled them out.

```mermaid caption="A server that misses its health probe is removed from the pool"
flowchart LR
  U["Same users,<br/>same traffic"]:::blue --> LB["Load balancer"]:::violet
  LB --> S1["Server 1<br/>answered probe"]:::green
  LB --> S2["Server 2<br/>answered probe"]:::green
  LB -. "no traffic" .-x S3["Server 3<br/>missed probe: removed"]:::rose
  LB -. "no traffic" .-x S4["Server 4<br/>missed probe: removed"]:::rose
```

The users of the removed servers don't disappear. **Their traffic lands on whoever is left.**

## The servers left behind drown

Microsoft named the thing that buckled: ["a process on the affected servers responsible for establishing secure connections."](https://www.epifive.com/blog/microsoft-365-outage-november-2026-root-cause-it-admin-lessons) Microsoft didn't say "TLS", but that's what setting up a secure connection means on the web: the **TLS handshake** every laptop and phone does before it can talk to a server.

**A new connection is far more expensive than an open one.** The handshake uses public-key cryptography to agree on keys, and that maths is heavy on the CPU. Once the connection is open, everything after it uses fast symmetric encryption. An open connection is cheap work for a server; every new one is a heavy lift.

```mermaid caption="Same request, very different cost: an open connection versus a brand-new one"
flowchart LR
  subgraph open["Existing connection"]
    direction TB
    O1["Session<br/>already open"]:::green --> O2["Symmetric encryption<br/>(AES)"]:::green
    O2 --> O3["Light CPU work,<br/>fast replies"]:::green
  end
  subgraph fresh["New TLS handshake"]
    direction TB
    N1["Client starts<br/>from zero"]:::rose --> N2["Public-key crypto:<br/>certificate, key exchange"]:::rose
    N2 --> N3["Heavy CPU work,<br/>queue backs up"]:::rose
  end
  open ~~~ fresh
```

Now the survivors are getting traffic meant for several servers, much of it new connections from users whose server just vanished. Microsoft's words: ["a core process on the affected servers is becoming overwhelmed, which causes the servers to stop responding."](https://www.theregister.com/saas/2026/11/12/microsoft-struggling-to-fix-massive-cloud-outage-thats-taken-down-email-and-intune/5309531) They miss their own health probes, and the rule removes them too. That's a **cascading failure**: a death spiral where every turn removes more servers.

```mermaid caption="A cascading failure: every turn of the loop removes more servers"
flowchart LR
  T["Network change"]:::blue -. "starts it" .-> D
  A["Fewer servers"]:::rose --> B["More connections<br/>per server"]:::amber
  B --> C["Handshakes max<br/>out the CPU"]:::amber
  C --> D["Probes time out"]:::amber
  D --> A
```

## Why every reboot failed

A freshly rebooted server has zero open connections. That's why it looks perfect with no traffic: it has nothing to do.

Then the gates open. Outlook, Teams and every app built on Microsoft 365 have been failing for hours, and they keep retrying until a server answers. Each retry needs a brand-new handshake, because a rebooted server has no connections to reuse. So a fresh server's first job is almost entirely the most expensive kind of work, arriving in one burst.

This is a **thundering herd retry storm**: every client stampeding toward the first server that looks alive. It's like being hit by **a DDoS attack from your own users**, except nobody is attacking. It's just ordinary apps doing exactly what they were built to do, all at the same moment.

```mermaid wide caption="A rebooted server looks healthy until every client reconnects at once"
sequenceDiagram
  participant LB as Load balancer
  participant S as Rebooted server
  participant O as Outlook
  participant T as Teams
  participant P as Phones
  Note over LB,P: 1. The server reboots with zero connections and nothing to do
  LB->>S: Are you OK?
  S-->>LB: Yes
  Note over LB,P: 2. It's back in the pool, and every waiting app retries at once
  O->>S: New handshake
  T->>S: New handshake
  P->>S: New handshake
  activate S
  Note over S: CPU maxed out
  Note over LB,P: 3. Too busy doing handshakes to answer anyone
  S--xO: Timeout
  S--xT: Timeout
  LB->>S: Are you OK?
  S--xLB: No answer
  deactivate S
  Note over LB,P: 4. It's removed again, the apps keep retrying, and the loop starts over
```

## How Microsoft broke the loop

Restarting alone couldn't fix it, because restarts were part of the loop. Going by Microsoft's updates, three things did, in roughly this order:

```mermaid wide caption="How recovery unfolded, in UTC, from Microsoft's status updates"
timeline
  section Nov 12
    16#58;17 : Exchange Online incident opens : Servers fail health checks
    ~22#58;00 : New health check brings some servers back
  section Nov 13
    00#58;35 : Restored servers fail again under traffic
    01#58;06 : Network change rollback begins
    07#58;25 : Servers start to stabilise
  section Nov 14
    Final update : Last customers restored
```

1. **Stop kicking out servers that can work.** On the evening of November 12, Microsoft ["validated an alternative service health check method"](https://www.theregister.com/saas/2026/11/12/microsoft-struggling-to-fix-massive-cloud-outage-thats-taken-down-email-and-intune/5309531), which brought some servers back into rotation.
2. **Open the gates slowly.** Engineers began ["isolating a portion of infrastructure, restarting affected components, and reintroducing traffic"](https://www.theregister.com/saas/2026/11/12/microsoft-struggling-to-fix-massive-cloud-outage-thats-taken-down-email-and-intune/5309531), so the reconnect storm hit a few servers at a time instead of all of them.
3. **Roll back the trigger.** At 01:06 UTC on November 13, Microsoft began reverting ["a recent network configuration change that correlates with the start of impact,"](https://www.epifive.com/blog/microsoft-365-outage-november-2026-root-cause-it-admin-lessons) and later patched an upstream configuration component.

Servers started to stabilise on the morning of November 13, and the last customers were restored on November 14. The first two steps bought time. **Only fixing the trigger ended it.**

## What to take from it

Microsoft described the changes it was weighing as ["the small number of recent configuration updates we identified."](https://www.theregister.com/saas/2026/11/12/microsoft-struggling-to-fix-massive-cloud-outage-thats-taken-down-email-and-intune/5309531) The rules around them turned a small change into a global outage, and every system has its own version of those rules:

- **A health check shouldn't be able to empty the pool.** Cap how many servers it can remove at once. A slow server serves more users than a missing one.
- **Busy is not dead.** "Is the process alive?" and "is it overloaded?" are different questions with different answers: replace a dead server, shed load on a busy one.
- **Overload should slow you down, not knock you over.** Cap how many new connections a server accepts at once and turn the rest away quickly, so it keeps serving the users it already has.
- **Plan the way back.** After an outage, everyone reconnects at once. Clients need exponential backoff with jitter (random delays, so they don't all retry in sync), and recovery needs a ramp, not a switch.
- **Config changes are deploys.** Roll them out region by region, with an automatic stop when errors climb.

## Frequently asked questions

### What caused the Microsoft 365 outage in November 2026?

Microsoft hasn't published its final root cause yet. Its status updates say servers failed automated health checks and became unavailable, the remaining servers were overloaded, and a process that establishes secure connections became overwhelmed. Microsoft rolled back a recent network configuration change that correlated with the start of impact, and later attributed the incident to an issue during an earlier network capacity upgrade.

### Was the Microsoft 365 outage a cyberattack?

No. Microsoft said it found no evidence of malicious activity, and posted that the incident was not related to cyber or AI agents.

### How long did the Microsoft 365 outage last?

About a day and a half. Exchange Online problems started at 16:17 UTC on November 12, 2026, and Microsoft said service was restored for the remaining customers on November 14.

### Why did rebooted Microsoft 365 servers keep failing?

Microsoft said restored servers stayed healthy until they began receiving traffic, then became unresponsive again. A freshly rebooted server has no open connections, so every client has to set up a new secure connection with it, which costs far more CPU than serving an open one. With clients reconnecting all at once, the server was overwhelmed before it could settle.
