When GitHub Goes Down: What Actually Breaks in a Dev Workflow (and What Doesn't)

Background

GitHub outages are common enough now to be a recognizable pattern, not a rare event — status-page incidents affecting Git operations, Pull Requests, Actions, or Copilot show up multiple times in a typical month, ranging from a few minutes of degraded performance to multi-hour outages for specific services. The pattern worth examining isn't the outage itself; it's which parts of a developer's actual workflow stop functioning versus which parts don't, because that split reveals exactly which tools were quietly dependent on GitHub's servers the whole time.

What happens during an outage

3 categories of breakage show up, in order of how often they're reported: git push/git pull failing or timing out when GitHub's Git backend is affected; Pull Request pages, reviews, and merge queues becoming unavailable when the web/API layer is affected; and Copilot suggestions failing silently or returning errors when its backend service is degraded independently of core Git operations — the 3 layers don't always go down together, which is why some outages block pushes while Issues stay browsable, and others take out Copilot while Git itself is untouched.

Root cause: 1 remote dependency, many workflow steps

The actual root cause across almost every one of these incidents is the same shape: a workflow step that looks local (editing a snippet, comparing 2 versions of a file, formatting a config) is quietly routed through a remote call — GitHub's API for a Gist, a Copilot completion request, a PR diff view rendered server-side. None of those steps need to be remote; they're remote because that's where the product built the feature, not because the underlying operation (storing text, diffing 2 strings, formatting JSON) requires a server at all.

Fix: separate what needs GitHub from what doesn't

1. Snippet storage that isn't a Gist dependency. A Gist is convenient, but it's also a 3rd request in your workflow that can fail independently of Git itself. SolveBar's Code Snippet Manager saves everything to localStorage under 1 key, with 22 supported languages and client-side syntax highlighting via highlight.js — 0 requests to any Git host, so a GitHub outage has nothing to break here.
2. Diffing 2 versions of a file without a PR view. Comparing a local file against a remote branch by opening a GitHub PR diff page depends on GitHub's web layer being up. SolveBar's Diff Checker runs a real LCS-based line-diff algorithm entirely client-side — paste 2 versions, see the added/removed lines instantly, independent of any Git host's availability. It saves your last 5 comparisons to local storage too, so a repeat check doesn't need a repeat paste.
3. Config/JSON validation that doesn't route through a GitHub Action. If your workflow leans on a CI job just to check that a config file parses, that's a 4th dependency on GitHub's infrastructure for something JSON.parse() does instantly in a browser tab, with 0 wait for a runner to spin up.

Lessons learned

• An outage doesn't just block the feature that broke — it blocks every workflow step someone quietly built on top of that feature without noticing the dependency.
• 3 GitHub subsystems (Git backend, web/API layer, Copilot) can fail independently — a single "GitHub is down" headline can mean very different things for your specific workflow depending on which layer is actually affected.
• The fastest recovery from an outage isn't a status page refresh — it's not having routed a local-only operation (diffing text, formatting JSON, storing a snippet) through a remote service in the first place.
• Tools that could run 100% client-side but choose to hit a server anyway inherit that server's uptime as a hidden dependency of your own workflow.