Growth rates, lags and seasonality

A rise from 400 orders to 500 is 25%, but nine days against a whole month is not a comparable growth rate. A growth rategrowth rate: A relative change computed as the current value divided by a stated earlier base, minus one; a percentage display multiplies that fraction by 100. divides the current value by an earlier base and subtracts one. A laglag: An earlier observation paired with a current one under a stated offset, such as the previous row or the same calendar month a year earlier. places that earlier observation beside the current one: one month for month-on-month growth, twelve months for year-on-year growth on monthly data. shift and pct_change count rows by default, so calendar comparisons need the intended period keys and gaps retained in position.

Seasonalityseasonality: A pattern that recurs at a position in a calendar or other cycle, such as weekday or month; a period comparison can mix this pattern with growth. is a repeating pattern by calendar position, such as weekday or hour. Matching months a year apart can control a stable month pattern, but it does not guarantee matched holidays or business coverage. Keep a running month out of a whole-month headline, and leave missing values explicit unless a declared replacement is justified.

Pair the intended periods before dividing

Growth rates express a change relative to a specified earlier base, rather than the number of orders added. Growth rates are comparable only when the source units, period keys and observed coverage match the question being asked.

The examples use two years of synthetic daily orders from an online grocery shop, exported on the ninth day of a month, so the last month is still running.

"""Daily orders of a synthetic online grocery shop, from a September to the 9th day of an October two years later."""
import numpy as np
import pandas as pd


def daily_orders():
    days = pd.date_range("2024-09-01", "2026-10-09", freq="D")
    months = (days.year - 2024) * 12 + days.month - 9  # 0 for the first September
    weekday = np.array([1.00, 0.95, 0.95, 1.00, 1.10, 1.30, 1.25])[days.dayofweek]
    rng = np.random.default_rng(12)
    noise = rng.normal(1.0, 0.04, len(days))
    return pd.Series(np.round(200 * 1.015 ** months * weekday * noise).astype(int), index=days, name="orders")

"""Flag partial months and keep every calendar position before computing whole-month growth."""
import pandas as pd

from orders import daily_orders

def monthly_table(orders):
    """Monthly totals and coverage from one observation per naive local midnight."""
    index = orders.index
    if (not isinstance(index, pd.DatetimeIndex) or index.tz is not None
            or index.hasnans or index.has_duplicates or not index.equals(index.normalize())):
        raise ValueError("use unique date-only keys on the declared reporting calendar")
    table = pd.DataFrame({
        "orders": orders.resample("MS").sum(min_count=1),
        "days": orders.resample("MS").count(),
    })
    table["complete"] = table["days"] == table.index.days_in_month
    table["mom"] = table["orders"].pct_change()
    table["yoy"] = table["orders"].pct_change(12)
    return table


def whole_month_report(monthly):
    """Compute rates on the full calendar grid before selecting complete headline months."""
    whole_totals = monthly["orders"].where(monthly["complete"])
    full = monthly.loc[monthly["complete"]].copy()
    full["mom"] = whole_totals.pct_change().reindex(full.index)
    full["yoy"] = whole_totals.pct_change(12).reindex(full.index)
    return full


if __name__ == "__main__":
    orders = daily_orders()
    monthly = monthly_table(orders)
    print(f"{len(monthly)} months, the first and the last three:")
    shown = pd.concat([monthly.head(1), monthly.tail(3)])
    print(shown.to_string(formatters={"mom": "{:+.1%}".format, "yoy": "{:+.1%}".format}))

    full = whole_month_report(monthly)
    last = full.iloc[-1]
    print(f"\nLast complete month: {full.index[-1]:%b %Y}, {last['orders']:,} orders, MoM {last['mom']:+.1%}, YoY {last['yoy']:+.1%}")
    earlier = full.index[-1] - pd.DateOffset(years=1)
    if earlier in monthly.index and monthly.loc[earlier, "complete"]:
        print("YoY compares it with", f"{earlier:%b %Y}:", f"{monthly.loc[earlier, 'orders']:,}", "orders")
    else:
        print("YoY base is missing or incomplete at the required calendar month")

    middle_gap = pd.Series(10, index=pd.date_range("2026-01-01", "2026-03-31", freq="D"))
    middle_gap = middle_gap.drop(pd.Timestamp("2026-02-15"))
    controls = whole_month_report(monthly_table(middle_gap))
    print("\nOne February day is missing; March's adjacent-month rate is missing:",
          bool(pd.isna(controls.loc[pd.Timestamp("2026-03-01"), "mom"])))

26 months, the first and the last three:
            orders  days  complete    mom    yoy
2024-09-01    6486    30      True    NaN    NaN
2026-08-01    9556    31      True  +3.5% +20.9%
2026-09-01    9147    30      True  -4.3% +18.9%
2026-10-01    2785     9     False -69.6% -65.5%

Last complete month: Sep 2026, 9,147 orders, MoM -4.3%, YoY +18.9%
YoY compares it with Sep 2025: 7,696 orders

One February day is missing; March's adjacent-month rate is missing: True

resample("MS").sum() turns days into months, and counting the days in each month next to its total shows at once that the last month holds only 9. Its month-on-month rate, −69.6 %, and its year-on-year rate, −65.5 %, describe the export date, not the shop. September is the latest whole month: 4.3 % below August and 18.9 % above the September a year earlier. Before selecting headline rows, the program marks every incomplete month’s whole-period total as unknown on the full calendar grid. Its final drill removes one February day and keeps March’s adjacent-month rate missing; dropping February first would incorrectly compare March with January. pct_change(12) is the year-on-year rate because the series has exactly one row per month, so twelve rows back is twelve months back. pandas builds lags with shift: shift(1) moves every value one row down, so each row also holds the month before. Lags are just as useful on their own: orders.shift(12) puts last year’s value beside this year’s in the same row, which is often clearer in a report than a percentage.

Keep the incomplete month on the calendar grid, then inspect the base selected for each headline rate.

Keep missing periods in their calendar position

"""pct_change in pandas 3 when a value is missing: no silent filling."""
import pandas as pd

orders = pd.Series([100.0, None, 110.0], index=["Jan", "Feb", "Mar"])
print("pct_change():        ", orders.pct_change().tolist())
try:
    orders.pct_change(fill_method="ffill")
except ValueError as error:
    print("fill_method='ffill': ", "ValueError:", error)
print("ffill().pct_change():", orders.ffill().pct_change().round(3).tolist())
print("shift(1) by hand:    ", (orders / orders.shift(1) - 1).tolist())

pct_change():         [nan, nan, nan]
fill_method='ffill':  ValueError: fill_method must be None; got fill_method='ffill'.
ffill().pct_change(): [nan, 0.0, 0.1]
shift(1) by hand:     [nan, nan, nan]

In pandas 3, pct_change() does not fill missing values first: the month after a gap compares with a missing value and is missing too. The old fill_method="ffill" now raises a ValueError: the pandas 3 documentation says the argument must be None and will be removed. If carrying the last known value forward is right for your data, say so with ffill().pct_change(), which reports 0 % for the missing month and 10 % for the next. Often it is not justified: a missing month of orders might be a missing export, and a growth rate built on an invented value is worse than a gap. The same result comes from the definition, orders / orders.shift(1) - 1, which is worth knowing because it works the same way in every tool. Growth rates inherit gaps in their comparison values. Keep missing calendar periods in position; dropping rows before calculating a calendar rate would change which periods are compared. A last-observation comparison can be valid too, but it must be labelled as that different metric.

Retain the unknown middle month and contrast a missing comparison with an explicit carried-value policy.

State the denominator of a seasonal index

Seasonality describes recurring differences by a position in a calendar cycle, such as the weekday. Seasonality can coexist with growth, changing exposure and unusual events, so a repeating profile is a descriptive comparison rather than a causal explanation.

"""A weekday profile: the average orders of each weekday, as a share of the overall daily average."""
import pandas as pd

from orders import daily_orders

orders = daily_orders()["2026-07-01":"2026-09-30"]  # one recent quarter, 13 weeks and 1 day
profile = orders.groupby(orders.index.day_name()).agg(days="count", mean="mean")
profile = profile.reindex(["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"])
profile["index"] = profile["mean"] / orders.mean()
print(profile.round({"mean": 1, "index": 2}).to_string())
print(f"\nBusiest day: {profile['index'].idxmax()}, {profile['index'].max() - 1:+.0%} against an average day")

           days   mean  index
Monday       13  281.4   0.93
Tuesday      13  264.2   0.87
Wednesday    14  269.4   0.89
Thursday     13  282.2   0.93
Friday       13  310.2   1.02
Saturday     13  366.3   1.21
Sunday       13  354.2   1.17

Busiest day: Saturday, +21% against an average day

A seasonal profile averages a value by its position in the cycle, here the weekday, and divides by the overall average, so an index above 1 marks a day busier than average. Saturday’s 1.21 means 21 % more orders than an average day, and Tuesday’s 0.87 means 13 % fewer. The days column matters: the quarter starts on a Wednesday, so Wednesdays appear 14 times and every other day 13, and a profile built on uneven counts should say so. Month-of-year profiles use month positions instead of weekday positions, and more observed cycles help reveal whether an unusual month dominates. Hour profiles summarize by hour on the reporting clock. They need comparable observed coverage per hour, rather than treating an unobserved hour as a measured zero.

Count the observed weekdays first, then compare each mean with the stated overall daily denominator.

Growth that misleads: tiny bases, running months and missing months Pro: opens with a Pro, Premium or Ultimate pass

Seasonal profiles that hold up: weekday by hour, and a festival that moves Pro: opens with a Pro, Premium or Ultimate pass

Compound growth and a monthly KPI table, with numbers Pro: opens with a Pro, Premium or Ultimate pass

Practise whole-month growth

The exercise computes month-on-month and year-on-year growth with the standard library, refusing the month that is still running and any month with missing days.

from calendar import monthrange
from datetime import date


def monthly_growth(rows):
    """[(month, total, mom, yoy), ...] for every whole month, in calendar order.

    rows is a list of (day, orders) pairs, such as ("2026-07-14", 31).
    mom and yoy are changes in per cent, rounded to 1 decimal place, or None.
    """
    # Replace this line with your code.
    return []

from calendar import monthrange

from kpi import monthly_growth


def month(year, number, per_day, days=None):
    """Rows for the first `days` days of a month (all of them by default), each with `per_day` orders."""
    last = monthrange(year, number)[1] if days is None else days
    return [(f"{year}-{number:02d}-{d:02d}", per_day) for d in range(1, last + 1)]


def test_partial_month_is_left_out():
    """leaves out the month that is still running"""
    rows = month(2026, 1, 10) + month(2026, 2, 12) + month(2026, 3, 15, days=9)
    assert monthly_growth(rows) == [("2026-01", 310, None, None), ("2026-02", 336, 8.4, None)]


def test_year_on_year():
    """compares each month with the same month a year earlier"""
    rows = [r for m in range(1, 13) for r in month(2025, m, 10)] + month(2026, 1, 11)
    result = monthly_growth(rows)
    assert len(result) == 13
    assert result[-1] == ("2026-01", 341, 10.0, 10.0)
    assert all(yoy is None for _, _, _, yoy in result[:12])


def test_missing_month():
    """does not compare a month with the one two months back when the month between is missing"""
    rows = month(2026, 1, 10) + month(2026, 3, 10)
    assert monthly_growth(rows) == [("2026-01", 310, None, None), ("2026-03", 310, None, None)]


def test_zero_base():
    """gives None, not an error, when the month before had no orders"""
    rows = month(2026, 4, 0) + month(2026, 5, 4)
    assert monthly_growth(rows) == [("2026-04", 0, None, None), ("2026-05", 124, None, None)]


def test_rows_in_any_order():
    """sorts the months itself"""
    rows = list(reversed(month(2026, 6, 20) + month(2026, 7, 21)))
    assert monthly_growth(rows) == [("2026-06", 600, None, None), ("2026-07", 651, 8.5, None)]



def test_missing_day_does_not_shift_the_comparison():
    """An incomplete February is excluded, but March is not compared with January."""
    february = month(2026, 2, 12)
    february = [row for row in february if row[0] != "2026-02-15"]
    rows = month(2026, 1, 10) + february + month(2026, 3, 15)
    assert monthly_growth(rows) == [("2026-01", 310, None, None), ("2026-03", 465, None, None)]


def test_incomplete_prior_year_has_no_yoy():
    """A known partial prior-year month is not a whole-month comparison base."""
    earlier = [row for row in month(2025, 1, 10) if row[0] != "2025-01-15"]
    assert monthly_growth(earlier + month(2026, 1, 11)) == [("2026-01", 341, None, None)]

Interview questions

Key takeaways

• A growth rate compares a current value with a stated earlier base; pct_change returns a fraction rather than percentage units.
• Calendar growth needs the intended period keys and missing periods retained in their positions.
• pandas 3 does not silently fill missing comparison values, so a replacement must have a declared meaning.
• Whole-month headlines require comparable coverage; a yearly match does not remove every calendar or business difference.
• A seasonal profile compares observed averages by cycle position with a stated overall average and exposure.