This is not a ranking and not a catalogue: these are the books I actually use, the ones many of the examples and explanations in the articles come from. Few of them, chosen with a simple criterion: each book must let anyone working with data in SEO and marketing take one concrete step forward, without requiring a degree in mathematics.

A note on transparency before we start: the links below are Amazon affiliate links. If you buy a book through them, the blog receives a small commission at no extra cost to you: it is the most painless way I have found to cover the server bills.

Where to Start

The Art of Statistics — David Spiegelhalter

If I could keep only one, it would be this. The Art of Statistics does not teach formulas: it teaches how to reason about data before trusting it, which is exactly the skill missing when someone reads a Search Console report and jumps to conclusions. Spiegelhalter — a Cambridge professor and a science communicator of rare clarity — builds every chapter around a real case: botched polls, misread medical statistics, the famous Berkeley admissions case (the same case I told when discussing Simpson’s Paradox).

I cite it practically everywhere on this blog: from sampling to confidence intervals, by way of the Central Limit Theorem. You can read it without pen and paper, and re-read it with profit. (For Italian readers there is also an excellent Italian edition, L’arte della statistica.)

Finalmente ho capito la statistica — Maurizio De Pra

The title says it all (“statistics, I finally got it”). Finalmente ho capito la statistica (Italian edition) is the book for absolute beginners who want a gradual path, plenty of examples and a modest price. It covers the territory of probability distributions well — the ones this blog’s path takes from the Poisson to the Beta — together with the foundations of probabilistic reasoning. It does not replace a textbook, but it does what a textbook cannot: it takes the fear away.

When Data Lies

How to Lie with Statistics — Darrell Huff

Written in 1954 and never aged. How to Lie with Statistics is the short, venomous catalogue of the tricks numbers can be made to play: biased samples, conveniently chosen averages, truncated chart axes, percentages stripped of their context. Huff wrote for newspaper readers; I recommend it to anyone reading SEO tool reports and vendor slide decks, where those very tricks are alive and well. If you have been through Simpson’s Paradox you already know that aggregate data can lie: Huff completes the picture with all the other ways.

You can read it in an afternoon, and from that afternoon on you never look at a chart the same way again. (Italian readers can find it as Mentire con le statistiche.)

The Textbook for Getting Serious: Inference

Statistica — Newbold, Carlson, Thorne

Sooner or later the moment comes when popular science is not enough: you want the applicability conditions of a test, the complete formulas, the exercises to check you understood. Statistica by Newbold, Carlson and Thorne (Italian edition) is the reference university textbook for the whole of inference: hypothesis testing, confidence intervals, chi-square, ANOVA — in practice, the theoretical backbone of my guide to statistical tests for A/B analysis.

Let me be frank: it is a university textbook, and it costs like one. But it is one of those books you buy once and consult for years.

Regression, Time Series, Models

Introduzione all’econometria — Stock, Watson

The name may be intimidating (econometrics?), but the content is exactly what anyone needs to go beyond basic linear regression: multiple regression, omitted variables, diagnostics, time series. Introduzione all’econometria by Stock and Watson (Italian edition; the English original is Introduction to Econometrics) has a quality that is rare in textbooks: a constant focus on the interpretation of results, not just their computation. Which is, after all, where the difference between a useful analysis and an exercise in style is decided.

The (Fallible) Art of Prediction

The Signal and the Noise — Nate Silver

Anyone working with data sooner or later has to make a forecast — and an estimate of next quarter’s organic traffic is a forecast in every respect. The Signal and the Noise tells the story of why predictions fail so often: too much faith in models, the temptation to mistake noise for signal, the inability to reason in probabilities. Silver — the man who called the 2012 US presidential election right in all fifty states — moves through poker, earthquakes, weather and finance, and along the way delivers the best narrative introduction to Bayesian reasoning I know of. It is the popular companion to the time series chapter: first you learn to build a forecast, then you learn to distrust it. (There is also an Italian edition: Il segnale e il rumore.)

Online Experimentation

Trustworthy Online Controlled Experiments — Kohavi, Tang, Xu

On A/B testing there is simply no equivalent: Trustworthy Online Controlled Experiments is the book on the subject, written by the people who led experimentation at Microsoft, Google and LinkedIn. Inside is everything I have touched in these articles — sample size, test power, mistakes to avoid — plus ten years of real-world cases about what goes wrong in actual experiments. I also used it to build my sample size calculator. Very readable.

The Bayesian Path

Bayesian Statistics the Fun Way — Will Kurt

Bayesian statistics has a reputation for being hard, and its textbooks do their best to confirm it. Bayesian Statistics the Fun Way does the opposite: Will Kurt explains priors, posteriors and Bayesian updating with examples taken from Star Wars and Lego bricks, and — something I particularly appreciate — uses R for the computational side, exactly as I do here. It is the right book for grasping the Bayesian logic (and the reason behind the Beta distribution) before tackling the formal theory.

Towards Machine Learning

An Introduction to Statistical Learning — James, Witten, Hastie, Tibshirani

The contemporary classic of statistical learning, known to everyone as “ISL”. An Introduction to Statistical Learning covers, with the right balance of intuition and formalism, the topics of the more advanced part of this path: logistic regression, decision trees, PCA, with hands-on labs in R. N.b.: the authors distribute the PDF for free from their website — the printed edition remains for those who, like me, prefer to annotate study books in pencil.

Introduction to Machine Learning — Ethem Alpaydın

For those who want the theoretical foundations of machine learning — the ones that in a university course would come before the labs — Introduction to Machine Learning by Alpaydın is the reference I cited in my introductory guide to ML. More formal than ISL: one to pick up after it, not instead of it.

The Working Language: R

R for Data Science — Wickham, Çetinkaya-Rundel, Grolemund

There was an obvious gap on this shelf: R code shows up in nearly every article of this blog — from the chi-square test to time series — but the book to learn the language from was missing. R for Data Science (second edition) fills the gap: Hadley Wickham is the author of the tidyverse, the package ecosystem that made R modern, and the book teaches the whole workflow — import, tidy, transform, visualise, communicate — on real data, with no superfluous theory. Like ISL, it can be read for free on the authors’ website: one more reason to have no excuses.

Communicating Data

Storytelling with Data — Cole Nussbaumer Knaflic

The most rigorous analysis in the world is worth little if the person receiving it does not understand it — and in marketing an analysis almost always has to be told to someone: a client, a manager, a meeting. Storytelling with Data teaches how to turn the default charts of Excel and Looker Studio into clear messages: choosing the right chart, removing the ink that carries no information, directing attention where it matters, building a narrative around the number. Of the whole shelf it is probably the book that pays for itself fastest: you can apply it to your very next report. (There is also an Italian edition, Data storytelling, published by Apogeo.)

A Niche Read

Monte Carlo Methods in Financial Engineering — Paul Glasserman

This is the most specialised book on the shelf, and I list it out of honesty towards anyone who has reached the Monte Carlo method and wants to go all the way: Monte Carlo Methods in Financial Engineering by Glasserman is the complete reference on simulation applied to finance. Not a beach read: it is the text you reach for when the others are no longer enough.

The Library at a Glance

To get your bearings quickly, here is the complete shelf in table form:

This shelf is not closed. As the blog’s path widens — the statistical paradoxes I have started to explore, the bootstrap, text analysis — the library will widen too, and this page will be updated accordingly. In the meantime, if one single recommendation had to suffice: start with Spiegelhalter, and let the articles on this blog be your gym.

Before writing the bad-news email and bracing ourselves to justify the drop, let’s do the right thing: disaggregate the data to understand where we’re losing ground. We look at performance by device and discover something seemingly impossible:

• CTR on Desktop rose from 5.0% to 5.5%.
• CTR on Mobile rose from 2.0% to 2.5%.

We stare at the screen. How is it mathematically possible that performance improved everywhere, yet the overall total dropped by a full percentage point?

We haven’t broken Google Search Console, and we haven’t forgotten elementary-school arithmetic. We’ve simply just fallen victim to Simpson’s Paradox.

What we’ll cover:

• What Is Simpson’s Paradox
• The Proof: Anatomy of a Fake Collapse
• Two More SEO Scenarios Where the Paradox Strikes
• How to Defend Yourself
• Further Reading

What Is Simpson’s Paradox

Simpson’s Paradox is a statistical phenomenon in which a trend that appears clearly within several groups of data disappears — or even reverses — when the groups are combined into a single total.

In the everyday practice of SEO and marketing, this almost always happens because of a hidden confounding variable: in our case, the relative weight of the segments we’re analyzing. It’s the same reasoning we meet when discussing conditional probability, where what matters is not the marginal figure but the one conditioned on a subgroup. At bottom, the paradox doesn’t arise because the averages are wrong, but because we’re comparing two snapshots of a population whose composition has changed in the meantime.

When we work with rates and percentages (CTR, conversion rate, bounce rate), looking at the aggregate figure without considering the underlying volumes is one of the most insidious traps for anyone analyzing data.

The Proof: Anatomy of a Fake Collapse

Let’s go back to our monthly report and put the absolute numbers behind those percentages. Only then can we understand what really happened between Month 1 and Month 2.

Here’s the point: we don’t have an SEO problem — on the contrary, we’ve had a remarkable success. Our Mobile rankings have exploded, bringing in 18,000 more impressions than the previous month.

Mobile traffic, however, has historically had a structurally lower CTR than Desktop (more noise in the SERP, faster scrolling, distractions). That huge influx of low-CTR impressions “watered down” the global average, dragging it downward. The aggregate figure told us “we’re getting worse”; the disaggregated data tells us “we’re improving across the board, but our traffic mix has changed”.

The mathematical reason is simple, and it’s worth keeping firmly in mind: the aggregate CTR is not the average of the segments’ CTRs, but a weighted average of them, where the weights are each segment’s share of impressions. As a formula:

where \(\text{CTR}_i\) is the CTR of segment i and \(w_i\) is its weight, that is, the fraction of impressions it owns. In Month 2 the weight of Mobile went from 1/6 to 2/3 of the total: even though every individual CTR rose, the average shifted toward the (low) value of the segment that had become dominant. It’s not the math that has gone crazy: it’s the mix that has changed.

Let’s reconstruct the whole thing in R, so we can see the mechanism at work instead of taking it on faith:

# Reconstruct the two months' data
df <- data.frame(
  segment     = c("Desktop", "Mobile", "Desktop", "Mobile"),
  month       = c("Month 1",  "Month 1", "Month 2",  "Month 2"),
  impressions = c(10000,      2000,      10000,      20000),
  clicks      = c(500,        40,        550,        500)
)

# CTR of each segment
df$ctr <- df$clicks / df$impressions

# Aggregate CTR per month: a WEIGHTED average over impressions,
# NOT the arithmetic mean of the CTRs
agg <- aggregate(cbind(clicks, impressions) ~ month, data = df, FUN = sum)
agg$aggregate_ctr <- agg$clicks / agg$impressions
print(agg)

As the output shows, the aggregate drops from 4.5% to 3.5% while both segments rise. N.B.: the arithmetic mean of Month 2’s two CTRs would be 4% (the simple average of 5.5% and 2.5%), quite different from the real 3.5%. The entire difference is in the weights.

Two More SEO Scenarios Where the Paradox Strikes

CTR by device is the textbook example, but Simpson’s Paradox lurks just about everywhere in our dashboards.

1. The Conversion Rate Collapse (Informational vs. Transactional Intent)

We’re working on an e-commerce site and the organic conversion rate goes from 3% to 1.5%. A disaster? Not necessarily. If we’ve just launched a corporate blog that has started ranking well for hundreds of informational, top-of-the-funnel keywords, we’ve brought thousands of users to the site who are far from the purchase stage (with a physiological CR close to 0.1%). The CR of our product pages may be stable or growing, but the sheer volume of blog traffic has distorted the aggregate average.

2. Cannibalization or Ranking Expansion?

One of our long-standing product pages used to rank only for 5 exact transactional keywords: 100 impressions, 10 clicks, 10% CTR. We decide to optimize its content, and the next month Google rewards its semantics, ranking it for 80 new long-tail and related keywords. Now the page gets 5,000 impressions and 100 clicks: 2% CTR. If we look only at the page’s average CTR in Search Console, it seems our optimization destroyed it; if we look at the absolute clicks, we’ve multiplied them tenfold.

How to Defend Yourself (Takeaways for the Analyst)

How do we survive Simpson’s Paradox when presenting data to a client or stakeholder? Four precautions.

1. Never trust the aggregate figure alone. When analyzing relative metrics (conversion rates, click rates, averages), the global total is often the least useful number of all.
2. Segment until you find homogeneity. Always split the data along logical dimensions before drawing conclusions: by device (Desktop/Mobile), by query type (brand/non-brand), and by page type (blog/product).
3. Look for the shift in weights. If a global rate collapses but the subgroups hold steady, ask: “has the traffic mix changed?”. Almost always, a low-performing segment has suddenly increased its volumes.
4. Educate the client. In a report, don’t just show the CTR drop: show the disaggregated table. Explaining the mechanism doesn’t just save the monthly report — it positions us as analysts who reason about data rather than being at its mercy.

Data doesn’t lie, but aggregate data makes for an excellent magician. The most solid defense, however, isn’t statistical but experimental: when we get to decide how to assign traffic — randomizing users between two versions of a page — the mix stops being a variable beyond our control. That’s exactly what we do with a rigorously run A/B test, the next step on our path: seeing how a controlled experiment neutralizes at the root the confounding variables that here we’ve merely unmasked.

Further Reading

If we want to dig deeper into Simpson’s Paradox and the art of reading data without being fooled, The Art of Statistics by David Spiegelhalter is the right read: it devotes lucid pages to this very paradox — including the famous Berkeley admissions case — showing how an aggregate number can tell the exact opposite of what happened in the data.

A time series consists of values observed over a set of sequentially ordered periods. This, for those who do SEO, is already an element of utmost interest.

Website traffic data, considered over a time sequence, is in fact an example of a time series.

Time series analysis is a set of methods that allow us to derive significant patterns or statistics from data with temporal information.

In very general terms, we can say that a time series is a sequence of random variables indexed in time.

The purpose of analyzing a time series can be descriptive (consider decomposing the series to remove seasonality elements or to highlight underlying trends) or inferential, with the latter including forecasting values for future time periods that have not yet occurred.

A bit of theory. Classical time series analysis. Decomposing a time series.

The classical method of time series analysis identifies four influences, or components:

1. Trend (T): the general long-term movement of the values (Y) of the time series over a long period of time.
2. Cyclical Fluctuations (C): recurring long-duration movements.
3. Seasonal Variations (S): fluctuations due to the particular time of year, for example the summer season compared to the winter months.
4. Erratic or Irregular Movements (I): irregular deviations from the trend, which cannot be attributed to cyclical or seasonal influences.

According to the classical time series analysis model, the value of the variable in each period is determined by the influences of the four components.

The main purpose of classical time series analysis is precisely to decompose the series, to isolate the influences of the various components that determine the values of the time series.

The four “classical” components and their relationship

The four components can be related to each other additively:

Y = T + C + S + I

or multiplicatively:

Y = T x C x S x I

Recall that a multiplicative model can be transformed into an additive model by exploiting the properties of logarithms:

log(Y) = log(T) + log(C) + log(S) + log(I)

A brief review: the useful properties of logarithms

The logarithm of a number n to the base c (with c not equal to 1 and c > 0) is the exponent to which the base c must be raised to obtain n.

Therefore, if n = c^b then log_c n = b

• When numbers are multiplied together, the logarithm of their product is the sum of their logarithms.
• The logarithm of a fraction is the logarithm of the numerator minus the logarithm of the denominator.
• The logarithm of a number with an exponent is the logarithm multiplied by the exponent of the number.

Creating a time series in R from a vector or data frame

There are various ways to transform a data vector, a matrix, or a data frame into a time series.
Here, we will limit ourselves to the tools offered by base R to achieve this result.
The function of interest is simply called ts() and its use is rather intuitive.

Let’s see a practical example. Suppose we have a data vector saved with the name mydata.csv in the /home folder of my PC.

The first thing I will do is import my data into R, which I assume is in a CSV file:

# import the data from a csv file into a dataframe
dfmydata <- read.csv("/home/mydata.csv")

# create a vector with the data I'm interested in
mydata <- dfmydata$myobservation

Now all I have to do is call the ts() function with the appropriate start and frequency values to create my time series.

Let’s assume that the data is monthly, starting with January 2012 and going up to December 2018:

timeseries <- ts(mydata, start=c(2012,1), end=c(2018,12), frequency=12)

As you can see, the typical form of the ts() function is

ts(vector, start, end, frequency)

where frequency is the number of observations per unit of time.

Therefore, we will have 1=annual, 4=quarterly, 12=monthly…

Useful functions related to a time series

I can easily find out the time of the first observation of a time series using the command:

start()

Similarly, I can find the last observation with:

end()

The command:

frequency()

returns the number of observations per unit of time, while the very useful command

window()

allows you to extract a subset of data.

Using as an example a dataset included in R called Nile containing 100 annual readings of the Nile river at Aswan for the years 1871 to 1970 (we will also use it in the following paragraph), the command looks like this:

nile_sub <- window(Nile, start=1940,end=1960)

Plotting one or more time series

One of the advantages of using time series is the simplicity in graphical representation. Using the Nile example dataset present in R, which is already a time series object – and I can verify this with the command is.ts(Nile) – I just need the command:

plot.ts(Nile)

to get a graph of the trend of my variable over time. Obviously, I can use the various attributes xlab, ylab, main etc… to make my graph even more meaningful and clear:

plot(Nile, xlab="Year", ylab="Annual Nile River Flow", main="Example Time Series: Nile")

If the dataset contains more than one time series object, I can get the graph of the various objects.

Let’s use another example dataset present in R called EuStockMarkets which contains, as you can easily imagine, the prices of the FTSE, CAC, DAX and SMI stock markets:

plot(EuStockMarkets, plot.type = "multiple")

Alternatively, I can plot the various time series objects together—with different colors—in the same graph:

plot.ts(EuStockMarkets, plot.type = "single", col=c("red","black","blue","green"))

Smoothing Techniques

If we graphically represent a time series, we will almost always notice a series of small variations that can make it very difficult to identify important trends and make predictions for the future. To address this problem, various “smoothing” techniques have been developed, which we can, for simplicity, divide into two main families: techniques based on moving averages and exponential techniques.

MOVING AVERAGE
Instead of the data for month X, I calculate the average of n months, where X is the central point.
The random component is compensated for if we put several months together; its average is equal to 0 for a reasonable number of periods.
The seasonal component repeats regularly throughout the year, so if I distribute the seasonal effect over all 12 months, the effect disappears.
With the moving average, I achieve both desired effects: I compensate for randomness and “distribute” seasonality.

R, as we will soon see, provides fundamental help by making a whole series of tools available to us to carry out our analyses with maximum practicality.

An SEO Example: from Google Analytics 4 to the Time Series

As we have seen, we can easily create a time series in R using the basic command ts().

Since I intend to use time series analysis for SEO purposes to derive a trend and make a forecast, I need to import the data of my Google Analytics 4 property into R. (N.b.: the first version of this article used the Universal Analytics API, which Google permanently shut down in July 2024; the code that follows is updated to the GA4 Data API.)

I can do this “automatically” using the very useful googleAnalyticsR library — which supports GA4 through the ga_data() function — or by manually exporting the data to a csv file.

Let’s see the first case:

# use the googleAnalyticsR library
# which obviously I must have
# correctly installed
library(googleAnalyticsR)
# Authorize Google Analytics
ga_auth()
# set the numeric ID of the GA4 property
# (Admin > Property > Property details)
property_id <- 123456789
# Retrieve the data I need:
# three years of monthly sessions
# from the GA4 Data API
gadata <- ga_data(property_id, 
          metrics = "sessions", 
          dimensions = "yearMonth",
          date_range = c("2023-01-01", "2025-12-31"),
          limit = -1)
# The Data API does not guarantee row order:
# sort by month before building the series
gadata <- gadata[order(gadata$yearMonth), ]
# Convert the data into a time series
# with monthly frequency by indicating frequency=12:
ga_ts <- ts(gadata$sessions, start = c(2023,1), frequency = 12)

The procedure to obtain the same result without going through the API is just as simple.

From the GA4 interface I open the report I am interested in (for example Reports > Life cycle > Acquisition > Traffic acquisition), set the date range and use the share button to download the csv file. Alternatively, I can query the Data API directly from the browser with the GA4 Query Explorer: I choose the property, the metric (sessions), the dimension (yearMonth), the date range, and download the result.

I then open the file with a text editor and delete any general header lines and the totals at the bottom. If I want, I can rename the columns (“date” and “sessions”) for better readability.

All that remains is to import the csv and create the time series. A matter of two lines:

# Import a very simple dataset
# with month and sessions
sitedata <- read.csv("path/monthly-sessions.csv", header = TRUE)

# Convert the data into a time series
sitedata_ts <- ts(sitedata$sessions, start = c(2023,1), frequency = 12)

Now that I have my time series, I have a multitude of R packages available that provide me with all the useful tools for any type of analysis, from the most basic to the most in-depth.

Limiting the Effect of Seasonality Through Moving Averages

Install the forecast package to be able to use the very useful ma() function:

library(forecast)
sitedata.filt <- ma(sitedata_ts, order=12)
sitedata.filt

In this way, a weighted average has been applied to our time series to limit the effect of seasonality. I can now visualize the estimated trend using the moving average system:

lines(sitedata.filt, col="red")

Removing the Seasonal Trend Using Differencing

Using differencing with the diff() function and an appropriate lag, I can eliminate the seasonal trend, if present. In the case of a monthly time series that includes several years of observations, I just need to use a lag=12, as in this trivial example where I assume I’m working on a time series x:

# remove the seasonal trend
# assuming monthly data and the presence of seasonality
dx <- diff(x, lag=12)
ts.plot(dx, main="Deseasonalized User Trend")

Decomposing the Time Series Through Moving Averages

We have seen in the course of the article that the classical method of time series analysis identifies four influences, or components, and that the main purpose is precisely to decompose the series to isolate the influences of the various components that determine the values of the time series.

Moving from theory to practice, let’s see how we can proceed.
I can use the decompose() function of the stats package to perform a classical decomposition of my time series into its components using the moving average system and representing everything in a single clear graph:

# decompose the time series. I have chosen a multiplicative decomposition
# obviously, I could have chosen an additive one
components <- decompose(sitedata_ts, type ="multiplicative")
names(components)
# explore the components of the time series in the graph
plot(components)

Decomposing the Series with the LOESS Method

A more refined alternative for decomposing the series is the one that uses the LOESS (Locally Weighted Smoothing) method. It is a set of non-parametric methods that fit polynomial regression models to subsets of the data. We use the stl() function of the stats package for this purpose:

# use stl for a LOESS type decomposition
sitedata_loess <- stl(sitedata_ts, s.window="periodic")
head(sitedata_loess$time.series)
plot(sitedata_loess)

Compared to decompose(), stl() has two advantages that carry real weight in everyday practice: it allows the seasonal component to evolve over time (by passing a numeric value to s.window instead of “periodic”) and it is more robust in the presence of outliers. And from the decomposition I can instantly derive the seasonally adjusted series — the traffic “cleansed” of seasonality, the one that tells us whether we are really growing or it is just high season — thanks to the seasadj() function of the forecast package:

library(forecast)
# the seasonally adjusted series: trend + remainder
sitedata_adj <- seasadj(sitedata_loess)
plot(sitedata_adj, main="Seasonally adjusted sessions")

The Seasonal Plot: Seasonality at a Glance

There is one chart that, in everyday practice, is worth half the seasonality analysis on its own: the seasonal plot. The idea is simple: instead of drawing the series as a single continuous line, I overlay the years — months on the horizontal axis, one line per year. If the lines resemble each other (the August dip, the November peak), seasonality is there, visible and recurring; if one line breaks away from the others, something happened that year and it deserves a closer look. I draw the seasonal plot with the ggseasonplot() function of the forecast package:

library(forecast)
# one line per year, months on the x axis
ggseasonplot(sitedata_ts, year.labels = TRUE)

# "polar" variant: months arranged in a circle
ggseasonplot(sitedata_ts, polar = TRUE)

Three years compared at a glance: the year-over-year growth (the lines shift upwards) and the seasonal profile repeating itself, with the summer low and the autumn recovery. Alternatively, the base R command monthplot(sitedata_ts) groups the observations by month, showing the average and the evolution across years for each month.

Exponential Smoothing with the Holt-Winters Method and Forecasting

Smoothing and forecasting techniques offer us powerful operating modes for predicting future values of time series data.

At the most basic level, smoothing can be achieved using moving averages.

In R, we can use HoltWinters, a function to perform time series smoothing.
The function contains three exponential smoothing methods. All three methods use the same function, HoltWinters. However, we can invoke them separately based on the values of the alpha, beta, and gamma parameters.

Holt-Winters exponential smoothing provides reliable forecasts only if there is no autocorrelation in the time series data, which can be verified, as we will see shortly in practice, with the acf function and a Box-Pierce or Ljung-Box test.

After creating a forecasting model, we must evaluate it to understand if it correctly represents the data. Similar to a regression model, we can use residuals for this purpose. If the residuals follow a white noise distribution, then the sequence (or error) of residuals is generated by a stochastic process. And therefore, our model represents the time series well.

Let’s see an example. Suppose we have a time series x:

# We use the forecast function for a prediction: next 6 periods
x.hw <- HoltWinters(x)
future.forecast <- forecast(x.hw, h=6)
# print a summary to the screen
summary(future.forecast)
# draw the graph
plot(future.forecast)
# draw the graph of the residuals to estimate the autocorrelation
acf(future.forecast$residuals, na.action = na.pass)
# perform an autocorrelation test
Box.test(future.forecast$residuals)

Autocorrelation tells us whether the terms of a time series depend on its past.

If we consider a time series x of length n, the lag 1 autocorrelation can be estimated as the correlation of the pair of observations (x[t], x[t-1]).

R provides us with a convenient command: acf().
Using:

acf(x, lag.max = 1, plot = FALSE)

on the x series, the autocorrelation of degree -1 is automatically calculated.

By default, the command acf(x) draws a graph that shows two dashed blue horizontal lines, which represent the 95% confidence interval.
The autocorrelation estimate is indicated by the height of the vertical bars (obviously, the autocorrelation at degree 0 is always 1).

The confidence interval is used to determine the statistical significance of the autocorrelation.

I show, as an example, the output of the acf() function on the Nile time series provided by R:

If the autocorrelation coefficient decreases and falls rapidly between the bounds, this means that the residuals follow a white noise distribution. There is no apparent autocorrelation.
Conversely, if the coefficients are always above or below the limit, this means that the residuals are autocorrelated.

A Ljung-Box autocorrelation test is a particular form of hypothesis test, and it provides a p-value as output, a value that allows us to understand whether to reject the null hypothesis or not.

Let’s apply the box.test function to the residual sequence; we find the p-value. If it is greater than the value of α, we cannot reject the null hypothesis. That is, the residuals are white noise, and this demonstrates that our model “works well” in predicting the value.

Let’s see it all in action in our SEO example related to website traffic, also using the highcharter library for better visualization of the output:

# First, I load the libraries I need
library(googleAnalyticsR) 
# to read Google Analytics 4 data
library(forecast) 
# for time series forecasting
library(highcharter) 
# to get the chart
# numeric ID of the GA4 property
# (Admin > Property > Property details)
property_id <- 123456789
# Authorize Google Analytics
ga_auth()
# and then retrieve the data from the GA4 Data API
sitedata <- ga_data(property_id, 
            metrics = "sessions", 
            dimensions = "yearMonth",
            date_range = c("2023-01-01", "2025-12-31"),
            limit = -1)
# nb: the dimension of my data is yearMonth
# and I sort the rows by month
sitedata <- sitedata[order(sitedata$yearMonth), ]
# Now I express the data as a time series
sitedata_ts <- ts(sitedata$sessions, start = c(2023,1), frequency = 12)
 
# Calculate Holt-Winters smoothing
hw_forecast <- HoltWinters(sitedata_ts)
# Generate a forecast for the next 12 months
hchart(forecast(hw_forecast, h = 12))

The reader is tasked with testing the quality of the forecasting model.

Investigating Time Series with ARIMA Models

Using the exponential smoothing method requires that the residuals are not correlated. In real-world cases, this is quite unlikely. However, we have other tools available to address these cases: R provides us with the ARIMA function to build time series models that take autocorrelation into account.

White Noise

The very useful arima.sim function allows you to simulate an ARIMA process by generating ad hoc time series data.

Through this function, therefore, we can begin to look at two basic time series models: white noise and the random walk.

An ARIMA model consists of three components: ARIMA(p,d,q).

• p is the order of autoregression
• d is the order of integration
• q is the order of the moving average

White noise is the most basic example of a stationary process. Its salient characteristics are:

1. It has a fixed, constant mean.
2. It has constant variance.
3. It does not follow any temporal correlation.

The white noise model in ARIMA terms is therefore ARIMA(0,0,0).

Let’s simulate a time series of this type:

wn <- arima.sim(model = list(order = c(0,0,0)), n=100)
ts.plot(wn)

Random Walk

The Random Walk is a simple example of a non-stationary process. It has the following salient characteristics:

• It does not have a specific mean or variance.
• It shows strong temporal dependence.
• Its changes or increments are of the White Noise type.

The random walk model is also a basic time series model and can be easily simulated with our arima.sim function.
The Random Walk model is the cumulative sum of White Noise series with a mean of zero.
From this, it follows that the first differenced series of a Random Walk series is a White Noise series!

The ARIMA model for a Random Walk series is ARIMA(0,1,0).

Let’s generate a series of this type and visualize it:

RW <- arima.sim(model = list(order = c(0,1,0)), n = 100)
ts.plot(RW)

Let’s see the proof of what was stated above:

RWdiff <- diff(RW)
ts.plot(RWdiff)

We obtain precisely a White Noise series:

The ARIMA Model in Action

The Autoregressive Integrated Moving Average (ARIMA) model is also known as the Box-Jenkins model, named after statisticians George Box and Gwilym Jenkins.

The purpose of ARIMA is to find the model that best represents the values of a time series.

An ARIMA model can be expressed as ARIMA(p, d, q), where, as we have already seen, p is the order of the autoregressive model, d indicates the degree of differencing, and q indicates the order of the moving average.

Operationally, we can define five steps to fit time series to an ARIMA model:

1. Visualize the time series with a graph.
2. Difference non-stationary time series to obtain stationary time series.
3. Plot ACF and PACF graphs to find the optimal values of p and q, or derive them using the auto.arima function.
4. Build the ARIMA model.
5. Make the forecast.

Let’s See a Practical Example of an ARIMA Model

1. Simulate an ARIMA process using the arima.sim() function and plot the graph:

simts <- arima.sim(list(order = c(1,1,0), ar = 0.64), n = 100)
plot(simts)

2. Difference the series to obtain a stationary time series and plot the graph:

simts.diff <- diff(simts)
plot(simts.diff)

3. Use the auto.arima function to estimate the best values for p, d, and q:

auto.arima(simts, ic="bic")


Series: simts 
ARIMA(1,1,0) 
Coefficients: 
ar1 0.6331 
s.e. 0.0760 
sigma^2 estimated as 0.9433: log likelihood=-138.73 
AIC=281.46 AICc=281.58 BIC=286.67

4. Create the ARIMA model with the indicated p, d, and q values (in our example, 1, 1, 0):

fit <- Arima(simts, order=c(1,1,0))
summary(fit)

5. Based on our ARIMA model, we can now proceed to forecast future values of the series and plot the graph:

fit.forecast <- forecast(fit)
summary(fit.forecast)
plot(fit.forecast)

The shaded areas show the 80% and 95% confidence intervals.

Finally, let’s evaluate the goodness of our model with an ACF graph:

As with the exponential smoothing model, we can use the acf function to calculate the residuals and create the autocorrelation plot. Since the autocorrelation coefficient decreases rapidly, the residuals are white noise.

We can also perform a Box-Pierce test:

Box.test(fit.forecast$residuals)

Box-Pierce test 
data: fit.forecast$residuals
X-squared = 0.020633, df = 1, p-value = 0.8858

And we obtain a p-value that indicates the non-rejection of the null hypothesis.

Try It Yourself

To consolidate everything, here is a complete exercise that requires neither a website nor access to Google Analytics: we generate the data ourselves. Let’s build in R three years of realistic monthly sessions — an underlying growth, a marked summer dip (as happens to many B2B sites) and some random noise:

set.seed(42)

# 36 months: growing trend + seasonality + noise
trend <- seq(8000, 14000, length.out = 36)
seasonality <- rep(c(1.05, 1.08, 1.12, 1.04, 0.98, 0.88,
                     0.72, 0.65, 1.02, 1.12, 1.16, 1.10), 3)
noise <- rnorm(36, mean = 1, sd = 0.04)
sessions <- round(trend * seasonality * noise)

# the time series: monthly, from January 2023
traffic_ts <- ts(sessions, start = c(2023, 1), frequency = 12)

The exercise retraces the whole article, in five steps:

1. Plot the series with plot.ts(traffic_ts): can you already see trend and seasonality with the naked eye?
2. The seasonal plot with ggseasonplot(traffic_ts, year.labels = TRUE): it is exactly the chart shown earlier in this article — is the August dip recognizable at first glance?
3. Decompose with stl(traffic_ts, s.window = “periodic”), plot the components with plot() and derive the seasonally adjusted series with seasadj().
4. Estimate the model and the forecast: future <- forecast(HoltWinters(traffic_ts), h = 6), then plot(future).
5. Evaluate the residuals: acf(residuals(future), na.action = na.pass) and Box.test(residuals(future), type = “Ljung-Box”). Does the model hold up?

If everything goes smoothly, the forecast for the first six months of 2026 should continue the growth while respecting the seasonal profile (n.b.: with seed 42, the point forecast for January is around 15,300 sessions), and the Ljung-Box test on the residuals should return a p-value comfortably above 0.05: the residuals are white noise, the model has captured the structure of the series.

One final warning before we close, because the tool is powerful but treacherous: a forecasting model — be it Holt-Winters or ARIMA — projects the regularities of the past into the future. It works as long as the world keeps behaving the way it has behaved: a Google core update, a botched migration, an aggressive competitor are not in the model, and no confidence band can predict them. This is why, in SEO practice, forecasting is less about guessing the future and more about noticing quickly that the present is drifting away from it: when real traffic exits the forecast bands, that is where we need to go and look. We discussed this “negative” use of models in the article on anomaly detection, and we will soon return to the decomposition of organic traffic with a dedicated case study.

Further Reading

To dig deeper into time series analysis — stationarity, autocorrelation, forecasting models — Introduzione all’econometria by Stock and Watson (Italian edition) devotes clear and rigorous chapters to the subject.

On the popular side, The Signal and the Noise by Nate Silver tells the story of why forecasts fail so often — and how good forecasters think: the ideal companion read, no computer required.

You might also like

• Anomaly Detection: How to Identify Outliers in Your Data
• Simpson’s Paradox in SEO: When Aggregate Data Can Lie