Correlation is not causation, but it's also not nothing: reading correlation matrices right - The Official Site Of NAIT (Native AI Teams)

LEARN · EXPLORATORY DATA ANALYSIS & STATISTICS

Why correlation matrices are useful — and why they are so easy to misread

A correlation matrix is one of the fastest ways to get a rough map of a numeric dataset.

Give pandas a table with ten numeric columns, and one method call can tell you which pairs tend to move together, which tend to move in opposite directions, and which show little linear relationship at all. Turn that matrix into a heatmap, and patterns that would be tedious to find manually become visible almost immediately.

That convenience is exactly why correlation matrices deserve care.

A cell showing 0.92 looks authoritative. It is precise to two decimal places, appears in a neat grid, and may be painted an alarming color. But the number answers a much narrower question than people often assume.

A high correlation does not automatically mean:

one variable causes the other;
the relationship will continue in the future;
the association is useful for prediction;
there are no important outliers;
the relationship is linear in a meaningful way;
the result is statistically reliable;
another variable is not driving both;
the correlation was calculated from the same observations as neighboring cells.

At the same time, dismissing every correlation with “correlation isn’t causation” throws away useful information.

Correlation is evidence of association. Association can reveal redundancy, data-quality problems, shared drivers, useful predictive signals, suspicious leakage, or hypotheses worth investigating.

The trick is learning to ask exactly what a correlation matrix can tell you — and what it cannot.

What a correlation coefficient actually measures

The most common number in a correlation matrix is the Pearson correlation coefficient.

Pearson correlation measures the strength and direction of a linear association between two variables.

Its value lies between -1 and 1.

A rough interpretation is:

r = 1: perfect positive linear relationship.
r = -1: perfect negative linear relationship.
r = 0: no linear relationship.
Values near 1 or -1: stronger linear association.
Values near 0: weaker linear association.

Conceptually, Pearson correlation is:

r = covariance(x, y) / (standard deviation of x × standard deviation of y)

The division by the standard deviations is important. Covariance depends on units; correlation does not.

If you convert revenue from dollars to cents, for example, the covariance changes dramatically. Pearson correlation does not.

That makes correlation convenient for comparing variables with wildly different units.

Consider an e-commerce dataset containing:

website sessions;
advertising spend;
number of orders;
revenue;
average discount;
support tickets.

Revenue might be measured in dollars, sessions in thousands of visits, and discounts as fractions. Correlation lets us examine their linear associations on the same standardized scale.

But the phrase linear association deserves emphasis.

A coefficient near zero does not necessarily mean “these variables are unrelated.”

They could have a powerful nonlinear relationship.

For example, suppose:

y = x²

Negative and positive values of x can cancel each other when Pearson correlation is calculated, even though y is completely determined by x.

You can see that directly:

import numpy as np

rng = np.random.default_rng(42)

x = rng.uniform(-3, 3, 20_000)
y = x**2

correlation = np.corrcoef(x, y)[0, 1]

print(f"Pearson correlation: {correlation:.4f}")

You should get a correlation reasonably close to zero.

Yet knowing x tells you exactly what y is.

That gives us our first major rule:

A small Pearson correlation means weak linear association, not necessarily weak association of every kind.

Pearson, Spearman, and Kendall are answering different questions

Pearson is not the only correlation available.

Current pandas provides DataFrame.corr() with Pearson, Spearman, and Kendall methods, as well as support for a custom callable. The current API also supports min_periods, and pandas computes these correlations using pairwise complete observations.

The three built-in approaches are useful for different situations.

Pearson correlation

Use Pearson when you care about linear relationships.

If advertising spend rises by roughly proportional amounts as impressions rise, Pearson is a natural first measure.

Pearson is sensitive to extreme points because those points can have enormous influence on covariance.

Spearman correlation

Spearman correlation first turns observations into ranks.

It therefore measures whether two variables have a consistent monotonic relationship rather than specifically a straight-line relationship.

Suppose delivery time improves steadily as warehouse automation increases, but improvements flatten out at high automation levels.

The curve may not be linear, but higher automation still tends to correspond to better delivery times. Spearman can capture that ordering.

Kendall correlation

Kendall’s tau also works with ordering. Conceptually, it examines whether pairs of observations are concordant or discordant.

It can be useful for ordinal data and ranking relationships.

With pandas, comparing all three requires very little code:

import pandas as pd

df = pd.DataFrame(
    {
        "page_views": [10, 20, 30, 40, 50, 60, 70, 80],
        "orders": [2, 3, 5, 8, 12, 18, 27, 39],
        "returns": [1, 1, 2, 1, 3, 2, 4, 3],
    }
)

pearson = df.corr(method="pearson")
spearman = df.corr(method="spearman")
kendall = df.corr(method="kendall")

print("Pearson")
print(pearson)

print("\nSpearman")
print(spearman)

print("\nKendall")
print(kendall)

If Pearson and Spearman differ substantially for a pair of variables, do not automatically decide that one is “correct.”

Investigate the shape of the data.

The disagreement itself is information.

Building a runnable correlation heatmap

Let’s build something more realistic.

We will generate a synthetic e-commerce dataset. Using synthetic data makes this example fully reproducible and avoids requiring an external download.

Create an environment and install the required packages:

python -m venv .venv

On macOS or Linux:

source .venv/bin/activate
python -m pip install pandas numpy matplotlib seaborn

On Windows PowerShell:

.venv\Scripts\Activate.ps1
python -m pip install pandas numpy matplotlib seaborn

Now create a script:

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns

rng = np.random.default_rng(2026)
n_days = 365

ad_spend = rng.normal(5_000, 1_100, n_days).clip(1_000)
organic_sessions = rng.normal(8_000, 1_500, n_days).clip(2_000)

paid_sessions = (
    ad_spend * 1.7
    + rng.normal(0, 1_800, n_days)
).clip(0)

total_sessions = (
    organic_sessions
    + paid_sessions
    + rng.normal(0, 500, n_days)
).clip(0)

conversion_rate = (
    0.025
    + rng.normal(0, 0.004, n_days)
).clip(0.005, 0.08)

orders = (
    total_sessions * conversion_rate
    + rng.normal(0, 15, n_days)
).clip(0)

average_order_value = rng.normal(72, 8, n_days).clip(30)

revenue = (
    orders * average_order_value
    + rng.normal(0, 1_500, n_days)
).clip(0)

support_tickets = (
    orders * 0.06
    + rng.normal(0, 5, n_days)
).clip(0)

discount_rate = rng.uniform(0.02, 0.25, n_days)

df = pd.DataFrame(
    {
        "ad_spend": ad_spend,
        "organic_sessions": organic_sessions,
        "paid_sessions": paid_sessions,
        "total_sessions": total_sessions,
        "conversion_rate": conversion_rate,
        "orders": orders,
        "average_order_value": average_order_value,
        "revenue": revenue,
        "support_tickets": support_tickets,
        "discount_rate": discount_rate,
    }
)

corr = df.corr(method="pearson", numeric_only=True)

mask = np.triu(np.ones_like(corr, dtype=bool), k=1)

plt.figure(figsize=(11, 9))

sns.heatmap(
    corr,
    mask=mask,
    annot=True,
    fmt=".2f",
    vmin=-1,
    vmax=1,
    center=0,
    cmap="vlag",
    square=True,
    linewidths=0.5,
)

plt.title("E-commerce correlation matrix")
plt.tight_layout()
plt.savefig("correlation_heatmap.png", dpi=150)
plt.show()

Seaborn’s current heatmap() API accepts a pandas DataFrame directly, uses its row and column labels, and supports parameters such as annot, mask, vmin, vmax, center, and square, which are exactly what we need for this kind of visualization.

Why the heatmap is configured this way

The visualization code contains several decisions worth understanding.

Fix the scale from -1 to 1

We use:

vmin=-1,
vmax=1,
center=0,

Correlation coefficients always live in that range, so the color scale should reflect the entire meaningful range.

Without fixed limits, automatic color scaling can make a matrix containing correlations from -0.2 to 0.3 look visually much more dramatic than it really is.

Show the number as well as the color

We use:

annot=True,
fmt=".2f",

Color is excellent for pattern recognition.

Numbers are better for distinguishing 0.61 from 0.89.

Use both.

Hide one triangle

A standard correlation matrix is symmetric.

If the correlation between orders and revenue is 0.91, then the correlation between revenue and orders is also 0.91.

Showing both halves wastes space.

This creates an upper-triangle mask:

mask = np.triu(np.ones_like(corr, dtype=bool), k=1)

The result is easier to scan without removing information.

How to read a correlation matrix systematically

Do not start by hunting for the darkest square.

Use a repeatable process.

1. Ignore the diagonal

Every variable is perfectly correlated with itself.

That is why the diagonal is full of 1.00.

It tells you essentially nothing.

2. Look at the sign

Positive correlation means larger values of one variable tend to accompany larger values of the other.

Negative correlation means larger values of one tend to accompany smaller values of the other.

The sign is about direction, not whether a relationship is “good” or “bad.”

A negative relationship between server capacity and latency might be desirable.

A positive relationship between error rate and customer complaints might be undesirable.

Statistics does not know your business objective.

3. Examine magnitude

An absolute correlation of 0.9 represents a stronger linear association than an absolute correlation of 0.2.

But avoid universal rules such as:

0.0–0.3 = weak;
0.3–0.7 = moderate;
0.7–1.0 = strong.

Those labels can be convenient descriptions, but their practical meaning depends heavily on the domain.

A correlation of 0.15 can matter in a noisy system with millions of observations.

A correlation of 0.80 can be useless if it is produced by leakage.

Context wins.

4. Identify clusters

The most interesting feature of a matrix is often not one cell but a group of highly related variables.

In our synthetic store, you might find a cluster containing:

paid sessions;
total sessions;
orders;
revenue;
support tickets.

That should make intuitive sense because the variables are connected through the way we generated the data.

Clusters can reveal several things in real datasets:

measurements of the same underlying process;
duplicated or near-duplicated features;
multiple proxies for the same hidden factor;
stages of a business funnel;
potential multicollinearity in some statistical models.

A cluster is a prompt to investigate structure, not merely a collection of impressive coefficients.

Never stop at the heatmap: draw the points

One of the most important habits in exploratory data analysis is simple:

When a correlation matters, inspect its scatterplot.

A single number compresses an entire geometric pattern into one scalar.

That compression can destroy crucial information.

And there is a famous demonstration of exactly how badly that can go.

The Anscombe-style warning: almost identical numbers, wildly different pictures

Consider these four datasets.

They have nearly identical means, variances, regression lines, and Pearson correlations when rounded to the usual precision.

Their plots are dramatically different.

import matplotlib.pyplot as plt
import numpy as np

datasets = {
    "A": (
        np.array([10, 8, 13, 9, 11, 14, 6, 4, 12, 7, 5], dtype=float),
        np.array([8.04, 6.95, 7.58, 8.81, 8.33, 9.96, 7.24, 4.26, 10.84, 4.82, 5.68]),
    ),
    "B": (
        np.array([10, 8, 13, 9, 11, 14, 6, 4, 12, 7, 5], dtype=float),
        np.array([9.14, 8.14, 8.74, 8.77, 9.26, 8.10, 6.13, 3.10, 9.13, 7.26, 4.74]),
    ),
    "C": (
        np.array([10, 8, 13, 9, 11, 14, 6, 4, 12, 7, 5], dtype=float),
        np.array([7.46, 6.77, 12.74, 7.11, 7.81, 8.84, 6.08, 5.39, 8.15, 6.42, 5.73]),
    ),
    "D": (
        np.array([8, 8, 8, 8, 8, 8, 8, 19, 8, 8, 8], dtype=float),
        np.array([6.58, 5.76, 7.71, 8.84, 8.47, 7.04, 5.25, 12.50, 5.56, 7.91, 6.89]),
    ),
}

for name, (x, y) in datasets.items():
    correlation = np.corrcoef(x, y)[0, 1]
    slope, intercept = np.polyfit(x, y, 1)

    print(
        f"{name}: "
        f"correlation={correlation:.3f}, "
        f"line=y={slope:.3f}x+{intercept:.3f}"
    )

    plt.figure(figsize=(6, 4))
    plt.scatter(x, y)

    x_line = np.linspace(x.min(), x.max(), 100)
    y_line = slope * x_line + intercept
    plt.plot(x_line, y_line)

    plt.title(f"Dataset {name}: r = {correlation:.3f}")
    plt.xlabel("x")
    plt.ylabel("y")
    plt.tight_layout()
    plt.savefig(f"anscombe_{name.lower()}.png", dpi=150)
    plt.show()

All four correlations round to about 0.816.

Yet visually:

Dataset A resembles the relationship you might expect from the summary.
Dataset B contains a strong curved pattern.
Dataset C is heavily influenced by one unusual point.
Dataset D is essentially a vertical stack plus one influential observation.

If all you received were the correlation coefficients, you could easily treat these datasets as equivalent.

They are not.

This is why scatterplots are not decorative accessories to a correlation analysis. They are part of the analysis.

Outliers can manufacture correlation

Pearson correlation is particularly vulnerable to influential observations.

Imagine most of your observations look like random noise:

x: scattered between 10 and 20
y: scattered between 40 and 60

Then one observation appears:

x = 500
y = 1200

That point can exert enormous leverage on the covariance and therefore on Pearson correlation.

You may end up with a respectable-looking coefficient even though the bulk of the data contains little useful linear relationship.

When you encounter a surprisingly high correlation, ask:

Is it present across the whole range?
Is one point creating it?
Are there multiple clusters?
Does removing a single observation transform the result?
Is the relationship actually curved?

Do not automatically delete an influential observation. It may be the most important observation in your dataset.

Investigate it.

Missing data creates a quieter problem

Correlation matrices can also be misleading when columns contain different missing values.

Current pandas documentation specifies that correlations are calculated using pairwise complete observations.

That means two cells in the same correlation matrix might have been calculated from different subsets of rows.

Suppose you have:

50,000 observations for sessions;
49,500 for orders;
only 300 observations for customer-acquisition cost.

The correlation between sessions and orders could use tens of thousands of observations, while a neighboring correlation involving acquisition cost could use only a few hundred.

They still appear as equally sized cells in your heatmap.

One useful diagnostic is to calculate the number of shared non-missing observations for every pair:

import numpy as np
import pandas as pd

rng = np.random.default_rng(42)

df = pd.DataFrame(
    {
        "sessions": rng.normal(10_000, 1_500, 100),
        "orders": rng.normal(300, 40, 100),
        "revenue": rng.normal(25_000, 4_000, 100),
    }
)

df.loc[rng.choice(df.index, 20, replace=False), "orders"] = np.nan
df.loc[rng.choice(df.index, 60, replace=False), "revenue"] = np.nan

numeric = df.select_dtypes(include="number")

present = numeric.notna().astype("int32")
pair_counts = present.T.dot(present)

correlations = numeric.corr(
    method="pearson",
    min_periods=30,
)

print("Correlations")
print(correlations)

print("\nShared observations")
print(pair_counts)

The min_periods argument lets you refuse to calculate correlations when too few paired observations are available. In current pandas, it applies to Pearson and Spearman correlations.

That is often much safer than displaying a dramatic coefficient based on a tiny overlap.

Correlation can appear because both variables share a trend

Time series deserve special suspicion.

Suppose:

the number of customers grows every month;
infrastructure spending grows every month;
coffee consumed by the engineering team grows every month.

All three may correlate strongly.

That does not imply coffee purchases are driving customer growth.

They may simply share an upward trend.

This happens constantly with:

inflation;
company size;
population;
internet adoption;
cumulative totals;
long-term technological growth;
seasonal cycles.

If two variables both rise over time, their raw correlation can mostly measure the passage of time.

For time-series data, consider examining:

first differences;
percentage changes;
detrended values;
seasonal adjustments;
lagged relationships;
correlations calculated within narrower windows.

The correct method depends on the question.

A raw correlation matrix is not automatically wrong for time-series data, but it can be answering a much less interesting question than you think.

Correlation cannot distinguish cause from a common cause

Imagine you find a strong positive correlation between advertising spend and revenue.

One tempting interpretation is:

Advertising causes higher revenue.

That could be true.

But another possibility is:

The company spends more on advertising during periods when it already expects high demand.

A third variable — expected demand — now helps explain both.

Or perhaps seasonality causes both:

holiday season
    ├── higher advertising spend
    └── higher revenue

The raw correlation between advertising and revenue cannot choose between these explanations.

This is the classic confounding problem.

Other causal traps include:

reverse causality: revenue increases the advertising budget;
selection bias: your dataset contains only successful campaigns;
common trends: both variables increase over time;
measurement artifacts: both are calculated from the same underlying number;
data leakage: one feature accidentally contains future or target information.

Correlation is often the beginning of a causal question, not the answer.

But correlation is still useful

None of this makes correlation useless.

Quite the opposite.

A correlation matrix is excellent for exploration.

Finding redundant features

If two sensor variables correlate at 0.999, perhaps they are measuring nearly the same physical quantity.

You should investigate whether both are needed.

Detecting leakage

Imagine building a machine-learning model to predict an order’s final revenue, and you discover a feature called invoice_total correlates with the target at 0.9998.

Congratulations — or perhaps not.

The feature may contain essentially the answer you are trying to predict.

An extreme correlation can be a data-quality alarm.

Finding unexpected relationships

Maybe refund rate strongly correlates with shipping delay.

That does not prove delayed shipping causes refunds, but it gives you a concrete hypothesis worth testing.

Checking feature engineering

Suppose you created:

revenue_per_session = revenue / sessions

You would expect the engineered variable to relate to some of its inputs.

A matrix helps verify that derived columns behave approximately as intended.

Understanding multicollinearity

Strongly correlated predictors can make coefficient estimates unstable in some regression settings.

Correlation matrices provide a useful first warning, although pairwise correlation alone does not fully diagnose multicollinearity involving combinations of multiple variables.

In other words:

Correlation is a screening tool, not a verdict.

A cherry on the cake: the distracted-boyfriend meme apparently hired statisticians

Tyler Vigen’s continuously available Spurious Correlations collection is one of the funniest ways to demonstrate the danger of discovering a number first and inventing a story afterward.

Among the correlations currently listed is this glorious pairing:

Popularity of the “distracted boyfriend” meme vs. the number of statisticians in New Jersey.

The collection reports a correlation of about 0.96 across 17 years.

A correlation of 0.96 would look spectacular in a heatmap.

If the column names were anonymized as feature_17 and feature_42, someone might immediately flag the pair as a major discovery.

But once you see the actual labels, the causal story becomes rather difficult to defend.

Did New Jersey employ more statisticians because people enjoyed a stock photo of a man looking over his shoulder?

Did professional statisticians somehow increase worldwide appreciation for distracted-boyfriend memes?

Probably not.

The point of Vigen’s collection is not that correlation coefficients are defective. The project itself describes these as deliberately silly correlations intended to demonstrate what can happen when unrelated variables are matched by their numerical behavior.

The deeper lesson is about search.

If you inspect enough possible relationships, some will look extraordinary by chance.

With 100 numeric variables, you do not have 100 possible pairwise relationships.

You have:

100 × 99 / 2 = 4,950

With 1,000 columns:

1,000 × 999 / 2 = 499,500

Search half a million pairs and “Wow, look at this correlation!” becomes a much weaker argument.

This is the multiple-comparisons problem in exploratory clothing.

The more relationships you search, the more cautious you should be about treating the most extreme one as meaningful.

Correlation magnitude is not effect size in business units

Another common mistake is treating a coefficient as though it tells you how much one variable changes when another changes.

It does not.

A correlation of 0.8 does not mean:

Increasing X by 10% increases Y by 8%.

Correlation is dimensionless.

If you need a statement about expected changes in the original units, you are moving toward regression or another explicit statistical model.

Even then, a regression coefficient does not magically become causal. The model still inherits the identification assumptions behind your analysis.

Think of the tasks separately:

Correlation: “How strongly do these variables move together?”
Regression: “How does an outcome statistically vary with predictors?”
Prediction: “Can these variables help predict unseen outcomes?”
Causal inference: “What would happen to Y if we intervened on X?”

Those are related questions.

They are not interchangeable.

Strong correlation does not guarantee predictive value

Suppose temperature and electricity use correlate strongly in a historical dataset.

That sounds predictive.

But prediction depends on more than historical correlation.

Ask:

Will the relationship remain stable?
Will the predictor be available at prediction time?
Does the test period follow the same distribution?
Is the relationship already captured by other features?
Is the correlation driven by one season?
Are you accidentally using information from the future?

Likewise, a feature with weak marginal correlation can still be highly predictive when combined with other variables.

Consider an interaction:

target depends strongly on x1 × x2

Neither x1 nor x2 may have an impressive individual linear correlation with the target.

A machine-learning model that captures interactions might nevertheless use them very effectively.

Do not use a correlation matrix as an automatic feature-selection machine.

Sorting correlations can be useful — with one warning

When a dataset has dozens of columns, a heatmap can become unreadable.

You can instead rank variables by their correlation with one target.

import numpy as np
import pandas as pd

rng = np.random.default_rng(7)
n = 500

sessions = rng.normal(12_000, 2_000, n)
conversion_rate = rng.normal(0.03, 0.006, n).clip(0.005, 0.08)
orders = sessions * conversion_rate + rng.normal(0, 20, n)
average_order_value = rng.normal(75, 10, n)
revenue = orders * average_order_value + rng.normal(0, 1_500, n)
random_feature = rng.normal(0, 1, n)

df = pd.DataFrame(
    {
        "sessions": sessions,
        "conversion_rate": conversion_rate,
        "orders": orders,
        "average_order_value": average_order_value,
        "revenue": revenue,
        "random_feature": random_feature,
    }
)

target_correlations = (
    df.corr(numeric_only=True)["revenue"]
    .drop("revenue")
    .sort_values(key=np.abs, ascending=False)
)

print(target_correlations)

This is useful for exploration.

But remember what you have done: you searched all variables and sorted them specifically to put the largest coefficients first.

That ranking procedure guarantees that the top of the list looks interesting.

The right response is not to distrust it completely. It is to validate what you find.

A practical checklist for every suspiciously interesting cell

Suppose your matrix shows:

feature_a vs feature_b: r = 0.87

Before turning that into a slide saying “Feature A drives Feature B,” run through this checklist.

Check the raw data

Ask:

Are the units sensible?
Are missing values encoded correctly?
Are zeros genuine zeros?
Are sentinel values such as -999 present?
Were categories accidentally converted to arbitrary numbers?

Check the sample size

A coefficient calculated from 12 observations deserves different confidence than one calculated from 120,000.

Sample size does not magically make a biased relationship causal, but it matters for uncertainty.

Plot the relationship

Use a scatterplot.

Look for:

curvature;
outliers;
separate clusters;
heteroskedasticity;
ceiling effects;
floor effects;
suspicious gaps.

Compare Pearson and Spearman

If Pearson is large but Spearman is much smaller, influential points may be involved.

If Spearman is strong while Pearson is weaker, the relationship may be monotonic but nonlinear.

Ask whether time explains both

Plot each variable over time.

Two upward trends can produce a compelling correlation without a useful direct relationship.

Search for common causes

What variables could plausibly influence both?

Domain knowledge matters here.

Look for leakage

Could one column be calculated from the other?

Could it contain future information?

Could both be constructed from the same underlying measurement?

Ask how many relationships you searched

One prespecified hypothesis and 20,000 exploratory correlations are not equivalent evidential situations.

Validate on other data

Does the relationship survive:

another time period;
another geographic region;
another customer segment;
a held-out dataset?

Replication turns an interesting pattern into much stronger evidence.

Better language for reporting correlations

The words you use matter.

Suppose customer support volume and order volume have a correlation of 0.78.

Avoid:

More orders cause more support tickets.

Unless you actually have a causal design, that statement goes beyond the evidence.

Prefer:

Order volume and support-ticket volume were strongly positively associated in this dataset.

Then add interpretation separately:

One plausible explanation is that higher transaction volume creates more opportunities for support requests, but other shared factors such as seasonality should be investigated.

That wording may feel more cautious, but it is also more useful. It separates:

what the data directly shows;
what you believe might explain it.

That distinction is the heart of good statistical reasoning.

Why “correlation is not causation” is only half the lesson

The slogan is valuable because people constantly overclaim causal relationships.

But repeated carelessly, it can become an excuse to stop thinking.

Suppose two production metrics suddenly move from a historical correlation near zero to 0.94.

Should you respond:

Correlation isn’t causation, so ignore it.

Of course not.

You should investigate.

Perhaps:

a software deployment coupled two services;
a sensor began duplicating another signal;
a new queueing bottleneck appeared;
a metric definition changed;
a shared dependency began failing;
one field is now being copied incorrectly.

Correlation may not tell you the mechanism.

It can still tell you that something changed.

That is why the better mental model is:

Correlation is not causation, but association is evidence that deserves an appropriate next question.

Sometimes the next question is causal.

Sometimes it is predictive.

Sometimes it is simply, “Did our data pipeline break?”

A compact workflow you can actually use

When you receive a new tabular dataset, a sensible beginner workflow looks like this:

Identify the numeric variables and understand their units.
Inspect missingness and obvious data-quality problems.
Compute a Pearson correlation matrix.
Visualize it with a fixed -1 to 1 scale.
Find notable positive, negative, and near-zero relationships.
Check how many observations contributed to important cells.
Plot important variable pairs.
Compare Pearson with Spearman where nonlinear or outlier-sensitive behavior is plausible.
Check time trends and segmentation.
Develop domain explanations for interesting relationships.
Look deliberately for confounding, leakage, and selection effects.
Validate important findings on fresh or held-out data.
Use causal language only when your design supports causal conclusions.

The correlation matrix is therefore not the conclusion of exploratory analysis.

It is a navigation map.

It tells you where to look.

The takeaway

A correlation matrix compresses a remarkable amount of information into a small space, which is both its strength and its danger.

Read it correctly and it can help you:

discover structure;
detect redundant measurements;
identify possible leakage;
generate hypotheses;
prioritize plots and deeper analyses;
spot unusual changes in a system.

Read it carelessly and the same matrix can encourage you to:

confuse association with causality;
miss nonlinear relationships;
overlook outliers;
compare coefficients based on different samples;
mistake common trends for direct relationships;
discover impressive-looking accidents after searching thousands of pairs.

The most important habit is simple:

Never let the heatmap have the last word.

Pick an interesting cell. Check the observations behind it. Draw the scatterplot. Inspect time and subgroups. Compare alternative correlation measures. Ask what mechanism could generate the relationship — and what other mechanisms could generate exactly the same number.

Then take your own dataset, build the heatmap from this tutorial, and choose the three strongest correlations. For each one, write down one plausible causal explanation, one plausible non-causal explanation, and one plot or experiment that would help distinguish between them.

That exercise is where reading correlation matrices turns from a visualization trick into statistical reasoning.

Correlation is not causation, but it’s also not nothing: reading correlation matrices right