TTFB (Time To First Byte) is the time from the moment a browser requests a page until the first byte arrives from the server. Several things happen in that window: the domain is resolved to an IP, a connection is opened, HTTPS encryption is negotiated, and the server builds the page and starts responding. The visitor stares at a blank screen the whole time, so TTFB is the foundation of page speed. However well you optimise images and scripts, a late first byte delays everything else.
What counts as good
Google's web.dev guidance treats a TTFB of roughly 0.8 seconds or less as good. That is a general target: cached pages usually answer much faster, while a complex search or cart page may be a little slower. Watch the trend rather than a single number; if a TTFB that used to be 0.3 s is now 2 s, something has changed. Measure from the network your visitors actually use, because a test from a distant data centre adds latency that local users never see.
Measure it phase by phase
curl -o /dev/null -s -w "dns: %{time_namelookup}\nconnect: %{time_connect}\ntls: %{time_appconnect}\nttfb: %{time_starttransfer}\ntotal: %{time_total}\n" https://example.uz/
Each value is the cumulative time in seconds since the request began. A large dns points to DNS servers; a big gap between connect and tls means slow negotiation or a distant server. The gap from tls to ttfb is the time the server spent generating the page, and that is usually where most of it goes.
Page caching: the biggest win
On dynamic sites like WordPress every request runs PHP, fires dozens of queries and assembles HTML. A page cache stores the finished HTML and serves it instantly to the next visitor, which is the single biggest TTFB reduction for anonymous traffic. Exclude the cart, account and checkout pages, or one user's data could be shown to another. To confirm the cache works, measure the same page twice with curl; the second request should be noticeably faster.
PHP version and OPcache
Newer PHP releases generally run the same code faster, so use the newest stable version your site supports. OPcache keeps compiled scripts in memory instead of parsing them on every request. Check it over SSH, remembering that CLI and web PHP settings can differ:
php -v
php -i | grep -i "opcache.enable"
ISPmanager lets you pick the PHP version per site. Take a backup before switching and test key pages afterwards.
Database queries
Without a cache, much of TTFB is spent in the database. WordPress accumulates revisions, expired transients and settings from removed plugins. Autoloaded rows in wp_options are read on every page, so a bloated set slows every request:
SELECT ROUND(SUM(LENGTH(option_value))/1024) AS autoload_kb
FROM wp_options
WHERE autoload IN ('yes', 'on', 'auto');
Your table prefix may differ. If the result is several megabytes, find which plugin left those rows and remove the unneeded ones, after taking a backup.
Object cache and external calls
Sites with many logged-in users, such as shops or learning platforms, cannot cache every page. An object cache like Redis keeps frequent query results in memory, usually on a VPS or a plan that supports it. Watch for external API calls too: a currency rate or social widget fetched while the page is built adds that server's wait time directly to TTFB. Refresh such data in the background and cache it.
Server location and network
The farther the server is from the visitor, the longer every round trip takes, and HTTPS needs several. If a dental clinic in Tashkent serves mostly local patients, a server in Uzbekistan connected to Tas-IX reduces latency. sayt.uz hosting servers are located in Uzbekistan, which shortens the network phase for a local audience. A CDN can help international visitors, but it speeds up static files and does not hide slow PHP on the origin.