Your dashboard shows correlations. Here's how to find what actually moves the metric.

The webinar that wasn't closing deals

A sales team noticed that leads who attended a product webinar closed at roughly twice the rate of leads who didn't. Tight correlation. Big sample. So they poured budget into webinars and pushed every open lead to attend.

Close rate didn't move.

What had actually happened: leads who were already serious — already leaning toward buying — were the ones who bothered to show up to a webinar and the ones who closed. Attendance was a symptom of intent, not a cause of it. The lukewarm leads who got dragged in sat through 40 minutes and bought at exactly the rate they would have anyway.

This happens every quarter, in product, marketing, and revenue teams. Two metrics move together, a deck gets built, a decision gets made, the decision doesn't work, and the post-mortem is uncomfortable. Dashboards are correlation machines. They're excellent at that. It is not the same job as telling you what causes what.

Why correlation fools smart people

Two variables correlate for exactly three structural reasons, and a correlation coefficient can't tell you which one you're looking at:

From a scatter plot, all three look identical. That's the whole problem.

Two variables can correlate for three reasons — A causes B, B causes A, or a hidden third variable causes both — and a scatter plot cannot tell them apart.

What causal discovery actually does

Causal discovery is a family of methods from statistics and computer science. Instead of looking at correlations one pair at a time, it looks at the pattern of conditional (in)dependencies across all your variables at once, and uses that pattern to propose a graph: which variables plausibly cause which.

The trick is that different structures leave different fingerprints. If X and Y are correlated but become independent once you control for Z, that says something specific about whether Z is a common cause or a step in between. Test enough of those relationships across the whole dataset and you can rule out a huge number of causal structures and keep a much smaller set of plausible ones.

The output is a graph with both directed and undirected edges — arrows where the data supports a direction, plain lines where it can't pick one. It is not proven truth. It's a set of defensible hypotheses with explicit uncertainty — which is strictly more than a correlation table gives you, and it's the honest description of the method.

A worked example: a marketing funnel

Here's the part most write-ups get wrong, so let's be precise.

We built a synthetic dataset — generated from a causal model we specified, so we know the right answer before running anything. Start with a clean linear funnel:

ad_spend → signups → activation → revenue

Generate a few thousand rows with realistic noise, hand the raw CSV to a causal-discovery algorithm with no hints, and here's what comes back:

(On data this clean and synthetic, a correct skeleton is expected — that's not the point. The point is to show what the algorithm reports about direction.)

That surprises people, but it's correct, and it's the most important thing to understand about this whole field. A pure chain A → B → C and its exact reverse C → B → A produce identical correlation patterns. So do all the in-between orderings that don't introduce a collision. When relationships are linear with bell-shaped noise, observational data — no matter how much of it — cannot tell a chain's direction apart. This is a proven result (Verma & Pearl, 1990), called Markov equivalence. (With skewed noise or curved relationships, more can be decided; that's a bonus when your data happens to have it, not something to count on.) An honest tool reports those edges as undirected instead of flipping a coin and drawing an arrow.

So how does any edge ever get a direction? You need a specific structure in the data: a collider — a variable with two causes that are independent of each other.

Add one more independent driver to the funnel — say organic_traffic, which also feeds signups and whose volume is set independently of ad_spend. Now the structure is ad_spend → signups ← organic_traffic, then signups → activation → revenue as before.

Now signups has two independent parents. That leaves a fingerprint the algorithm can detect: ad_spend and organic_traffic are unrelated on their own, but become related once you condition on signups. Only one orientation produces that pattern — both arrows pointing into signups. From there the rest of the chain is forced: pointing activation → signups would have to create a second collider the data doesn't show, so the only consistent orientation is outward — signups → activation → revenue. (This propagation step is standard; the rules are Meek's, 1995.)

One independent fork unlocked direction for the whole funnel. No fork, no direction. That's the entire game: you can recover a cause's direction exactly where your data contains the right structure, and not where it doesn't.

Real datasets are a mix. On data simulated from standard benchmark networks with known answers, some networks give plenty of directions and others give almost none: the connections are found, but the data doesn't contain the collider fingerprints needed to force a direction, so they stay undirected. That's not the tool being weak; that's the data being honest about what it can and can't support. (Our numbers per network are on the comparison page.)

And it isn't magic. With smaller samples and more variables, the algorithm can also miss a real edge or invent a spurious one — conditional-independence tests get noisier as data thins. Treat results on small samples as low-confidence starting points, not conclusions.

The limits worth knowing before you trust any of this

Three things to know before trusting any causal-discovery output — ours or anyone's:

Observational data has a hard ceiling. With linear, bell-shaped data, some graph structures are provably indistinguishable without an experiment (that's the Markov equivalence above). No tool beats this, because no tool can. Anyone claiming to "find the true causal graph" from observational data alone is overselling.

Unmeasured confounders are a real risk. If something you didn't record drives two things you did, a method that assumes all causes are measured will draw an edge between your two variables instead of pointing at the hidden cause. On larger files (5,000+ rows) DAGsight allows for this and leaves such directions open, but that's a partial safeguard, not a guarantee. Knowing which variables to include matters enormously. Garbage in, confident-looking graph out.

Sample size is real. Causal discovery on 300 rows and 20 variables is a bad idea. As a rough heuristic, aim for at least 10–20× as many rows as variables — more if the data is noisy.

None of this makes the method useless — it makes it honest. A correlation table has every one of these limits too and doesn't tell you about them. Causal discovery at least surfaces where the uncertainty lives.

How to actually use it

Use it as a hypothesis-narrowing tool, not an answer machine.

You want to move revenue. The graph says activation sits right before it; ad_spend and organic_traffic feed signups, which feeds activation. Where the graph leaves an edge undirected, that's your flag: run an experiment there before committing budget. Where it's confidently directed, you have a ranked shortlist of where leverage plausibly lives.

You've gone from "anything could be moving revenue" to "here are the four most defensible places to look, and here's the one we need to A/B test properly." That's a real compression of uncertainty — and you got it before pouring a quarter's budget into the next webinar push that turns out to be a symptom, not a cause.

On accuracy, to be plain: we test the engine on standard benchmark networks and on simulated data where the true causes are known. The arrows it draws point the right way about 90–100% of the time, depending on data size and on whether causes were hidden, and links it can't orient stay undirected instead of guessed. Direction is still limited by what observational data can show, for any tool. The numbers and the assumptions behind them are on our assumptions and limits page. We publish that because the honesty is the point.

So why not just do this yourself in Python? If you're comfortable there, the open-source libraries are genuinely good. DAGsight is the hosted, no-code version for people who'd rather upload a CSV than pip-install a stats stack, choose an algorithm, clean the data by hand, and squint at a matplotlib plot: it picks the approach for your data's shape, scores how stable each edge is across re-runs, and draws the graph — directed and undirected edges and all. None of the setup.

Related: if you build predictive models, see why feature importance isn't causation — the same trap, wearing a SHAP plot.

Try it

DAGsight does exactly this from a CSV in about a minute — upload your data, get a causal graph back with confidence scores and honest undirected edges where the data can't decide. Free tier, no card required: start here.