Hourly Is Not Real Time
A closed hourly report answers different questions than ongoing operational monitoring – and gets simpler as soon as time windows, delays and measurement gaps are modeled explicitly.
An hourly report doesn’t ask about the current state but about the hour that just closed. Whatever happens at 14:00:00 UTC already belongs to the next time window. So the run only starts once the time window is closed, and it publishes its state a few minutes later. For an alert, that would be far too late. For a reliable summary, it’s exactly the delay you want.
This timing decision separates the hourly report from ongoing operational monitoring. A closed report answers a different question than monitoring: it records a bounded period as a verifiable state of the observations, while monitoring has to react to new signals. The difference isn’t primarily in Prometheus, Grafana or Markdown. It lies in how quickly a new value has to trigger a reaction and whether the statement in question may still change later.
The article “Markdown Reports Instead of Dashboard Mandates” already describes the difference between a fleeting view and a verifiable state. This one is more narrowly about the timing mechanics of a regular product report: closed time windows, late data, retries and the boundary to real operational monitoring.
Two time axes, two jobs#
Monitoring works as close to the event as possible. An error rate rises, an alert is evaluated, someone opens logs and traces. New data keeps changing the display. A report, on the other hand, waits until its period has ended. It can then determine which sources were complete, hash its facts and deliver the same state again later.
flowchart LR
E["Event"] --> M["Live metric<br/>seconds to minutes"]
M --> A["Alert or investigation"]
E --> W["Closed hourly window"]
W --> R["Immutable report"]
R --> V["Comparison and context"]Both paths may see the same event and still arrive at different results. Monitoring can react at 13:42 to five errors in two minutes. Later, the hourly report records that in the time window from 13:00 to 14:00, five errors occurred across 1,200 executions, which sources were covered and whether the cluster stands out compared with earlier time windows.
A continuously updated UI for the second job would show incomplete intermediate states. While the time window is running, counters are incomplete. A value of zero at 13:01 says almost nothing about the hour. A growing bar invites you to compare unmarked intermediate states with closed hours. Without accounting for the different coverage, that comparison doesn’t hold up.
The boundaries of the time window#
Collection uses half-open UTC intervals. Start included, end excluded. This notation prevents an event at the boundary from ending up in two reports.
type ClosedWindow = {
from: string; // inclusive RFC 3339 timestamp
to: string; // exclusive RFC 3339 timestamp
bucket: "hour";
};
const window: ClosedWindow = {
from: "2026-07-18T13:00:00.000Z",
to: "2026-07-18T14:00:00.000Z",
bucket: "hour"
};
UTC avoids an unpleasant special case: in Europe, the day of the daylight saving time switch doesn’t always have 24 local hours. Storage and collection therefore stay in UTC. The report page can localize a date for its readers later without changing the domain boundary.
Between the end of the time window and the freshness check, this process provides an explicitly defined buffer. If collection grows more extensive, start time, timeout and check boundary have to be adjusted together. A secretly extended buffer would only make real delays visible later.
Keeping late data and missing runs apart#
An HTTP call can fail temporarily. A workflow can abort after writing the artifact but before updating its status. A release can succeed even though the response never reaches the client. That’s why a retry must not simply mean “everything again.”
Each run has a unique time window. Cadence-tagged reports are treated here as immutable publications: once an hourly state is published, it doesn’t change anymore. A repeated successful attempt must therefore not make a second, different hourly report visible for the same time window.
Only after the intended buffer does the distinction between late and missing apply. A late run can still complete successfully and publish the same report. A missing run leaves a gap in the expected sequence of hours. Lateness, measurement gap and closed time window thus remain three separate facts that the report should name separately.
What follows from a missing observation#
A critical case for an hourly report is an hour without data. An observation service should explicitly distinguish four states for this: a source has never been observed, it was checked and the expected content isn’t there, it is access-protected, or it is actually broken. A missing observation must be reported neither as a healthy state nor as the numeric value zero.
For an hourly report, this means: if there’s no measurement for an hour, there’s no value for that hour. The report then must not claim there were zero events, because that statement would imply a measurement that never took place. Instead, it has to show that the source wasn’t observed in the period in question and the statement remains open. If, on the other hand, the source was checked and the expected content wasn’t found, that state is observed; but that doesn’t automatically mean a general error counter of zero.
When you would miss Prometheus and Grafana#
Tools like Prometheus and Grafana support, among other things, ongoing investigation: you can adjust a query during the analysis and shift the time range. This way of working is valuable when the question wasn’t fixed in advance.
A UI for hourly reports, on the other hand, can be geared toward closed report periods. That focus fits as long as the UI is meant to explain closed periods. For an incident analysis, though, warnings would come too late, and hourly resolution isn’t enough to trace a cause down to individual requests. An hourly report replaces neither alerting nor ongoing operational monitoring; it assumes both as separate jobs.
Four questions before choosing a tool#
“Dashboard or report?” is too coarse. Four questions separate the requirements: reaction time, mutability, investigation and resolution.
The first concerns reaction time. If someone has to act within seconds or a few minutes, the observation belongs in a monitoring and alerting system. If a team can check the state in the next regular work cycle, an hourly or daily report may be enough.
The second concerns mutability. If the same URL should show new values tomorrow, a live query fits. If exactly the state from July 18 still has to be readable later, you need an immutable artifact or an explicitly stored snapshot.
The third concerns investigation. If the questions are known in advance – number of releases, errors, source coverage – a limited schema can represent them precisely. If the questions only arise when you look at an anomaly, a query language, variable time ranges and drill-down become important.
The fourth concerns resolution. An hourly counter can show that something failed more often. It can’t explain which individual request was slow or which log line belongs to a trace. For that investigation, the high-resolution data has to stay in its operational tool.
decision:
reaction_time: next_work_cycle
immutable_history: required
questions_known_in_advance: true
per_request_drilldown: false
result: scheduled_report
As soon as one answer flips, the right tool can change too. A report and a live system may observe the same service, as long as they don’t pretend to do the same job.
The scheduler is part of the statement#
A manually generated report only proves that someone pressed a button at some point. A scheduled run additionally makes visible whether the expected regularity was kept. A check of this regularity therefore has to distinguish between scheduled and manually triggered runs: manual runs must not cover up a missed scheduled hour, otherwise the check counts successes that say nothing about the promise of regularity.
A pause isn’t an error either, if it was explicitly set during a release. But it has to be visible and deliberately lifted after the rollout. A forgotten pause switch isn’t a data problem but a broken promise about regularity.
What an hourly report has to explain#
Without stated source coverage, an operator can read a measurement gap as a result. An hourly report therefore has to explain for itself what it’s based on. Overview, question, conclusion and next action can be derived from the same semantic report document; a second, separately maintained dashboard dataset isn’t needed for that. A suitable UI shows this answer in decreasing order of importance: first state and exception, then a few signals, then evidence and provenance.
A page with thirty metrics and no question is harder to check than a page with one clear question, one supported state and one named next decision. For this, the fact definition also has to represent data gaps: it should name available, missing and stale sources separately, so that an open statement doesn’t look like an answered one.
## Data quality
The source window is complete for four product APIs.
External acquisition data is not connected yet and is shown as unavailable.
No value is inferred from missing input.
Aggregation needs an explanation too. A weekly median runtime answers a different question than the maximum of the slowest hour. The report names the period, the expected and available sub-windows and the aggregation used. Otherwise, a precise number looks more verified than it is.
Rolling up over larger periods#
Daily, weekly, monthly and yearly reports are built from already closed artifacts. A daily report can build on the immutable hourly states instead of querying the same sources again for each hour, and in doing so show which hourly windows it’s missing. Cadence-tagged reports remain immutable publications; a rollup doesn’t replace an hourly state, it condenses it.
flowchart TD
H["24 hourly artifacts"] --> D["Daily report"]
D --> W["Weekly report"]
W --> M["Monthly report"]
M --> Y["Yearly report"]
H --> Q["Coverage and missing windows"]
Q --> DA daily report that’s missing individual hourly windows can still be more helpful than no report at all – but only if it clearly marks itself as incomplete. It must not radiate the same visual certainty as a fully covered period. Data quality belongs next to the metrics, not in a footnote.
A UI can place the latest closed period ahead of further decision horizons and a limited history. Which question each coarser report answers is a design decision. An obvious split: the hour checks the data flow and fresh technical signals. The day answers what needs attention today. The week compares daily patterns and recurring exceptions. The month puts activity patterns, operational risks and measurement gaps in context for the next round of planning. The year condenses only the evidence that can support a strategic decision. Just widening the date filter would be formally correct and weak in substance.
Numbers aren’t just values here either. A fact definition should distinguish counters, stocks, durations, ratios and data volumes, name the unit and specify whether a rollup prefers the sum, the last value or the mean. A machine then doesn’t have to guess from a metric name how the value should be read across several intervals.
Simple technology needs a clear boundary#
The hourly approach can get by without an additional, permanently running analytics platform if existing systems take over collection, scheduling and publishing. Its questions are fixed before the run, and its result appears as an immutable publication. What matters is the boundary of responsibility: the report collects, closes and publishes; ongoing observation stays with the systems built for it.
This simplicity only survives if the system stands by its job. A report may show a missing data source instead of secretly building in new data collection. It may point to an external incident view instead of becoming the control room itself. And it may leave a question unanswered if there’s neither a fact nor a connector for it.
Hourly here doesn’t mean “almost live.” It means: regular, closed, repeatable and slow enough to verify a complete state. If you have to react faster, you need monitoring and alerting. If you want to trace later what was known in a clear period, you need an hourly report. Both exist side by side, with clearly assigned jobs: monitoring delivers ongoing signals, alerting triggers a reaction from them, and the hourly report preserves the closed, verifiable state of observation.
Further reading#
Revised and translated from German with the help of AI.