← All casesCase 0514 min

Case 05 · Lineage and observability

The dashboard says zero. You have fifteen tables and no idea which one.

Case 03 was about finding out something is wrong. This one is about the twenty minutes that follow — which, if you have not drawn a map, is where the whole night goes.

03:40

The pager goes off. Now what?

A revenue figure that leadership opens every morning is sitting at zero. Orders definitely came in last night — you can see them in the app. So it is the figure that is broken, not the business.

You now have three questions and no obvious way to answer any of them. Where did it go wrong? How far back does the damage start? And who else is about to open something built on the same broken thing?

Somebody on a comment thread described exactly this: a revenue dashboard showing nothing, a top-priority incident raised, half the engineering team woken up — and the cause turned out to be an upstream source arriving two hours late. Nothing was broken. Something was late, and nobody could see that from where they were standing.

Hours of panic, because nobody had a map.

Two things would have shortened that night. A map of what feeds what, and something watching the data that would have said “payments are late” at 02:15 instead of leaving you to guess at 03:40.

The map

Lineage is just: what feeds what.

Every table in your warehouse was built from something, and feeds something else. Write all of those arrows down and you have lineage. That is the entire concept — the value is not in the idea, it is in actually having it when you need it.

And you walk it in two directions, for two completely different jobs.

Backwards

Why is this wrong?

dashboard
   ↑
revenue_daily
   ↑
payments_clean
   ↑
raw_payments   ← here

Start at the thing that looks broken and keep stepping to whatever feeds it. The first place the data is already wrong is your answer.

Forwards

Who does this touch?

raw_payments
   ↓
payments_clean
   ↓
revenue_daily
   ↓  ↓  ↓
dash  export  model

Start at the broken thing and follow the arrows out. Everything you reach is either already wrong, or about to be.

The second direction is the one people forget, and it is the one that saves you from the worst version of the morning: fixing the dashboard, going back to bed, and finding out at eleven that a finance export built on the same table went out to someone at nine.

Your turn

Fifteen tables. One of them is lying. Three minutes a look.

The revenue dashboard, bottom left, is showing zero — that is all you know. Click any box to inspect it, and each inspection costs you three minutes of the night. Find the first place the data is actually wrong.

lineage

What that was worth

Three looks, or fifteen.

Following the arrows, the cause is three inspections from the symptom. Without the map you are opening tables in whatever order occurs to you, and on average you will be about halfway through before you land on it — call it eight looks, twenty four minutes, at four in the morning, while a number is wrong in public.

That gap is the entire business case for lineage, and it gets wider every time somebody adds a table.

It also tells you where to stop. Once you find the first wrong thing, everything above it is innocent. You do not have to keep checking the sources one by one.
And which half of the graph to ignore. In that example the city dashboard was completely fine, because nothing on its path touched payments. Knowing what is not affected is half of what you tell people.

Switch the widget to the second mode and look at what the broken table feeds. The dashboard that woke you up is one of several things on that path — and it is not the expensive one.

The part people skip

Fixing it is half the job. Telling people is the other half.

The finance export is the one that should worry you. It left the building at nine o’clock carrying a zero, to someone outside your team who has no idea the pipeline had a bad night. Nobody is going to come and tell you about it — they will simply believe it.

So when something breaks, lineage gives you the list of people to warn before they act on it, and the list is usually longer than you would guess from the thing that alerted you.

Anything downstream that already ran has shipped bad numbers. Those need a correction, not just a fix.
Anything downstream that has not run yet can simply be held until the fix lands. That is a decision you can only make if you know what they are.
Models are worse than dashboards. A dashboard with a wrong number gets questioned. A model trained on a bad week just quietly becomes slightly wrong and stays that way.

There is a second use for the same arrows, on a much calmer day. Before you rename a column or change a transformation, walk forwards first. “This touches twenty three things, including the board pack” is the sentence that stops an ordinary Tuesday from becoming another 03:40.

The alarm side

Four things worth watching, and no more than that.

Lineage helps once you know something is wrong. Observability is what tells you. Case 03 covered the checks that stop a bad batch from being served; this is the layer that watches tables continuously, including ones nobody is loading right now.

You can measure almost anything, which is exactly the problem. These four catch most of what actually goes wrong:

Is it recent? A table that should move every hour has not moved since yesterday. Nothing failed — it simply stopped being fed, and the page still renders.
Is the amount normal? You usually get around two million rows. Today it is zero, or twenty million. Both are stories, and both are invisible in a success message.
Did the shape change? A column renamed or retyped by a team that does not know you exist. Your job keeps running and starts producing nulls where values used to be.
Are the values sane? A field that is never empty is suddenly a fifth empty. Prices arrive negative. The run was fine. The contents are not.

Notice all four are about the table, not the job. That is the whole distinction, and it is why a green run never settles the question.

Two checks, two moments

Look before you start, and look after you finish.

There is a useful distinction here that almost nobody is taught, and it comes up the first time you have a pipeline that is expensive to run.

Before

A quick look at the source

is there a file for today?
does it have roughly
the rows we expect?

Cheap, fast, and it runs before the real work. If the source has nothing for you, skip the run entirely rather than spending forty minutes carefully processing nothing.

After

A proper inspection of the result

no duplicate keys
no nulls where there
should not be
totals within range

Slower, thorough, and it runs after the table is built but before anyone reads it. This is the gate from Case 03.

The first one saves you money and noise. The second one protects the people reading the numbers. They are not alternatives — most mature pipelines have both, and the cheap one at the front is the one teams usually add second, after a few nights of carefully transforming an empty file.

The counterintuitive one

Adding alerts past a point makes you less safe, not more.

This is the mistake nearly every team makes on the way up, and it feels like diligence while you are doing it. Drag the slider and watch what happens to the thing you actually care about — not how many alerts fire, but how many real problems get dealt with.

alerts firing per week · 15

—chance one gets read
—real problems caught
—missed per month

Three real problems happen a week in this imaginary company, whatever the slider says. The only thing changing is how much noise they are buried in.

A team on one of these comment threads described going from over two hundred alerts to fifteen, and people suddenly started responding again. That is not a story about discipline. It is what the curve above does.

So the useful question is not “what else could we monitor”. It is what would we actually get up for. An alert nobody will act on is not a safety net — it is a layer of padding over the ones that matter. If a check fires every week and the answer is always “yes, that is normal”, either fix the threshold or delete it.

Starting from nothing

What a three-person team should build first.

Everything above describes what a large company runs. Here is the honest minimum, in the order it pays off, and none of it needs a paid tool.

1. Make your logs machine-readable. One line per run, with the same fields every time — which pipeline, which run, how long, how many rows in and out, did it pass. Plain sentences in a log file are unsearchable; the same facts as structured fields turn a long afternoon into a query. Nothing else on this list works properly without it.
2. Count the rows at every step. Write down what went in and what came out of each stage. Most silent problems show up here first, as a number that is zero or ten times too big.
3. Check how recent your important tables are. Not all of them. The five people actually look at.
4. Send it all to one channel. One place, few enough messages that people still read them.

That is a few hours of work on top of whatever you already run, and it covers most of what the expensive platforms are sold for. The time to buy something is when you genuinely cannot keep the map in your head any more — not before.

The names

What you will hear these called.

dbt lineageIf your transformations are in dbt it already knows what feeds what, and will draw you the graph. For a small team this is often the entire answer, and you have it already.
OpenLineageAn open standard for pipelines to report what they read and wrote, so tools from different vendors can build one picture. Marquez is the open-source server that collects it. This is where to look when your pipelines are not all in one tool.
Column-level lineageThe same map, one level finer: not just “this table feeds that one” but “this column becomes that column”. Much more useful the day you need to rename something, and a good deal more work to keep accurate.
Observability platformsCommercial products that watch the four signals for you and learn what normal looks like. Genuinely good, genuinely priced like it. You will be fine without one for longer than the sales page suggests.

As with every tool list on this site: the map matters, not the thing that drew it. A graph on a whiteboard that is correct beats a generated one nobody trusts.

Three things that sound sensible

And quietly are not.

“We will draw the lineage when we need it.” The moment you need it is the moment you have the least time to make it, at four in the morning, from memory, under pressure. This is a thing you build on a calm Tuesday or do not have.
“Everything is monitored.” Usually means every job reports whether it finished. That is the one thing you already knew. Ask instead which tables would tell you if they stopped being fed — the answer is often none of them.
“The alert fired, so the system worked.” Only if somebody did something. An alert that fires into a channel nobody opens has the same value as no alert, and costs more, because it lets everyone believe they are covered.

If you get asked

“How do you find out when something has gone wrong?”

Almost everyone answers with the job status. Separate the two layers and you are instantly in a different conversation.

First, split watching the job from watching the table. A run can finish perfectly and load nothing, so the exit code is not the question. Say you watch the table itself: how recent it is, how many rows arrived, whether the columns are still what you expected, and whether the values are sane.

Then bring in the map, and say both directions. When something fires you step backwards through what feeds what until you reach the first place the data is already wrong — and then forwards, to find every dashboard, export and model standing on it, so you know who to warn before they act on it.

Then say the thing almost nobody says. That you would keep the number of alerts small enough that people still read them, because a hundred alerts and no response is worse than ten that get acted on.

Naming a tool at the end is fine. Naming one at the start is what the weak answer sounds like.

Two questions

Did it land?

A dashboard shows zero. You have lineage. What is the first move?

Your team gets 180 alerts a week and keeps missing real incidents. What helps most?

Your playbook · Case 05

Eight things to keep

  1. Lineage is just what feeds whatThe idea is trivial. Having it written down at four in the morning is not.
  2. Backwards to the causeStep from the symptom to whatever feeds it, until you reach the first place the data is already wrong. Everything above that is innocent.
  3. Forwards to the damageThen follow the arrows out. The thing that alerted you is rarely the only thing affected, and often not the worst.
  4. Warn people before they actExports and models that already ran have shipped wrong numbers. Those need a correction, not just a fix.
  5. Walk forwards before you change anything“This touches twenty three things” is the sentence that prevents the next incident.
  6. Watch four things about the tableHow recent, how much, what shape, and whether the values are sane — none of which a job status can tell you.
  7. Look before the run as well as afterA cheap check that the source has anything at all saves you processing an empty file beautifully.
  8. Fewer alerts get readPast a point, every alert you add makes the others less likely to be looked at. Delete the ones nobody acts on.

Your review

How was this case?

Loading ratings…

Next · Case 06

Who owns this table, and what does this column mean?

Case 06 is about governance: how a company with four thousand tables keeps them findable, owned and trusted — and what happens in the ones where nobody did.

Open Case 06 →← Case 04