Skip to content
PodSubs
ShowsPeopleGuestsJobsNewsEvents
More
BlogPodCred
Menu
ShowsPeopleGuestsJobsNewsEventsBlogPodCredNetworksSign in
Join nowSign in
  • Shows
  • People
  • Jobs
  • News
  • More
    • Guests
    • Events
    • Blog
    • PodCred
    • Networks
    Join nowSign in

Support Engineering Weekly

Support Engineering Weekly artwork

Microsoft Weekly — September 7–11, 2026

Sep 11, 202625 minAudio
ShareXLinkedInFacebookWhatsAppEmail

This week on Support Engineering Weekly, Alex and Maya examine a set of Microsoft 365 incidents and updates that reveal just how deeply connected modern cloud services really are. A shared access configuration created a cross-service blast radius, while telemetry failures produced misleading reporting and downstream service behavior that turned incomplete data into real operational impact. The discussion then moves into several targeted regressions across Outlook and Microsoft Teams, including unwanted Outlook add-ins, malformed shared-channel links, and failures affecting run-only workflows. The episode also looks at two very different forms of intentional disruption: an internal Microsoft resiliency drill that affected Copilot Chat suggestion pills, and TLS interception by network infrastructure that can make a customer-side security appliance look like a Microsoft cloud outage. The episode closes with two Message Center updates administrators should prepare for: more granular Microsoft 365 Copilot usage exports and the upcoming Rewrite with Copilot feature in Edge for Business. Together, these changes highlight a broader support-engineering lesson: authentication, telemetry, network controls, and data-governance policies can all determine how cloud services behave at the user interface. This episode is based on the Microsoft Message Center and Service Health updates for September 7-11, 2026, together with the supporting technical source material used for the episode. Chapters 00:00 - Hidden Microsoft 365 Dependencies 02:03 - When the Access Layer Fails 05:37 - Telemetry Failures and Bad Data 11:04 - Outlook and Teams Code Regressions 15:17 - Copilot Drills and TLS Interception 18:26 - Copilot Analytics and Edge Rewrite 22:25 - Three Key Support Engineering Lessons 23:43 - Resilience in AI-Driven Interfaces Learn more: The full technical source material, references, and supporting information are available through the Support Engineering Blog at https://blog.sadhan.ch.

Audio and video play straight from the show's own hosting. PodSubs stores and serves no media.

Transcript

From the show. Tap a time to play from there.

You are listening to Support Engineering Weekly. You know, there is this illusion we all sort of operate under when we're building these modern cloud environments. Oh, absolutely. The whole neatly separated boxes thing. Right. We like to think of these platforms as like series of isolated containers. You have your email box, your file storage box, your chat box. And the theory is, if the printing box breaks, well, you know, at least you can still send an email. Exactly. You look at the reality of modern architectural dependencies and that illusion just completely

shatters. It really does. You realize pretty quickly that a single core access configuration can take down everything. Yeah, everything from exchange to universal print to the UI of your AI assistant all at the exact same time. The blast radius is just not confined to a single app anymore. I'm Alex, by the way, and I'm Maya. Thank you so much for joining us on this deep dive. You are tuned in to support engineering weekly. And today our mission is to unpack a massive stack of Microsoft Message Center and service health updates.

Yes, specifically from the week of September 7 through the 11th, 2026. Right. And we're looking at a week defined by cascading failures across totally disparate services, automation going just entirely off the rails and the heavy impact of internal network intercepts. It's a heavy week. We are going to break down the actual routing failures, the missing telemetry, and most importantly, the exact workarounds you need to keep your tenant afloat. So let's just jump right in. What's the big theme here? Well, the overarching theme of this particular stack of updates is what happens when the

underlying invisible pipelines we take for granted suddenly glitch out. You're talking about things like authentication brokers and telemetry feeds, right? Exactly. When those backend components experience even a minor degradation, they manifest as these massive, highly confusing, front end outages for the end user. And they look like entirely unrelated problems, which is the worst part. So let's start by unpacking that massive cross service outage that span from August 31st to September 3rd. Yeah, this one perfectly illustrates that shattered illusion of separated boxes we were

just talking about. For sure. We're looking at incident reports, mo 1465-074 and ex 1464-935. To set the stage for you, imagine you are a user logging in on a Tuesday morning. Just a normal Tuesday, you go to download an exchange email attachment and the download fails. Right. So you try to search across your Microsoft 365 tenant failure. You look at teams and everyone's present status is completely stale. And then you try to ask co-pilot to summarize an email, a standard grounding prompt, and

that fails too. In desperation, you try to just print out a physical document and universal print jobs absolutely refuse to queue. I mean, listing those symptoms out all at once, it immediately sounds like a catastrophic systemic network failure. It sounds like the internet is broken. But the root cause was actually incredibly specific, wasn't it? Yeah, highly localized. It wasn't that the exchange databases were corrupted or that universal print servers were physically offline. The entire issue was traced back to a single core access configuration.

That config acts as a shared broker across multiple Microsoft 365 services. Think of it like a corporate building's master keycard server going down. The physical doors to the email room, the SharePoint room, the printing room, they're all perfectly fine. The rooms themselves are fully operational. Right. But because the centralized badge reader system is offline, nobody can authenticate to get through any of those doors. Suddenly, you are locked out of every seemingly unrelated service at once. And to the user, it just looks like the whole building has burned down.

Exactly. So why do we build it this way? Well, that is the architectural trade off of modern cloud identity and access management. Relying on centralized access brokers is fantastic for enforcing zero trust policies, conditional access and unified logging. Because you absolutely want one primary gatekeeper evaluating those signals. Right. But when that gatekeeper's configuration gets corrupted or it experiences a service degradation, the operational blast radius crosscuts entirely disparate services. Which is why we saw exchange web services failing, room fighters and outlook, just spinning

infinitely while spinning forever. I mean, Microsoft purview policy hits failing to evaluate basic one drive file opening actions, timing out all simultaneously. So as a support engineer on the floor, how do you even begin triaging that? It's tough. You have tickets flooding in about offline printers, broken calendars, missing chat statuses. The noise to signal ratio is just astronomical. My first instinct would normally be to check local network connectivity or look for a massive

ISP routing issue. But if you do that, you are burning hours chasing ghosts. Exactly. Pattern recognition is your only lifeline here. When completely unlinked services like teens presence and universal print fail simultaneously, you have to immediately stop troubleshooting the individual application layers. So you stop looking at the printer schooler, you stop looking at the team's local cash. Right. You have to look upstream to the common denominators. Yes. Authentication, authorization and core access brokers. So if your diagnostic telemetry shows that the requests are failing before they even

reach the app layer's compute environment. Or that token issue and says timing out. Yeah. You know you are dealing with an access config issue. And you route that escalation directly to your identity management team rather than the app owners. I've bought on. That upstream dependency problem is a perfect bridge to the next major crisis from this week's updates. We just talked about authentication pipelines failing, which stops users at the door. But when a data pipeline goes down, the system actually starts making bad decisions on its own.

Yes. Missing telemetry doesn't just mean you lose visibility on an admin dashboard. It actively triggers automated protective chaos. And we saw two distinct incidents that highlight this exact dynamic. The exchange external email delay, which is EX1467029. And the Microsoft 365 admin center usage report. Oh, the one showing zero active teams users, right? Yeah. Under MO1469836. That's the one. The mechanics behind both of these failures are deeply tied to how cloud platforms handle

missing information. Let's focus heavily on the exchange issue for a second because this is where automated security systems actively caused the outage. Yeah. So users were trying to send and receive emails from external domains, just standard daily business flow. Instead, they were getting slammed with four 514.7.5 hundred server busy errors. Emails are being aggressively throttled and deferred by the system. So exchange online uses a multitude of data sources, right?

It integrates heavily with Microsoft Defender for Office 365 to calculate dynamic sender reputation. It relies on an upstream distributed data platform to constantly feed it massive volumes of telemetry about IP behaviors across the globe. Exactly. But what happened here is that a recent internal change at Microsoft increased the size of read requests beyond intended physical thresholds. Oh, wow. So it overloaded that distributed data platform causing severe latency and drop connections. Right. The data platform is basically choking, meaning it can't serve up the full picture of center

reputation to the services that evaluate inbound and outbound mail. But here is the critical failure point in the architecture. One of the sender based reputation processing jobs continue to run anyway. It executed on schedule, but it ran with substantially less input data than it normally expects. Because the upstream platform was choking, it only received a fraction of the historical IP data. But the job still reported a successful completion. That's the crazy part. There was no completeness check in the pipeline to flag that the data set was statistically

insignificant. That is just wild. The system basically said, Hey, I finished processing the data without anyone asking, wait, did you process all of the data or just 5% of it? Right. And the downstream mail protection service then ingested this highly incomplete reputation data because it lacked the full historical context for these IP addresses. The algorithms just assumed the worst. Exactly. It assigned overly restrictive limits to legitimate, historically safe sending IPs. The volume based reputation control kicked in automatically.

And suddenly normal business email was being throttled with those server busy errors. The protection mechanism functioned exactly as it was programmed to do based on the data it received. The problem was the data itself was truncated. I really have to push back on the design of this automated system though. How so? Why does an anti-span system default to aggressively throttling legitimate business flow rather than failing open when its own internal data pipeline breaks? Ah, I see what you mean. It feels like the system is essentially saying, I'm confused because I don't have my data,

so I'm just going to shut down the business. It highlights a massive tension between strict security defaults and actual business continuity. It does, but it's the classic zero trust dilemma. In a modern security environment, systems are fundamentally designed to fail closed. If you can't definitively verify that an IP is safe based on current data, the architecture forces you to assume it's hostile. Right. If the system were to fail open because reputation data was missing, it could potentially allow a massive coordinated fishing or malware campaign to slip through the filters during that telemetry

blind spot. So Microsoft by design, prioritizes strict protection over availability in that micromole. I understand the theory I do. And from an operational standpoint, when that completeness check is missing from the data pipeline, the system's protection literally becomes a self-inflicted denial of service attack. Yeah. You are effectively de-dossing your own tenants' mail flow because a backend reporting job didn't validate its data set size. It is absolutely a self-inflicted wound. And we saw a parallel upstream telemetry issue with those team's usage reports.

Great admins were logging into the Microsoft 365 admin center and seeing zero active users, zero chat messages. And zero channel messages starting around late August. Seeing those zeros across the board probably gave a lot of compliance officers a heart attack. I can only imagine they probably assumed the entire logging infrastructure had been wiped. While that specific dashboard failure didn't block mail flow, it operated on the exact same underlying principle, didn't it? It did. An error occurred within the flow of service health telemetry data utilized by the reporting

service. The upstream pipeline broke. So the downstream dashboard just reported zeros instead of caching the last known good state or displaying an error banner. It's a stark reminder to engineers that data pipelines are just as mission critical as your authentication pipelines. It really emphasizes that backend architectural failures have bizarre front-end symptoms. But let's shift gears from massive data pipeline failures to something a bit more insidious. Oh, you mean the Kade regressions? Yes. Sometimes a tiny, well-intentioned code update causes an incredibly specific localized operational

headache. We tracked a trio of highly annoying regressions this week. Unwanted Outlook Add-ins, Malformed teams, shared channel links, and broken run-only teams workflows. These are the exact types of incidents that drive support teams absolutely crazy. At first glance, they look entirely like user error or corrupt local client caches. Let's examine EX1441448, the Outlook Add-in issue. Users suddenly saw administrative add-ins appearing and pinning themselves automatically across all their Outlook clients. And to be clear, these were add-ins that admins had deliberately configured an attendant to

be merely available for users to install if they chose to. Right. They were never flagged to be auto-installed or mandated. So it broke. The mechanism of failure here is deeply tied to the Exchange Online Add-in Sync Pipeline. A specific portion of that pipeline stopped processing the add-in state information correctly. Oh, so when the Outlook client checked in to sync its configuration, the pipeline started returning incorrect, enabled status values in the payload. Exactly. So the client asks for the status of the add-in and the broken pipeline effectively lies,

telling it, yes, this is fully enabled and mandated. I'm using the local client to auto-install it and clutter the ribbon. If I'm an engineer dealing with this right now, I don't want to wait for Microsoft to roll out a global patch to fix the sync state. Definitely not. And there is a specific operational workaround you can deploy immediately. You can use PowerShell to force a local tenant override bypassing that broken cloud sync state, right? Yes, you need to run. Set app-identity, then the application id. Dash organization app-private catalog dash default state for user disabled.

Command explicitly forces the disabled state down to the clients, stripping out the unintentionally deployed add-ins until the permanent backend fix is fully saturated. Having that specific PowerShell parameter string is vital for containing the help desk ticket search. Absolutely. And moving over to the team's regressions, we saw two more interface level bugs. Under TM1459181, users couldn't join shared channels using certain generated links. But the bug was incredibly specific to how the user interacted with the UI.

Yes. If they used the copy link option from the three dots menu at the top right of the channel, the link failed. But if they right-click the exact same channel in the left rail and copied the link there, it works perfectly. An update meant to optimize the data pathways for link generation actually caused the payloads generated from that specific top right UI element to be malformed. The routing parameters in the URL were essentially garbled. And similarly, in TM1440450, we saw a complex regression in how teams' processes shared

workflow requests. Users trying to execute run-only workflows, where they have permission to trigger the automation, but lack permissions to own or edit the underlying code, were suddenly being blocked with a missing trigger URI error. If a user is getting a missing trigger URI error, my first instinct as a support engineer is to assume the flow was deleted or the endpoint changed. Right. But because this is a back-end regression in how teams processes the authorization token for run-only contexts, we have to do something unorthodox to route around it.

The immediate practical action is to temporarily grant those affected users owner or co-owner permissions for that specific workflow. Elevating their privileges temporarily forces the workflow to execute under a different authorization context. Completely bypassing the broken run-only token validation logic that is currently failing. Obviously, you have to document that elevation and remember to revoke that access once the fix is fully deployed. But it will unblock your critical business processes today. It perfectly illustrates how modern support engineering often requires you to intentionally manipulate authorization contexts just to route around a code regression in a proprietary

platform you don't control. It's basically digital duct tape. So let's transition from unintentional code regressions to situations where the disruption was actually an intentional action. Right. We had issues this week where the outage wasn't a bug in a deployment, but rather someone intentionally intercepting or altering the traffic. Either Microsoft testing their own systems or an organization's own network infrastructure stepping on the packets. This distinction is crucial for rapid triaging under CW 1469885.

Users globally suddenly notice that the suggestion pills in Microsoft 365 co-pilot chat. Those little helpful contextual prompts that appear after a bot response to guide the conversation. Yeah, those just vanish. They were entirely stripped from the interface. Knowing how often these UIs are updated, you'd immediately assume a front-end deployment broke the CSS or the component rendering. Yeah, you would. But examining the service telemetry revealed that this was caused by an internal Microsoft drill. A drill. Yeah, the engineering teams were running a drill designed to test the resiliency of the

underlying AI service. So that drill likely involved failing over massive back-end components. And during that failover, the service dropped non-critical UI payloads like the suggestion pills to maintain core chat functionality. Exactly. Once they halted the drill, the payload was restored and the impact was remediated. And then on the flip side of intentional disruption, we have MO1468437. Users couldn't edit virtual invites in Microsoft Teams. The interface just wouldn't load, spinning endlessly, or throwing connection errors.

The alert Microsoft published for this was highly specific. It said user connections to Microsoft 365 domains are being TLS intercepted and decrypted by a network intermediary. It is absolutely maddening because TLS interception always disguises itself as a cloud outage to the end user. The user just sees a broken page in Blaine's Teams. As an engineer on the floor, how do you quickly prove that this is the corporate firewall breaking the connection? Rather than just another Microsoft regression, you don't want to waste hours on a support ticket. You have to look at the certificate chain and the network trace.

If this were a Microsoft cloud outage like the co-pilot drill we just discussed, you would see a clean 200 OK HTTP response. But the specific JSON payload for the UI elements would be missing. However, with TLS interception, your corporate proxy is actively decrypting the traffic, encrypting it, and then re-encrypting it with its own internal certificate. And modern client applications like Teams often use strict certificate penning or highly specific WebSocket connections. Right, so when the Teams client detects that the certificate chain has been altered by

the proxy, it forcefully drops the connection for security reasons. So if you pull a fiddler trace or check the browser's developer tools network tab, you won't see a missing payload. You will see SSL handshake failures or connection resets specifically on the Microsoft endpoints. And that proves the traffic isn't even securely reaching Microsoft's edge. It proves you can't assume every broken button is a cloud regression. Sometimes it's your own security appliance trying to be a little too helpful and breaking the encryption chain. It requires a completely different troubleshooting methodology.

You aren't checking service health bashboards, you are checking proxy bypass rules. That's a great point. Now that we've contained this week's active fires, we need to talk about the ones brewing for next month. Oh, the AI updates. Specifically, how upcoming AI feature updates are going to violently collide with your current data governance frameworks. We have two major message center updates to prepare for. MC11222978, detailing the new co-pilot dashboard day level exports. And MC1146821, introducing the edge for business rewrite feature.

The co-pilot dashboard update is a massive leap forward for organizations desperately trying to measure the actual return on investment for generative AI. Because previously analytics were limited in granularity, right? Making it really hard to see daily adoption trends. Exactly. Now, users with company level access can export 28 days of de-identified user data. This role level data is aggregated daily, allowing architects to tactically track adoption patterns and honestly optimize their heavy licensing costs.

But there are strict guardrails on pulling that level of data. Right. First, the tenant requires a minimum of 50 Microsoft 365 co-pilot licenses to even activate the feature. Second, and critical for your governance teams, access to this new day level export utilizes the exact same Viva feature access management or VFAM controls as the existing user week export. So if your compliance team has already restricted access to analytics using VFAM policies, those restrictions will automatically inherit and apply to this new day level data.

Right. You don't have to build a parallel governance structure. That automatic inheritance is such a relief. But the update that really requires immediate attention is the rewrite feature coming to edge for business. Powered by co-pilot chat, it lets users highlight text directly in the browser and ask the AI to rewrite it, adjust the tone or summarize it. It's rolling out between late September and late October. But there is a massive governance implication buried in the technical documentation. It revolves entirely around how AI interacts with data loss prevention or DLP integration.

The documentation explicitly states that if Microsoft 365 co-pilot is restricted from accessing page content due to existing DLP policies, the rewrite feature will simply not function on that content. Think of it like putting a genius assistant in a sensory deprivation tank. I love that analogy. If your DLP rules are configured to block browser scraping or data extraction on a specific internal site, an internet wiki or a sensitive web app, you are essentially blocking the AI's eyes and ears.

It cannot read the DOM so it cannot help you rewrite the text. This is a fundamental paradigm shift for security architects. We used to think of DLP purely as a mechanism to block file uploads or prevent copying text to a clipboard. Now DLP dictates the functional boundaries of generative AI. AI will only work as well as your data policies allow. If you have overly aggressive legacy DLP policies that blindly block all browser scraping on all internal domains, your users are going to flood the help desk complaining that the new edge rewrite feature is broken.

But it won't be broken. The application will be functioning exactly as governed by your security team, which means you need to act right now before this hits the production ring in late September. You need to audit your DLP configurations to understand exactly how they intersect with browser content access. You also need to verify your inline compose enabled policy setting, which manages the edge rewrite feature at the administrative level. You have to map out which internal domains are restricted. So you aren't caught off guard when users submit tickets claiming the AI refuses to

rewrite a paragraph on their highly classified internal project site. Modern DLP rules can no longer be broad brush network blocks. They must be highly context aware, carefully balancing stringent data security with the required functional inputs of generative AI tools. Bringing all of these threads together, there are three critical technical lessons you should take away from this week's deep dive. Number one, unified access architectures require you to prepare for wide blast radius cross service outages. When the master keycard server experiences degradation, everything from exchange web

services to universal print cues will fail simultaneously. You have to triage the identity layer, not the application layer. Number two, automated security systems are fundamentally designed to fail closed when their internal telemetry pipelines break. As we saw with the Exchange 451 server busy throttling, a broken upstream data pipeline can lead to massive false positive throttling downstream, effectively allowing a backend analytics glitch to block legitimate critical business traffic. And number three, copilot's new capabilities are heavily reliant on your organization's

existing governance frameworks. Either as VFAM policies controlling who can see the new 28 day analytics exports or legacy DLP policies dictating what the edge rewrite tool is physically allowed to read in the browser. Your AI deployment is entirely dependent on the precision of your data policies. Every single failure and feature we discussed today traces back to complex dependencies, whether they are architectural routing, data driven telemetry, or policy based access controls, which leaves us with a final thought to ponder as you look at your own tenant.

For routine internal backend resiliency drill can accidentally draw off the payload for front end UI components, like making copilot suggestion pills vanish into thin air. How resilient are these new AI interfaces to underlying network fluctuations compared to traditional static UI tools? We are entering an era where the interface itself is generated dynamically based on real time prompts, which means the UI you click on is just as fragile as the data pipeline running behind it. You have been listening to Support engineering weekly from the Support Engineering Blog.

For the full articles, references, and technical resources from today's discussion, visit the URL blog.sadhan.ch. Until next week, keep troubleshooting, keep learning, and keep engineering. Thank you for listening to Support Engineering Weekly. This podcast is available on Spotify, Apple podcast, YouTube, and other major podcast platforms. Follow the show on your preferred platform and never miss an episode.

Open the transcript file

Hosts and Guests

Nobody is credited on this episode yet.

Credit the people on this episode

Be the first to rate this episode

More episodes

All episodes
  1. Microsoft Weekly — November 16-20, 2026

    Nov 20, 202656 minAudio

    What happens when a routine network maintenance operation triggers a failure deep inside a cloud provider's authentication infrastructure? In this week's episode, Alex and Maya investigate how a seemingly isolated...

    Credit the people on this episode

  2. When Redundancy Fails: Inside Microsoft’s Network Stampede

    Nov 17, 202633 minAudio

    How can a routine network capacity upgrade trigger a global cloud outage - and why can the very systems designed to protect availability make the failure worse? In this Support Engineering Weekly bonus episode, Alex and...

    Credit the people on this episode

  3. From Microsoft Announcement to Completed Change

    Nov 15, 202623 minAudio

    Microsoft 365 administrators deal with information from several places: the Microsoft 365 Roadmap, Message Center, and Service Health. But knowing where to find an update is only part of the challenge. The real question...

    Credit the people on this episode

  4. Microsoft Weekly — November 09–13, 2026

    Nov 13, 202623 minAudio

    A server under pressure fails its health checks. Automated traffic management removes it from service, pushing even more load onto the remaining infrastructure. What was designed to protect the system becomes part of...

    Credit the people on this episode

  5. Planner Premium Isn't Project Online — So What Is the Gap?

    Nov 8, 202621 minAudio

    Microsoft Project Online is approaching retirement - or, in this case, its retirement date has already passed. But replacing a project management platform is not as simple as moving tasks from one product to another. In...

    Credit the people on this episode