Skip to content
Anil Thapa
Architecture & economics

What a faster refresh actually buys

A request for real-time data is a request for a new operating promise. How to find out whether the earlier answer changes an action, what that promise costs, and when a slower schedule is the right one.

6 min read

A request once came through for real-time refund data. It had passed every requirements check, made it through planning, and the engineers had already started designing it. When I saw it, I asked them one question first: what would anyone do with a live refund number? And did refund mean a refund the company had processed, or a customer asking for one? The requirement didn’t say. The engineers had read it as processed refunds, which was reasonable, and it still missed the point. The team that asked wanted a refund rate by day, to see how changes in customer service and refund policy moved it. Real time meant nothing to them.

Another request ran the other way. It came in with no schedule at all: a success rate for each payment processor, so someone could check whether there had been outages. Once I understood what it was for, the stakes were obvious. A processor that stops taking payments hurts the business for every minute it is down. That one became real time, with an alert when the rate dropped.

The difference was never in the wording of the request. It was in the problem behind it. Don’t build first and ask later. Ask first, then build what the problem needs.

The requirement I want is the latest point at which useful information can arrive with enough time left to do something about it. The architecture and the cost follow from that.

Find the deadline the refresh is supposed to protect

The two requests, side by side:

Use Decision it supports What the delivery must provide
Refund rate by day Judge the effect of customer service and refund policy changes Checked data through the previous day, with refunds and refund requests counted separately
Payment processor success rate Catch a processor outage while payments are failing Success rate by processor within minutes, an alert when it drops, and a named person to act

The refund rate does not need minutes. It needs a clean definition and a checked day, and refreshing it every few minutes would only give people a number that moves while they are reading it.

The processor view is the opposite. An overnight answer describes an outage that has already cost the business, and a live chart nobody is watching is not much better. It needs a current view, an alert that reaches someone, and that someone has to be available and able to act.

So work backward from the action. Allow time for someone to notice the change, check what it means, decide and act. What remains is the time available for capture, processing and delivery, with some room for ordinary variation. And look for the consumers who never open the dashboard: a daily alert or an export can depend on the timing as much as any reader.

Fresher data earns its cost when it leaves someone more time to change what happens next.

A recent refresh can still show old events

An updated timestamp can mean several things: when the source recorded an event, when the platform received it, when a model ran, or when the report refreshed. A model that runs every five minutes against a feed delivered once an hour mostly produces new copies of old information.

Measure the delay through the whole path to the person, and look at the busy periods and the slow cases, because an average can look excellent while the view misses the only moment that matters. Even a setting named for freshness needs reading carefully: Snowflake’s documentation for dynamic tables, as it read in 2026, describes target lag as a best-effort staleness target, measured from the base tables at the root of the pipeline, which says nothing about the time an event spent before it arrived or the delay before a person sees the result.

Decide what may change after publication

An earlier answer usually contains less information, and refunds show why. A refund request today may become a processed refund next week, or never. A daily refund rate should say which one it counts and expect the most recent days to move as requests resolve. The Dataflow Model paper, by Tyler Akidau and colleagues at Google in 2015, treats late arrivals and revisions like these as normal for continuously arriving data, and frames the design as a choice among correctness, latency and cost.

The processor view can show the current state and accept late updates, provided the person watching can see when the feed itself is behind. A quiet chart and a stalled feed look the same unless the view says which one it is.

Price the promise through a failed refresh

A live view is a service, not a page. When the feed behind the processor alert fails, the failure has to be loud, someone has to answer it, and there has to be an agreed fallback. That is what the speed actually costs: the monitoring of the monitor, the person on call, and the recovery when a run is missed. More frequent runs can also repeat scans and keep capacity awake, though processing only the changes can make a faster schedule cheaper rather than more expensive. There is no rule that twelve times the runs means twelve times the cost.

Set all of that against what waiting would cost. For the processor rate, the cost of waiting is payments failing while nobody knows. For the refund rate, it is close to nothing, which is why a daily rate was the right build.

Slowing a schedule down deserves the same care. It may lower metered usage without changing a committed bill, or free capacity that something else immediately uses. Those are useful, and they are not cash savings.

Give the urgent consumer a smaller dependency

One urgent use can drag an entire reporting chain onto a tighter schedule. A processor alert does not need the historical enrichment and the slow sources the rest of the payments reporting waits on. I would first check whether the operational system can serve the decision directly. If it cannot, give the urgent path only the data its action needs, and let the reporting keep its own schedule, with shared identifiers and one definition of a successful payment between them. That split has its own cost in two delivery promises to watch, and when that outweighs the extra refresh cost, one path at the tighter target can be the better choice.

Write down the delay you are accepting

A slower schedule gives something up. A new event waits longer to be seen, and a use nobody mentioned may turn out to depend on the old timing. Those are reasons to agree on the change, not to slip it in after a budget review.

For each material consumer, record the data it needs, the delay it can tolerate at the point of use, the hours it matters, and what happens when delivery misses. Name who can accept provisional data, what the fallback is, and who decides if the requirement changes. Then agree on what would make you revisit it: a new policy that needs faster feedback, a new processor, or an action that becomes automated.

A cheaper refresh schedule comes with a delay someone has agreed to carry.

Freshness alerting is one of the four demands in the Tradeoffs exercise, and it is deferred in half of the six pairs. The reviews there say when that is the right call.

The refund team got a checked daily rate. The payments team got a live view and an alert. The schedules ended up different. The reason was the same: what becomes possible before the chance to act closes, and what it costs to keep that chance open.