Outages

When GitHub Actions and Webhooks Stop: The Cost of CI/CD Outages

GitHub Actions and Webhooks suffered a critical incident on October 19. Engineering leaders must plan for the cost of blocked deployments and lost webhooks.

Published October 22, 2026 6 min read By the Breakwatch team 1 source

On October 19, 2026, GitHub reported a critical incident affecting GitHub Actions, GitHub Pages, and Webhooks. Starting at 15:49 UTC, users experienced degraded availability across these core services. The disruption caused tangible delays in workflow processing, site builds, and webhook delivery. By 16:30 UTC, GitHub noted recovery following mitigation, though they stated, "Customers may still experience delays," specifically regarding Actions workflow status updates, Pages deployments, and check and workflow webhook events generated by Actions runs. The incident was officially resolved at 16:56 UTC, lasting exactly one hour and seven minutes.

According to the Status Page, this duration matches the typical GitHub incident. It was the thirty-third longest of sixty-five resolved incidents recorded over the preceding ninety days.

For engineering leaders, a one-hour pause in continuous integration and deployment is more than a brief inconvenience. It is a forced halt on shipping value. When the platform that builds, tests, and deploys your code degrades, the entire engineering organization feels the impact immediately.

The Financial Impact of Paused Pipelines

Modern software development relies heavily on hosted continuous integration. Teams configure GitHub Actions to run unit tests, lint code, build container images, and push releases to production environments. When GitHub Actions experiences degraded performance, that automated pipeline stops entirely.

A disruption lasting one hour and seven minutes during a busy workday carries a high financial cost. Consider an engineering department of fifty developers. If half of them are actively waiting on pull request checks to pass so they can merge their work, that represents dozens of hours of lost productivity. Engineers lose their flow state. They are forced to context switch to other tasks, which degrades focus and extends the time it takes to return to the original problem once the incident resolves.

Founders and engineering managers must account for this reality in their roadmaps and budgets. Hosted platforms provide immense value by removing the need to maintain internal build servers and infrastructure. However, that convenience trades total control for a hard dependency on a third party. When the vendor experiences an incident, your team cannot ship critical bug fixes or planned feature releases. The engineering roadmap must include buffer time for these inevitable platform degradations, as assuming one hundred percent uptime will lead to missed internal deadlines.

The Webhook Delivery Gap and Split-Brain Systems

While delayed site builds are visible immediately to developers waiting on a deployment, delayed webhooks create silent failures across your broader infrastructure. Webhooks are the connective tissue between third-party platforms and your internal systems.

During the October 19 incident, GitHub specifically noted delays in webhook delivery, including check and workflow webhook events generated by Actions runs. Many engineering teams rely on these specific webhooks to trigger downstream automated processes. An internal deployment dashboard might wait for a successful Actions run webhook to update its status to green. A ticketing system might wait for a pull request webhook to automatically move a ticket to the testing column.

When webhooks are delayed, these integrated systems fall out of sync. If a webhook is dropped entirely due to degraded availability, the downstream system might wait forever. This creates a split-brain scenario where GitHub knows a build finished successfully, but your internal tools think it is still running. Engineering teams then waste time manually verifying statuses across different dashboards, eroding trust in the internal tooling that was built to save them time.

The Reality of Vendor Incident Frequency

The October 19 event was not an isolated anomaly. The data shows sixty-five GitHub incidents recorded in the last ninety days. Other recent events included delays for pull requests and webhook deliveries on October 21, and delayed Actions workflow run logs on October 14.

For a Chief Technology Officer, this frequency requires a shift in perspective regarding error budgets. If a core dependency experiences an incident roughly every few days, your own system architecture must absorb that friction without passing the failure on to your end users.

When evaluating vendor reliability, leaders must look beyond the marketing pages and examine the historical status data. A typical incident lasting one hour and seven minutes means your team needs a predefined protocol for how to handle an hour of downtime. Do engineers switch to writing documentation? Do they review local code? Having a clear operational plan for vendor downtime prevents an hour of degraded availability from turning into an hour of total unproductivity.

Designing for Asynchronous Reliability

Engineering teams must design their systems to handle delayed or missing webhooks natively. You cannot assume a webhook will arrive immediately, or that it will arrive only once.

First, ensure every webhook handler in your system is strictly idempotent. When the incident resolved at 16:56 UTC, systems likely received a sudden influx of queued webhooks that had been delayed. If your handler processes the same event twice, it must not create duplicate database records or trigger duplicate downstream actions.

Second, implement a fallback polling mechanism for critical workflows. If your deployment pipeline requires a webhook to proceed to the next stage, set a timeout. If the webhook does not arrive within a reasonable window, the system should query the vendor API directly to check the status.

Third, monitor your own webhook receiving endpoints. If you stop receiving events during a time when you expect high activity, your internal monitoring should alert the team to investigate the upstream vendor status immediately, rather than waiting for user complaints.

Auditing Your CI/CD Dependencies

Engineering leaders should regularly audit how deeply their deployment processes are tied to a single vendor. The goal is not to move away from hosted services, but to understand the exact blast radius of an incident.

Ask your team what happens if GitHub Actions or GitHub Pages goes down for four hours during a critical security patch release. Can the team build and deploy the application locally? If the deployment scripts are entirely embedded in vendor-specific configuration files, you have a hard dependency that cannot be easily bypassed.

Consider abstracting the core build and deployment logic into scripts that can run anywhere. Use a standardized build tool, a shell script, or a containerized build process. The vendor configuration should only be responsible for executing those agnostic scripts. This abstraction allows an engineer to run the exact same build process from their local machine if the hosted platform is unavailable.

Review your internal documentation. When an incident occurs, engineers should not waste time debugging their own code. Clear runbooks should exist that outline how to check vendor status pages and how to execute emergency manual deployments if the primary pipeline is degraded.

The October 19 incident is a clear reminder that third-party dependencies dictate your ability to ship software. A one-hour and seven-minute delay in workflow processing and webhook delivery forces teams to pause and wait. By understanding these failure modes, engineering leaders can build resilient processes that handle vendor degradations gracefully.

Breakwatch maps which files in your repos call each vendor API, watches those vendors' changelogs, docs and API specs, and alerts you when a change affects your code.

Next step

See every third-party API your services depend on

Breakwatch maps the vendor APIs across your repos and tells your team when a breaking change or deprecation lands in one of them, with the files it affects and a migration hint.

See which files in your repo call each vendor API, free for 1 repo

Get API changes by email

Once a week: the breaking changes and upcoming deadlines, each linked to the vendor's own page. Free, no account. One-click unsubscribe.

Sources

Every fact above links to one of these. The date beside each is the page's own.

  1. Status Page, aitoolstatustracker.com, October 19, 2026

More from the blog

Articles describe vendors' APIs, status pages and changelogs as their sources showed them on the dates listed. Those change; check the sources before you rely on them. Names of other companies and their products belong to them; Breakwatch is not affiliated with them.