Microsoft Pulse was the internal tool engineering teams opened when something was actively breaking in production. Service degradation, SLA breaches, security events — Pulse was where on-call engineers went to monitor, diagnose, and fix it. And it was always used under pressure: SLA clocks running, stakeholders in the thread, systems partly down. When the tool was slow or confusing in that moment, it didn't just annoy people. It directly extended resolution time. That's why missed SLA targets here weren't a workflow complaint. They were an operational cost problem. And that's what made this project different from a typical UX engagement from the start.
Microsoft's engineering teams relied on Pulse during their most critical moments — live production incidents, system degradation, SLA-critical failures. Delayed resolution wasn't just a workflow inconvenience. It had real operational cost. Leadership flagged three business-level problems that weren't being addressed:
I ran four research methods side by side, each testing a different hunch from a different angle. I wasn't hunting for workflow annoyances. I was looking for the real reason a business number was going the wrong way.
Two artifacts did the work of convincing stakeholders: the journey map and the synthesized pain points diagram. The journey map showed the problem visually. The pain points numbered it. Together they turned "engineers feel friction" into a documented, evidenced structural failure.
One incident, five stages: what the on-call engineer went through, and what Pulse changed
Alert arrives without severity, logs or a health snapshot
Context-switching between the alert and the tools needed to verify it
Workspace reset every session: no saved views, no persistent filters
Filters organized by system module, not by account or datacenter
Three tools with three separate data contexts before diagnosis can start
Identical DGrep queries rebuilt from scratch every incident
Scripts executed in separate consoles; verification needs different views
Slide-in action panel avoided under pressure for fear of losing context
RCA done in Confluence with no direct link to session data
Next engineer starts with zero context from the prior stage
Engineers weren't slow at diagnosing. They were slow at getting to diagnosing. The 37% of time spent on actual problem-solving was being fragmented by a tool architecture that required constant context-switching. This number changed everything — including the conversation with stakeholders.
Measured via direct observational sessions — shadowing support and on-call engineers across live incidents, DM Sanstamping tool switches, query rebuilds, and navigation events vs. active diagnostic work. Not what people told us, what we watched.
The research gave us a diagnosis. The strategy decision was what to do with it — and that required making a case to three engineering teams and two leadership stakeholders for an approach none of them had asked for.
Unify the surface across Dashboard, DGrep, Health, Kusto, and Actions without touching the underlying architecture. Fastest to ship — 2 sprints. Reason cut: The 63% finding was an architectural problem, not a surface one. Rebranding five fragmented tools would have looked like progress while the actual cause of SLA breaches stayed intact. This direction would have shipped, measured nothing, and required a second engagement 18 months later.
Connect DGrep and Dashboard — the most-switched pair — with context persistence between them. Mid-cost build. Partial impact. Reason deferred: The lifecycle map showed tool-switching at every stage — not just between two tools. A two-tool fix would have covered roughly 30% of the friction, and told engineers we hadn't really understood how big the problem was.
Rebuild Pulse as a single surface where monitoring, querying, and action happen without tool-switching. Filter architecture rebuilt from card sort findings. Query memory built in. Context preserved across escalation handoffs. Longest build — full 12 months. Reason chosen: The only direction that addressed the root cause. The 63% finding gave us the business case. The card sort gave us the architecture. The nav speed study gave us the layout. Every big decision had data behind it, which made it easy to defend in front of stakeholders.
The answer was the 63% number. It wasn't my preference or a design opinion. It was what we watched happen: the way the platform was built was causing the delay. Once that was in the room, the conversation shifted from "should we do this" to "how do we sequence it."
How might we give on-call engineers a single investigation surface — so the 63% of time lost to tool-switching becomes zero, and the platform architecture stops being the source of every delay?”
Pulse was rebuilt from five disconnected tools into a single investigation platform — where monitoring, querying, and action happened in one surface, with context preserved across every stage of the incident lifecycle.
Once the root cause was named — fragmentation, not bad tooling — the product direction became clear. The goal wasn't to fix five tools. It was to eliminate the reason engineers needed five tools.
The card sort showed a basic mismatch: Pulse was organized around engineering system modules — the way developers structured their internal work. Engineers responding to incidents organized their world around environments and accounts.
DGrep Filters · Kusto Filters · Health Filters · Actions Panel
Scoping Conditions · Filtering Conditions · Namespace · Endpoint
Organization matched internal dev team structure — invisible to incident responders
Account (GenevaAccount0204) → Monitor → Dimensions
BackendDatacenter · requestType · Namespace as drill-down from environment
Time Range, Scoping, and Events were sub-filters of the account/monitor context — not top-level categories
The hardest part of this project wasn't the design. It was convincing three engineering teams — each with their own roadmap, their own tech debt, and their own opinion about what Pulse needed — to agree on a direction that required them to change things they hadn't planned to change.
How an incident moved through the unified Pulse, from alert to closed RCA
The wireflow above defines the structure; this traces one incident through it. Read left to right, then continue on the second row. Every loop stays inside one workspace: changing the time range, refining scope, re-checking a fix and escalating all return to the same view, with filters and time range intact.
12 months. 3 engineering teams. The delivery sequence was the product strategy made operational — if the IA was wrong, everything built on top of it would inherit the problem.
Custom dashboard builder — requested by senior engineers, deferred entirely. Build cost was 3 sprints. User research showed 8 of 10 engineers used the same 4 panels every incident. A configurability feature solving a preference problem was deprioritized against architectural work solving a business metric problem.
Slack integration for incident updates — deferred to post-launch phase. Would have required API work across 2 additional teams and introduced a dependency that could have blocked sprint 8. The escalation context feature already addressed the handoff problem within Pulse. Slack integration was nice to have, not need to have.
I defined MTTR reduction as the primary outcome metric at project kickoff — not post-hoc. Baseline was established from the same observational sessions that generated the 63% finding. Target was set at 25% reduction within 6 months of full rollout. Actual: ~30%.
Secondary metric: tool-switch frequency per incident session. Measured via session analytics added after launch. This was the leading indicator — if tool-switching dropped, MTTR would follow.
Two pre-ship validation rounds with L2/L3 support and on-call engineers — 60-minute sessions against real incident scenarios. Every round had documented outcome criteria. Every round changed something before the next sprint.
Every screen below mapped directly to a documented research finding. Nothing designed speculatively.
Event Viewer / Metric Timeline
Tool-switching dropped. Resolution time dropped. Engineers stopped rebuilding queries from scratch because the tool now remembered what they'd done before. The architectural fix the research demanded got shipped, and the business metrics that triggered the investigation reflected it. We measured this through internal incident telemetry and post-release observation sessions, comparing resolution DM Sans and tool-switch frequency across comparable incident categories before and after launch.