Precision Time Is a Dependency Almost Nobody Lists

Almost every distributed system in production carries an unstated assumption: that the machines involved agree about what time it is, to within a tolerance nobody wrote down. Ordering of events across services, expiry checks on tokens and certificates, correlation of logs during an incident, regulatory timestamping in trading and record-keeping — each of these is a correctness property that quietly depends on clock agreement, and each fails in a confusing way when the assumption breaks. What makes clock problems distinctively unpleasant is that they do not look like clock problems. A node whose time has drifted does not report drift; it reports a token that is somehow already expired, a record that appears to have been written before the request that created it, a replica that rejects an update as stale, or a log timeline that is subtly impossible to read. Engineers reliably investigate the application first, because the application is where the symptom appeared, and the median time to suspect the clock is long. The infrastructure has been improving in ways that mostly go unnoticed by the teams that benefit. Ordinary network time synchronisation is adequate for logging and expiry checks and is nearly free. Higher-precision approaches that timestamp packets in hardware rather than software close the gap by orders of magnitude and are standard in trading venues, telecommunications networks and increasingly in large database deployments where tight clock bounds allow faster consensus. Separately, the long-running effort to stop inserting leap seconds removes a genuinely nasty class of bug in which a repeated or skipped second broke software that assumed time only ever moves forward at a fixed rate. The practical advice is unglamorous and rarely followed: monitor clock offset as a first-class metric with an alert threshold, know which of your correctness properties depend on it and what tolerance each actually needs, and make sure time sources are diverse enough that one bad upstream does not move the whole estate together. Systems that agree on the wrong time are harder to debug than systems that disagree, because disagreement at least announces itself.