Coder Legion - Recent posts tagged cron

TTFB Won't Go Down? Server-Side Culprits Beyond the Theme

Sun, 23 Aug 2026 10:02:00 +0000

You moved the site behind a CDN, trimmed the theme, deferred scripts, and ran a caching plugin. PageSpeed Insights still flags a high Time to First Byte on the homepage, and the waterfall shows most of the wait in Waiting (TTFB) rather than DNS or TLS. The next ticket proposes a bigger hosting plan; in our experience that upgrade often treats the symptom while the origin keeps doing too much work per request, or background jobs steal capacity when real visitors arrive.

What follows is a server-side checklist for WordPress and PHP stacks when you need to reduce TTFB after delivery-layer fixes. We focus on origin compute and scheduling: cron, workers, cache, database, and maintenance plugins. For DNS, TLS, HTTP, and CDN cache rules, start with Network Performance for Web Teams: DNS, TLS, HTTP, CDN, and Cache Rules. For cases where application code beats infrastructure, see Why Your WordPress Site Is Slow (It Is Not Always Hosting).

When slow server response time is not a theme or CDN problem

Lighthouse and PageSpeed Insights label high first-byte time as Reduce initial server response time. The diagnostic measures how long the browser waits after the request leaves the client until the first byte of the HTML response arrives. When DNS, connect, and TLS are already short, the remaining delay is almost always origin processing: PHP execution, database queries, remote API calls inside the page build, or contention from other jobs on the same machine.

That pattern is common on WordPress sites that look optimised in the front end but still regenerate HTML on every uncached hit. A page cache can hide the problem until a cache miss, a logged-in session, a cart cookie, or a query-string variant bypasses the edge, so your lab test shows a high TTFB while marketing reports “the CDN is on.” Treat those misses as the path that matters, not the cached marketing homepage.

Symptom in lab or RUM	Likely layer	First place to look
High Waiting, low DNS/TLS	Origin PHP / app	Object cache, query count, cold workers
Spikes at the top of each hour	Scheduled tasks	WP-Cron, backup, search indexers
Slow only when editors are logged in	Uncached admin bar / personalised HTML	Page cache exclusions, admin-ajax
Slow on `/?` and `?nocache=1` only	Full page cache working elsewhere	Origin path above
Slow after deploy, fine after warm-up	Cold opcode / PHP workers	OPcache, worker count, warm scripts

If your waterfall still shows long DNS or TLS phases, fix the network stack first; the sections below assume those hops are already reasonable.

How WordPress WP-Cron inflates time to first byte

WordPress schedules many tasks through WP-Cron, which is not a system daemon. On default setups, wp-cron.php runs on page requests: a visitor or bot triggers due jobs before WordPress serves the page they asked for. Heavy plugins add hooks for imports, sitemap builds, newsletter sends, and housekeeping that can run for seconds on shared hosting, which is why support threads about WordPress TTFB and cron keep resurfacing. A backup finishing at 09:00, a search indexer at :15 past the hour, and a security scan at :30 can stack into the same traffic window, so editors notice the site feels slow while cron owns the CPU.

Practical fixes, in order of leverage:

Disable request-driven WP-Cron in wp-config.php (define('DISABLE_WP_CRON', true);) and trigger wp cron event run --due-now from system cron on a fixed interval (every five or fifteen minutes, not on every page view).
Audit scheduled events with wp cron event list (WP-CLI) or a cron inspector plugin in staging. Remove or reschedule plugins that register hourly full-table scans on production.
Stagger plugin schedules so backup, analytics aggregation, and link checkers do not share the same minute.
Run long jobs off-peak in the site’s traffic timezone, not the agency’s office hours.

After changes, compare TTFB on the same URL at :05 and :55 past the hour; if the spread collapses, cron was the culprit rather than the theme or CDN.

PHP workers, opcode cache, and origin saturation

Even with clean cron, each uncached HTML request needs a PHP worker to execute WordPress. On FPM pools with few children, a burst of concurrent visitors queues behind a small worker count, and cold workers (first request after idle, or after deploy) pay bootstrap cost: loading WordPress core, autoloaded options, and dozens of plugin files before your theme renders one line. The checklist below covers the worker and opcode issues we see most often on agency WordPress stacks.

Checklist for worker and opcode issues:

OPcache enabled with enough memory and validate_timestamps tuned for your deploy flow (revalidate in dev; stable in prod).
Realpath cache and sensible pm.max_children for traffic (too low queues; too high can exhaust RAM and swap).
Separate pools for admin, AJAX, and front-end when the host allows it, so admin-ajax.php storms do not starve public pages.
Warm critical URLs after deploy (homepage, top landing pages, cart) before announcing release.

Origin saturation also appears when the same server runs mail, staging sync, or backup restores alongside production. Slow server response time in that case is capacity planning, not a tweak to a single plugin, but right-sizing workers and separating batch work often beats doubling CPU without touching cron or object cache.

Database load, object cache, and N+1 queries on uncached requests

WordPress without a persistent object cache hits the database for autoloaded options, post meta, and taxonomy on nearly every request. Plugins that add large autoload rows or run wide queries on init multiply that cost, and page builders with dynamic blocks can trigger N+1 query patterns when a single template loads dozens of posts or meta keys per view. Those queries run before the first byte leaves the server, so they show up directly in Waiting time rather than as a front-end script problem.

Signs the database is dominating TTFB:

Query Monitor (staging) shows hundreds of queries on the homepage.
wp_options autoload size is megabytes (transients and plugin settings that never clean up).
Slow query log spikes on wp_postmeta, wp_options, or custom tables from analytics plugins.

Mitigations that actually move first byte:

Issue	Fix
No object cache	Redis or Memcached with a drop-in (`object-cache.php`)
Fat autoload	Audit `autoload=yes` options; remove stale plugin rows
N+1 in theme or plugin	Batch queries, lazy load blocks, or cache fragment output
Missing indexes on custom tables	Add indexes in staging; measure before prod
Remote HTTP inside `the_content` filters	Remove or cache API responses with short TTL

Object cache does not replace a full-page cache, but it cuts origin work on partial misses and logged-in routes, so pair database wins with Performance Budget Thresholds Template on templates that must stay dynamic (checkout, account, enrolment).

admin-ajax storms, backup plugins, and maintenance during peak

Two other WordPress-specific patterns keep server response time high without touching the theme CSS. admin-ajax.php handles heartbeat, cart fragments, live search, and page-builder autosaves; a misconfigured plugin polling every few seconds from the front end can keep workers busy and add latency to unrelated pages on small pools. In staging, watch access logs for admin-ajax.php volume during a normal editor session, disable heartbeat on the front end where safe, fix plugins that hammer AJAX on public pages, and rate-limit bots that target wp-login.php and AJAX endpoints.

Backup and migration plugins (UpdraftPlus, Duplicator, All-in-One WP Migration, and host scheduled snapshot tools) can lock tables or saturate disk I/O during business hours. Schedule backups when analytics show the lowest concurrent users, not at local midnight on the server if that is peak in the site’s country, and test restore windows separately from performance testing because a backup run is not a deploy. Security scanners and link-checker plugins that crawl the whole site on cron belong in the same bucket: if TTFB spikes line up with their schedule in the cron list, move or throttle them before buying hardware.

How to verify TTFB fixes without guessing

Use the same priority URL and device profile before and after each change. In WebPageTest or Chrome DevTools, confirm Waiting shrank while DNS and SSL stayed flat, and run at least twice: once during a quiet minute and once when cron used to fire. For WooCommerce and membership sites, repeat on cart and checkout URLs, not only the homepage.

Scheduled PageSpeed monitoring catches regressions when a plugin update re-enables request-driven cron or adds autoload bloat. PageSpeed Insights versus automated monitoring explains why one-off lab pastes miss hour-of-day effects, while field TTFB in CrUX moves on a 28-day window and lab TTFB on your uncached path tells you whether today’s origin fix worked. Document what you changed (cron mode, object cache, backup window) in the client runbook so the next agency does not optimise the theme again while the server still runs fifty due cron events at noon.

FAQ

What is a good TTFB for WordPress?

There is no single magic number. Google’s optimize TTFB guidance treats sub-800 ms as a reasonable target for the HTML document on the network path you control, and stricter shops aim lower on cached marketing pages. Compare your origin miss path, not only the CDN hit, because a fast edge response on a cached homepage can hide a slow uncached checkout.

Does a CDN always reduce TTFB?

No. A CDN lowers TTFB on cache hits, but on misses HTML still builds at origin. Fix origin compute first if misses are common or if personalised cookies bypass cache, because a green Lighthouse score on the cached homepage will not help checkout.

Should I disable WP-Cron on every site?

For production sites with real traffic, system cron plus DISABLE_WP_CRON is the usual best practice. Keep request-driven cron only where you cannot schedule CLI (some locked-down hosts), and even then reduce due events rather than accepting page-triggered jobs on every visit.

Is high TTFB a Core Web Vital?

TTFB is not one of the three Core Web Vitals (LCP, INP, CLS), but it still affects LCP because the main content cannot paint until HTML arrives. See LCP, INP, and CLS explained for how first byte fits the wider picture.

When is upgrading hosting the right fix?

When profiling shows sustained CPU or memory limits after cron, cache, and query fixes, or when traffic outgrew the plan honestly. If doubling RAM fixes TTFB without code changes, you probably skipped object cache or cron discipline first, so rerun the checklist above before signing a larger contract.

When CDN, TLS, and theme tickets are closed and TTFB is still high, walk this server-side list before the next hosting invoice. Apogee Watcher schedules PageSpeed runs on the URLs that bypass cache so you see origin truth, not only the fast cached homepage.

Start monitoring your client sites or run a free performance check on an uncached priority URL.

References

Optimize Time to First Byte (web.dev)
Time to First Byte (TTFB) (web.dev)
Reduce server response times (Chrome for Developers)
Improve Server Response Time (Google PageSpeed Insights documentation)
Network Performance for Web Teams: DNS, TLS, HTTP, CDN, and Cache Rules
Why Your WordPress Site Is Slow (It Is Not Always Hosting)
WooCommerce Performance Tuning (2026 Guide)
A Quick Way to Fix LCP: Four Changes That Cut Time to Paint
Performance Budget Thresholds Template
PageSpeed Insights versus automated monitoring
LCP, INP, and CLS explained

Automation periodically tasks with CRON job scheduler

Mon, 13 Jan 2025 20:57:40 +0000

What is CRON? Unix-like operating systems provide utility for run periodical tasks. For example you need to run script every day at 08:00 AM. CRON read tasks from configuration file line by line and have special syntax.

Windows have their own tool named as "Windows Task Scheduler".

Open terminal and run "crontab -e" command. When you open crontab first time, you must choose editor, which is convenient for your use. Enter number of preferred editor and press "Enter":

user@localhost:~$ crontab -e
no crontab for user - using an empty one

Select an editor.  To change later, run 'select-editor'.
  1. /bin/nano        <---- easiest
  2. /usr/bin/vim.tiny

Choose 1-2 [1]:

When you open cron system display generated configuration file with description:

# Edit this file to introduce tasks to be run by cron.
#
# Each task to run has to be defined through a single line
# indicating with different fields when the task will be run
# and what command to run for the task
#
# To define the time you can provide concrete values for
# minute (m), hour (h), day of month (dom), month (mon),
# and day of week (dow) or use '*' in these fields (for 'any').
#
# Notice that tasks will be started based on the cron's system
# daemon's notion of time and timezones.
#
# Output of the crontab jobs (including errors) is sent through
# email to the user the crontab file belongs to (unless redirected).
#
# For example, you can run a backup of all your user accounts
# at 5 a.m every week with:
# 0 5 * * 1 tar -zcf /var/backups/home.tgz /home/
#
# For more information see the manual pages of crontab(5) and cron(8)
#
# m h  dom mon dow   command

Structure of executable command:

# ┌───────────── minute (0–59)
# │ ┌───────────── hour (0–23)
# │ │ ┌───────────── day of the month (1–31)
# │ │ │ ┌───────────── month (1–12)
# │ │ │ │ ┌───────────── day of the week (0–6) (Sunday to Saturday;
# │ │ │ │ │                                   7 is also Sunday on some systems)
# │ │ │ │ │
# │ │ │ │ │
# * * * * * <command to execute>

Here cheat-sheet of some examples:

Run task every minute:

* * * * * cd /home/user && ./my_script.sh

Run task every 5 minutes:

*/5 * * * * cd /home/user && ./my_script.sh

Run task every 1 hour:

0 * * * * cd /home/user && ./my_script.sh

Or use "@hourly" definition.

Run task every day at 00:00:

0 0 * * * cd /home/user && ./my_script.sh

Or use "@daily" definition.

If your command not running by any reason use "bash -c":

*/5 * * * * bash -c 'cd /home/user && ./my_script.sh'

Run task at system startup:

@reboot cd /home/user && ./my_script.sh

Save changes and exit from editor. Now we're need to reload CRON service. Its need for read configuration file again. Just use "service cron reload" command:

user@localhost:~$ service cron reload
Reloading configuration files for periodic command scheduler: cron.