Incidents desk
Event date
Published
Last materially updated
No material update since publication
Primary source
GitHub, 12 Nov 2026
Reviewed by
Avinash Srinivasan, Founder and Lead Engineer
Incidents
GitHub Webhooks API
MG-03

GitHub Webhooks API Incident on 12 November 2026: What Failed and What Teams Should Check

The GitHub Webhooks incident is resolved, but teams that depend on webhook-triggered work should check for missed or delayed processing rather than assuming recovery completed every dependent action.

Affected: GitHub Webhooks API customer traffic experienced timeouts and errors, with about 1% of traffic affected according to the incident update.

What happened?

On 12 November 2026, GitHub reported degraded performance affecting Webhooks. The first incident notice was posted at 18:43 UTC. At 18:52 UTC, GitHub confirmed that the Webhooks API was experiencing timeouts and errors affecting about 1% of customer traffic.

At 19:20 UTC, GitHub reported that Webhooks API traffic had recovered. A monitoring update at the same time said the degradation had been mitigated. GitHub marked the incident resolved at 19:33 UTC.

The reported 1% figure describes the proportion of customer traffic affected. It does not identify which customers, repositories or individual operations experienced errors. The notice also does not establish whether every operation affected during the incident subsequently completed.

Our recommendation: Treat the resolved status as confirmation that GitHub ended the incident, not as evidence that every dependent workflow completed correctly. Check your own event processing records before closing an internal incident.

Which workflows?

GitHub identified Webhooks as the affected component. The incident report does not list individual repositories, event types or downstream integrations. It does not confirm that any particular deployment, build, security workflow or internal application failed.

For a startup using GitHub webhooks to initiate downstream work, the useful question is whether an expected action actually happened. Examples worth checking include automated deployment requests, internal notifications, repository event synchronisation and custom security automation. These are possible dependencies to investigate, not confirmed impacts from GitHub's report.

Our recommendation: Start with workflows where a GitHub event is the only signal that initiates an important action. Identify the event, the receiving system and the expected result. Compare what should have happened with what your systems recorded.

Our recommendation: Review receiving endpoint logs, processing records and downstream job results around the published incident times. Look for expected actions without corresponding completed work. Separate events that were processed successfully from those that need investigation.

Do not assume the reported 1% was distributed evenly across customers or workloads. The incident notice provides no customer-specific breakdown. An individual team's exposure must be established from its own records.

Cause per provider?

GitHub confirmed timeouts and errors affecting Webhooks API traffic. It later reported recovery, mitigation and resolution. The supplied status update does not explain the underlying technical cause.

At resolution, GitHub stated that a detailed root cause analysis would be shared when available. The incident report does not identify a faulty deployment, infrastructure component, capacity constraint or dependency failure.

Our recommendation: Record the cause as not yet disclosed in the incident report. Do not attribute this outage to a particular GitHub subsystem without supporting evidence. Keep the observed symptoms separate from any future root cause finding.

Our recommendation: Review the eventual root cause analysis before deciding whether changes are needed to your integration architecture. An incident's symptoms can inform immediate safeguards, even when its underlying cause remains unknown.

How to cut the impact of a repeat?

Our recommendation: First, inventory important workflows that rely on a GitHub webhook arriving and being processed. For each workflow, document the expected business or engineering action and identify where successful completion can be checked independently.

Our recommendation: Second, make webhook processing observable. Where you control the receiver, record incoming event identifiers, processing outcomes and failures. Alert when an expected operation does not finish, not only when an endpoint reports an error. A successful receiver response should not be your only evidence that downstream work completed.

Our recommendation: Third, establish a reconciliation path. For critical changes, compare the authoritative state in the relevant system with the state produced by webhook-driven automation. Investigate mismatches before attempting recovery. Do not assume that a timeout proves an operation never happened.

Our recommendation: Fourth, make recovery safe to repeat. Where you control the processing code, use stable identifiers and duplicate protection. Check whether an action already completed before running it again. This reduces the risk of applying the same operation twice during manual recovery.

Our recommendation: Fifth, define an incident closeout checklist. Confirm that important expected actions were processed, unresolved gaps have owners and recovery work has been verified. Preserve the relevant logs and incident timeline for later review.

Our recommendation: Finally, subscribe to GitHub status notifications through a supported channel. The status page offers email, SMS, Slack, webhook and feed-based notifications. Use these as an external incident signal alongside your own workflow monitoring.

The practical lesson is to verify outcomes independently. A provider can restore its service while a consuming team still needs to establish whether its own work completed. That distinction should guide both incident response and recovery design.

Sources

  1. Incident with Webhooks API (GitHub, 12 Nov 2026). Primary source.