When a client says real time, ask what breaks if data is late
Turn "real time" into a number, then pick the cheapest architecture that meets it, which is often batch rather than a round-the-clock stream.
In brief
- Most requests for "real time" really mean data every hour or every five minutes.
- Streaming runs continuously, so it consumes resources even when little data is flowing. It is worth building only when lower latency delivers real business value.
- The diagnostic question is "what breaks if the data isn't fresh?", not "can we stream it?"
At the second meeting on site, the head of operations delivers a line every FDE has heard: “This dashboard has to be real time.” Nod, go away and build a streaming pipeline, and you have taken on a system that must run around the clock, when the real need may be an hourly refresh.
Getting data freshness wrong is one of the quietest scoping mistakes. It does not make the demo fail. It makes the system more expensive and harder to run, and once you leave the site, the client’s team inherits that complexity.
The skill to practise here is not about tools. It is knowing which questions turn the words “real time” into a number, and then choosing the cheapest architecture that still meets it.
Five things clients lump together as “real time”
First comes batch. AWS defines batch processing as the method computers use to periodically complete high-volume, repetitive data jobs. Batch needs very little human intervention, and the system processes large volumes of data in sequence.
Batch also has a cost advantage. AWS notes that batch jobs can run on spare compute capacity, such as Spot Instances at discounts of up to 90%. The ETL job that runs at midnight is the familiar example.
Micro-batch is still batch, just run more often, every few minutes. The Data Lakehouse Hub engineering blog observes that this keeps most of the value of streaming while staying as simple as batch. Its limit is that it cannot get below one second.
Third is synchronous communication, such as an API call that waits for a result. In Guru’s definition, synchronous communication happens in real time: the parties are present together and respond immediately. This is usually what users actually mean when they say “real time” about a specific action.
Fourth is the message queue. AWS describes a queue as a form of asynchronous service-to-service communication, used to decouple heavy processing from the main flow and to buffer or batch work. Asynchronous means the response may come later; the core difference from synchronous communication is timing.
Last is streaming: processing data continuously as it flows in. The cost lies in that word “continuously”. A streaming job runs day and night and keeps consuming resources during hours when data is sparse. TDWI points out that the compute that sits idle between batch runs is always on in a streaming architecture.
Why “real time” usually means “hourly”
Data Lakehouse Hub states plainly that most “we need real-time” requirements are actually “we need hourly” or “we need every five minutes”. Clients are not lying. To someone in the business, “real time” often just means “fresher than the report from yesterday morning I’m stuck reading”.
The same source sets the bar for streaming: choose it only when latency is measured in seconds and stale data causes serious damage. TDWI puts it another way: streaming justifies its complexity only when the delay it removes has real business value.
That is the question TDWI advises asking before choosing streaming. For an FDE, it is the most effective discovery tool on this topic, because it moves the conversation from technology to consequences, which the client understands better than you do.
A sample conversation
Picture a consumer-goods distributor that wants “a real-time data platform”. Instead of discussing architecture, you split the request into use cases and ask the same question about each.
FDE: For the regional managers’ inventory dashboard, what happens if the numbers are an hour late?
Regional manager: Nothing, really. People only open it in the morning and early afternoon to plan the trucks.
FDE: And the alerts for unusual orders, say a dealer ordering ten times their normal amount?
Head of risk: That needs to be quick, but the risk team handles it manually. Within 10 minutes is fine.
FDE: What about payment status when a driver delivers and collects money at the store?
Operations team lead: The driver has to know immediately whether the transaction went through before moving on.
Three answers, three very different freshness levels. Write them down as a table and you have your first scoping document:
| Use case | What breaks if it’s late | Tolerable latency | Sensible choice |
|---|---|---|---|
| Inventory dashboard | Almost nothing; users check it twice a day | 1 hour | Hourly batch |
| Unusual order alerts | A risky order gets handled late | 10 minutes | 5-minute micro-batch |
| Payment confirmation | Driver left waiting, transaction hanging | A few seconds | Synchronous API call, heavy processing pushed to a queue |
Looking back at the table, none of the three rows needs a full streaming pipeline. Even the most urgent case needs only a synchronous call that returns a result immediately; the bookkeeping, reconciliation and analysis can go through a queue to be processed later.
The original request for a “real-time platform” turns out to be three small systems, each much cheaper and easier to run.
Doing it yourself on site
Start by listing each decision that will use the data, not each data source. A single table can serve three decisions with three different latency tolerances.
Next, for each decision, ask the person who actually makes it: when do they look at the numbers, how often, and what breaks if the numbers are late? Turn the answer into a concrete figure such as “1 hour”, “5 minutes” or “2 seconds”, and ask them to confirm it in writing.
Then choose the simplest option that meets that figure, in this order: batch, micro-batch, queue, and only then streaming.
Data Lakehouse Hub advises upgrading only when there is good reason, so write down the upgrade condition explicitly, for example “if the share of risky orders handled late exceeds threshold X, move to streaming”.
With that line in place, a few months later both sides need only look at the numbers to decide whether to upgrade, rather than reopening the whole debate.
Common mistakes
The most common mistake is asking the buyer instead of the user. The person signing the contract tends to want “real time” because it sounds modern; the person who opens the dashboard every morning is the one who knows what they actually need.
The second is letting one urgent use case dictate the architecture for everything. A single flow that needs an answer within seconds does not mean the whole platform must stream. Split it out and keep the rest on batch.
The third is forgetting the operating cost after handover. A continuously running streaming job needs someone on call, needs monitoring and burns resources even at midnight. If the client’s team has never run a system like that, you are leaving them with a debt.
How to answer the “client wants real time” interview question
This is an ideal scenario question to practise before an FDE interview: “The client says the dashboard must be real time. What do you do in the first week?”
A good answer follows the sequence above. You split the request into decisions, ask the actual users “what breaks if the numbers are late?”, pin each use case to a latency figure, choose the cheapest option that meets it, and state the conditions for upgrading to streaming later.
Finish with an example that has numbers in it, like the three-use-case table above, because it shows you understand both cost and the business.
Knowing how to build a streaming pipeline is a good skill. But what interviewers tend to remember is the moment you turned back to the client, asked “what breaks if it’s late?”, and came away with a number clear enough to choose the right architecture.
Was this article useful?
Thanks for the feedback!