Time-Series Forecasting Without Pain: Baselines First

Quickstart: the 15-minute forecasting setup

Use this post like a checklist. You’ll get a baseline that’s hard to beat, an evaluation you can trust, and a simple path to “fancier” models only when they actually help.

Overview: why baselines beat most “smart” models

Time series are deceptive: the past strongly predicts the future, so even flawed methods can look good. That’s why forecasting projects often fail in production—models overfit, evaluation leaks future info, and the simplest method would have performed just as well.

Once baselines are set, improving becomes straightforward: you either add real signal (useful features), reduce noise (smoothing/aggregation), or pick a model that matches the series structure (trend, seasonality, events, holidays, multiple series).

Core concepts: the few things that matter most

1) Forecast horizon

The horizon is how far ahead you predict (next hour, next day, next 30 days). A method that’s great for one-step ahead can fail at longer horizons.

2) Seasonality and calendar structure

Seasonality means patterns repeat at a fixed period (daily, weekly, yearly). Many real-world datasets have it. If you ignore seasonality, your model can “learn it” in training and still fail when the calendar shifts.

y_hat[t] = y[t - 7]

3) Leakage (the silent killer)

Leakage is when your features or preprocessing use information from the future. It can create models that look perfect in validation and collapse in production.

4) Backtesting (rolling evaluation)

Backtesting means evaluating the model on several time windows, not just one split. This protects you from picking a model that got lucky on a single period.

Step-by-step: a baseline-first forecasting workflow

This workflow scales from “one series in a CSV” to “many products across stores.” The ordering matters: each step prevents a class of mistakes.

Step 1 — Define the job (what are we predicting?)

Step 2 — Make a time split that matches reality

Decide how your model will be used, then simulate it. If you forecast daily and retrain weekly, your backtest should reflect that cadence.

Step 3 — Implement the baseline ladder

Build baselines from weakest to strongest. Stop when you hit “strong enough to be annoying to beat.” For many datasets, seasonal naive or ETS is that line.

Step 4 — Pick metrics that match the goal

Don’t overthink metrics, but do pick at least two: one absolute error and one scale-free percentage-like score.

Step 5 — Minimal baseline code (Python)

This is intentionally small. The goal is not “perfect library code,” it’s a clean reference you can trust.

# Minimal baselines + rolling backtest (pure Python-ish pseudocode)
# Replace arrays with pandas Series if you like.

def naive_forecast(y_train, horizon):
    # Predict last observed value for all future steps
    last = y_train[-1]
    return [last] * horizon

def seasonal_naive_forecast(y_train, horizon, season):
    # Predict value from one season ago; repeats if horizon > season
    out = []
    for h in range(1, horizon + 1):
        out.append(y_train[-season + ((h - 1) % season)])
    return out

def moving_average_forecast(y_train, horizon, k=7):
    k = min(k, len(y_train))
    avg = sum(y_train[-k:]) / k
    return [avg] * horizon

def mae(y_true, y_pred):
    return sum(abs(a - b) for a, b in zip(y_true, y_pred)) / len(y_true)

def rolling_backtest(y, start, horizon, step, forecast_fn):
    # y: full series list
    # start: first index where you begin forecasting (e.g. 70% of data)
    scores = []
    t = start
    while t + horizon <= len(y):
        train = y[:t]
        test = y[t:t+horizon]
        pred = forecast_fn(train, horizon)
        scores.append(mae(test, pred))
        t += step
    return scores

# Example usage:
# scores = rolling_backtest(y, start=200, horizon=14, step=7, forecast_fn=lambda tr, h: seasonal_naive_forecast(tr, h, season=7))
# print("MAE mean:", sum(scores)/len(scores), "min/max:", min(scores), max(scores))

Step 6 — Only then: upgrades that usually work

Common mistakes (and how to fix them)

These are the exact traps that make forecasting feel “painful.” Fixing them usually improves results more than switching to a new model.

FAQ

What’s the best baseline for forecasting?

If you have clear seasonality (daily/weekly/yearly), start with seasonal naive. It’s simple, brutally strong, and exposes whether your “smart model” adds real value. If seasonality is weak or unknown, use naive + moving average as quick references.

What is ETS, and why is it such a good baseline?

ETS (Exponential Smoothing) is a family of classical methods that model level, trend, and seasonality with smoothing. It’s popular as a baseline because it often performs surprisingly well with minimal tuning.

How many backtest folds do I need?

For most projects, 3–10 folds is enough. Use more folds if the series is unstable (lots of drift) or if you need high confidence for deployment. Always keep a final holdout period that you only evaluate once.

Why does my model do well at 1-day ahead but fails at 30-days ahead?

Longer horizons require stronger structure. At 1-day ahead, yesterday is often a great predictor. At 30-days ahead, you need seasonality, trend stability, and known future factors (calendar/events), otherwise forecasts become “guessy.”

Should I use deep learning for time series?

Only if the problem justifies it: lots of data, many related series, complex patterns, or a need to model nonlinear relationships with many features. For many forecasting tasks, strong baselines + classical methods + simple ML are easier to maintain and just as accurate.

Cheatsheet: baseline-first forecasting (copy this)

Wrap-up: make forecasting boring (that’s the win)

The goal isn’t to build the fanciest model—it’s to make accurate forecasts you can trust. Start with strong baselines (especially seasonal naive), evaluate with time-aware backtests, and only then move up the complexity ladder.

Related posts

• AI vs ML vs Deep Learning: A Clear Map for Beginners
• How LLMs Work (Without the Math Spiral)
• Prompt Patterns That Produce Reliable Outputs
• RAG Done Right: Make Chatbots Use Your Data Reliably
• Fine-tuning vs RAG: What to Choose (And When)
• Evaluating AI: Test Sets, Metrics, and the ‘Looks Good’ Trap