What the shared cache contains
PostgreSQL shared buffers hold pages from relations such as tables and indexes for use by multiple server processes. With a normal eight-KiB block size, one GiB corresponds to roughly 131,072 page-sized slots as a simple capacity calculation. The server still needs other memory for connections, query work and bookkeeping, while the operating system also needs memory. Increasing this cache therefore does not solve every memory problem. Distinguish a shared relation-page cache from per-query sort or hash memory and from the total resident footprint of all database processes.
Follow a hit and a miss
If a needed page is already in shared buffers, PostgreSQL can use that cached copy. A miss requires reading the relation file, but that read need not reach the physical device: the operating system’s cache may satisfy it. Shared-buffer hit ratio alone is therefore not a physical-SSD read counter. A large scan that touches each page once and repeated indexed access to a small working set benefit differently from caching. Interpret the ratio alongside workload, elapsed time and I/O observations instead of assuming that a high percentage proves every important query is fast.
Dirty pages and write-ahead ordering
An updated cached page becomes dirty. Before that changed page is written to its home location, the WAL required for recovery must satisfy the write-ahead durability rule. Commit does not generally require every modified data page to be written immediately, so a committed change remaining in memory is not a contradiction. Background writing, checkpoints and foreground activity can all participate in writeback. Consider the volume of dirty pages, writeback rate and WAL generation together. A cache-size change can alter these pressures rather than simply subtracting a fixed number of device reads.
Tune with a complete memory budget
Documentation percentages are starting points, not universal optima. Working-set size, concurrency, operating-system cache and checkpoint configuration affect the useful allocation. Giving shared buffers more space can also pressure other memory and worsen end-to-end behavior. Compare the same queries and data under stated cache conditions, and combine latency with CPU, I/O and wait observations. A hit is useful evidence about where a page was found; it is not proof of a good query plan. Inefficient repeated work can hit the cache perfectly while still consuming excessive CPU and delaying the user.