
By Samuel Torres — Software & Cloud Engineer. 23+ production sites.
GTA 6 traffic travels over internet providers' networks and gaming platforms, not through your company's server. What can take your site down this November 19 is an external dependency that fails or slows down: a CDN, DNS, the payment gateway or an API. I run 23+ production WordPress sites on AlmaLinux + WHM/cPanel, and this guide is the review I recommend doing today: a dependency inventory, timeouts, fallback caching, DNS failover and external monitoring.
You won't find tips for players here. This is a technical review for whoever runs a company website that has nothing to do with video games, but shares the internet with millions of downloads on the same day.
Why GTA 6 traffic isn't your problem (but your dependencies are)
The launch numbers are real. According to Newsweek, Comcast said GTA 6 preloads were the largest single event in its network's history, and Spectrum reported that game download traffic rose 40 to 50 percent during the preload window. In the UK, Virgin Media O2 recorded its highest peak: between midnight and 1 a.m. traffic was 51.6 percent higher than the same hour a week earlier.
None of that goes through your hosting. The same experts Newsweek quotes say a general internet outage is unlikely; local failures or problems with specific services are more likely. Steve Uhlig, of Queen Mary University of London, names CDNs, gaming platform infrastructure, authentication systems and access networks as the likely pressure points.
That is the point: your site uses several of those shared services. Polygon pointed out this week that Microsoft's Outlook and Excel were down for almost 24 hours because a faulty gateway was overwhelmed by the amount of data, and it describes online services as fragile interconnected systems. There is no evidence those outages were attacks; one external piece failing is enough to make yours look broken.
The useful question for today is not "can my server take it?" but "what happens to my site if the CDN, DNS or payment gateway takes thirty seconds to answer?"
Map what your site depends on
You can't protect what you don't know you use. A typical company WordPress site loads Google Fonts, an analytics script, a chat widget, a CDN for images, a payment plugin that talks to the gateway API and, sometimes, a plugin that pulls exchange rates or inventory from another server. Each one is a point of failure you don't control.
The first step is an honest inventory. There are two sides: what the visitor's browser loads and what your server calls through PHP. The first shows up in the home page HTML; the second lives in your plugins and theme code. This script pulls both lists, sorted by how often each domain appears:
#!/bin/bash
# External dependency inventory for a WordPress site on cPanel
site="https://tusitio.mx/"
root="/home/usuario/public_html"
echo "== What the browser loads (home page) =="
curl -s --max-time 15 "$site" | grep -oE '(src|href)="https://[^"/]+' \
| sed -E 's/.*"https:\/\///' | sort | uniq -c | sort -rn
echo "== What PHP calls (active plugins and theme) =="
grep -rhoE "https://[a-z0-9.-]+\.[a-z]{2,}" "$root/wp-content/plugins" "$root/wp-content/themes" \
--include='*.php' | sed -E 's#https://##' | sort | uniq -c | sort -rn | head -25
⚠️ The script only reads files and sends GET requests, but run it first on a copy or on staging if you don't know the server well.
With that list in hand, sort each dependency into three groups. Critical: if it fails, the site can't sell or won't load (payment gateway, DNS, the CDN if it serves all the HTML). Degradable: if it fails, the site should keep working without it (chat, analytics, fonts, widgets). Hidden: calls PHP makes while building the page, which block the response while they wait; these are the most dangerous because nobody sees them until the site freezes.
Every critical dependency needs a written plan B. Every degradable one needs to load without blocking (async or defer on scripts). Every hidden one needs a short timeout and a fallback copy, which is what the next two sections cover.
Timeouts: so a slow third party can't take your site down
A dead service is easy to spot: it returns an error and that's it. The real problem is the slow service. If a plugin calls an API on every page build and that API takes thirty seconds to answer, every visit leaves a PHP process waiting. The account's PHP-FPM workers run out, new visits queue up and your site looks down even though your server is healthy.
The defense has two parts: measure how long each dependency takes today, and limit how long your code is willing to wait. To measure, this script takes URLs as arguments and reports the HTTP code, DNS lookup time and time to first byte, with a hard limit so it never hangs:
#!/bin/bash
# Usage: ./deps.sh https://fonts.googleapis.com https://api.mercadopago.com
# Reports HTTP code, DNS and TTFB; gives up after 5 s so it never hangs
for url in "$@"; do
out=$(curl -s -o /dev/null --connect-timeout 3 --max-time 5 \
-w '%{http_code} dns=%{time_namelookup}s ttfb=%{time_starttransfer}s' "$url")
status=$?
if [ "$status" -ne 0 ]; then echo "FAIL $url (curl exited with $status)"; continue; fi
echo "OK $url $out"
done
Feed it the domains from your inventory. If one takes more than a couple of seconds on a normal day, it will take longer on an unusual traffic day.
To cap the wait inside WordPress, the WordPress HTTP API accepts a timeout argument in wp_remote_get(). The default is five seconds, and many plugins raise it without thinking. If the plugin is yours, give every call a short timeout. If it belongs to someone else, the http_request_args filter lets you lower it for a specific domain without touching the plugin's code:
<?php
// mu-plugins/external-timeouts.php: no external API blocks for more than 3 s
add_filter('http_request_args', function (array $args, string $url): array {
$host = (string) wp_parse_url($url, PHP_URL_HOST);
$slow = ['api.mercadopago.com', 'api.stripe.com', 'api.openweathermap.org'];
if (in_array($host, $slow, true)) {
$args['timeout'] = 3;
$args['redirection'] = 2;
}
return $args;
}, 10, 2);
Adjust the $slow list with the domains from your inventory. A must-use plugin always loads and can't be switched off by mistake from the dashboard, which is why it suits this job.
⚠️ Before applying it in production: back up wp-content/mu-plugins and test the rollback (deleting the file restores everything). Test the full checkout on staging: a timeout that is too short on the gateway can cut off legitimate payments.
Fallback caching with stale-while-revalidate and stale-if-error
A timeout keeps the site from freezing, but the visitor still sees a gap where the data should be. The second layer is serving the last good copy when the source fails. There are two places to do it: in HTTP headers, so the CDN and browser can reuse copies, and in PHP, for the data your site pulls from APIs.
In headers, stale-while-revalidate allows serving an expired copy while the new one is fetched in the background, and stale-if-error allows serving the expired copy if the origin answers with an error, for example an HTTP 503 Service Unavailable. Mind the scope: these directives help when your origin, or something behind it, fails; if the CDN itself goes down, no header will save you and you need a way to point DNS straight at your server. On WordPress, apply them to static files only: HTML pages can carry sessions, carts or user data.
# .htaccess: fallback caching for static files only (not session HTML)
<IfModule mod_headers.c>
<FilesMatch "\.(css|js|woff2|webp|avif|jpg|jpeg|png|svg)$">
Header set Cache-Control "public, max-age=600, stale-while-revalidate=600, stale-if-error=86400"
</FilesMatch>
<FilesMatch "\.(php|html)$">
Header set Cache-Control "no-cache, private"
</FilesMatch>
</IfModule>
How to read those values: max-age=600 (600 seconds) is how long the copy counts as fresh; stale-while-revalidate=600 adds another 600 seconds during which the expired copy can be served while it revalidates; stale-if-error=86400 lets it keep being served for up to a full day if the origin errors. Tune the numbers to how often your files change. If your theme versions CSS and JS with ?ver=, you can raise max-age safely.
To check it, request the headers of a real static file on your site with curl -sI and look for cache-control in the response. If your CDN overwrites headers, the equivalent setting lives in its dashboard, not in .htaccess.
In PHP, the pattern is to keep the last good response from each API and use it when the call fails. This function returns fresh data if the API answers, the one-hour copy if it doesn't, and the last known good copy as a last resort:
<?php
// Calls an external API with a short timeout and falls back to the last good copy
function api_with_fallback(string $url, string $key): ?array {
$resp = wp_remote_get($url, ['timeout' => 3]);
if (!is_wp_error($resp) && wp_remote_retrieve_response_code($resp) === 200) {
$data = json_decode(wp_remote_retrieve_body($resp), true);
set_transient($key, $data, HOUR_IN_SECONDS);
update_option($key . '_last_good', $data, false);
return $data;
}
$copy = get_transient($key);
return $copy !== false ? $copy : get_option($key . '_last_good', null);
}
The third argument, false, in update_option keeps the copy from being autoloaded on every page. If you use a Redis object cache, transients live there, and the fallback copy in the database survives even if Redis is flushed.
⚠️ Before changing .htaccess: back it up with cp -p .htaccess .htaccess.bak. If the site returns an HTTP 500 error, restoring that file is the rollback.
DNS and payment gateway fallback
DNS is the dependency most people forget. If your domain's record points to a single server and that server stops answering, there is nothing the visitor can do. AWS Route 53 handles this with a failover policy: a health check watches your primary server and, if it fails, Route 53 starts answering with the IP of a backup server, which can be a static copy of the site or a maintenance page with your contact details.
Understand what it covers and what it doesn't. Route 53 failover changes the destination when your server fails; it doesn't protect you if the DNS service you use goes down. That is what secondary DNS with another provider is for, and it's a separate project. With Terraform, the failover is declared and versioned, and undoing it is a terraform apply of the previous state:
resource "aws_route53_health_check" "origin" {
ip_address = var.server_ip
fqdn = "tusitio.mx"
type = "HTTPS"
failure_threshold = 3
}
resource "aws_route53_record" "primary" {
zone_id = var.zone_id
name = "tusitio.mx"
type = "A"
ttl = 60
records = [var.server_ip]
set_identifier = "primary"
health_check_id = aws_route53_health_check.origin.id
failover_routing_policy { type = "PRIMARY" }
}
resource "aws_route53_record" "backup" {
zone_id = var.zone_id
name = "tusitio.mx"
type = "A"
ttl = 60
records = [var.backup_ip]
set_identifier = "backup"
failover_routing_policy { type = "SECONDARY" }
}
Declare var.zone_id, var.server_ip and var.backup_ip in your variables.tf. The health check uses the direct IP so it doesn't depend on the same record it watches, and the fqdn only makes the certificate and virtual host answer correctly; it checks the site root over HTTPS every 30 seconds (the default) and flags a failure after three attempts. The low TTL makes the switch take effect quickly.
⚠️ Before applying it in production: export the current zone, run terraform plan and check that it only creates what you expect. Keep the previous state so you can roll back.
The payment gateway follows a different rule. Don't program an automatic retry with a second provider: if the first gateway charged the card but answered slowly, the retry can charge twice. The safe approach is for checkout to show a clear message when the gateway doesn't answer and offer an alternative method that doesn't depend on that API, such as bank transfer or in-store payment, and for someone to review pending orders before retrying anything.
External monitoring: hear about it before your client does
Monitoring that runs inside your server tells you the server is fine. It doesn't tell you that DNS stopped resolving, the CDN is serving errors or the gateway is taking twenty seconds. For that you have to look from the outside, from where your clients are.
The minimal version fits on a machine other than your server: another instance, an office computer or a monitoring service. Run the dependency script from the timeouts section on a cron every few minutes, write the output to a log and send an alert whenever a FAIL line appears. Add your own home page, your checkout page and the gateway endpoint to the list.
Measure three things per dependency: whether it answers, how long DNS takes to resolve and how long the first byte takes. Keep a baseline from a normal day; on peak day, compare against it. A dependency that goes from answering quickly to taking several seconds is the early signal of a cascading outage, and the moment to switch on the plan B you wrote in the inventory.
The most valuable part of external monitoring isn't the alert, it's the clarity: when the phone rings, you already know whether the problem is yours or a third party's, and you can tell the client what's happening instead of guessing.
The real case
What I can share with verified data is this: I run 23+ production WordPress sites on AlmaLinux + WHM/cPanel, and I migrated 61 domains to PHP 8.3, one by one, with automatic backup and rollback. I also compiled Redis 6.3.0 for ea-php83 without losing cache in production. I don't have a CDN or DNS outage case with figures I can publish, so I won't make one up.
[FALTA CAPTURA: output of the dependency inventory script on a real site, with external domains sorted by number of appearances]
Why I bring it up in an article about dependencies: the rule that made that migration possible is the same one I recommend here. One change at a time, a backup before touching anything and an automatic way back if something goes wrong. It applies equally to a plugin timeout, a cache header or a DNS record: if you don't know how to undo it in a minute, you're not ready to apply it in production yet.
Everything else in this guide is a recommendation, not a story: take the inventory, measure your dependencies today, put short timeouts on hidden calls, keep the last good copy of every API and watch from the outside.
What I wouldn't do
I wouldn't leave a site with a single DNS record pointing at a single server and no plan B. You don't need complex infrastructure: failing over to a static page with your phone number and email already keeps the visitor from seeing a browser error. And I wouldn't confuse that failover with redundant DNS: they're two different problems, and you should know which one you have covered.
I wouldn't let a PHP call to an external API block page generation without a timeout. It's the most common failure and the quietest: the site doesn't throw an error, it just gets slower until it stops answering. Nor would I raise the timeout to "fix" a slow API; that only makes the process queue grow faster.
I wouldn't set up an automatic charge retry with another gateway. The risk of charging twice costs more than a lost sale.
Shall we review it together?
If your site depends on a CDN, a payment gateway or external APIs, and you're not sure what happens when one of them fails, I can go through this guide's review with you: dependency inventory, timeouts, fallback caching, failover declared on AWS with Terraform and external monitoring. First, check the WordPress security audit checklist. Book a dependency and AWS + Terraform audit at /en/contact.
About the author
Samuel Torres is a Software & Cloud Engineer at Conqr Digital Agency (Mexico City). He runs 23+ production WordPress sites and migrated 61 domains to PHP 8.3, one by one, with automatic backup and rollback. More at /en/about. Get a quote on WhatsApp in 2 min


