Forecast any number with eight forecasting algorithms

The context

Forecasting has always fascinated me.
About five years after my first FinOps talk — a lightning session on forecasting at FinOps X in Austin (it’s still on YouTube) — I realised that even as the FinOps community evolved, forecasting remains one of the hardest and most debated topics.

We still talk about unit economics, budgets, and cost optimisation — but forecasting sits right next to them.
It’s a discipline that cuts across industries: banks, retailers, logistics, and energy companies all forecast. It’s a field with real history, tested methodologies, and mathematical rigour.

And yet, in cloud, we often treat it as guesswork.

I wanted to change that — or at least make it easier to explore.
I don’t claim to know every formula, but I wanted a tool that could run several methods at once, let me compare them, and see which one fits the data and context best.

So I built forecast_costs.py — a simple, composable tool that takes a CSV with dates and numbers, applies multiple forecasting techniques, and shows how they behave.

In spirit, it follows the same pattern as the rest of the FinOps Toolkit: small, local, contextual, and transparent.
The forecasts are not just for cloud spend — they work for any time series, any number, any system where you need to see what might happen next.

And yes, I also asked AI to help.
Sometimes I let it pick which algorithm fits the data best. Sometimes I override it. That’s the balance I like — humans and machines exploring context together.

Why it exists

Forecasting is everywhere — but it’s rarely approachable.
In FinOps, it often feels like a black box: either too simple (“just extrapolate”) or too complex (“we’ll deploy a neural network”).

The goal of forecast_costs.py is to make forecasting simple, plural, and transparent.

You feed it a CSV. It runs multiple methods. You compare the results.

No dashboards. No hidden models. Just clean outputs you can reason about.

👉 View it on GitHub →
🎨 Try the live demo →

What it does

forecast_costs.py takes a CSV with a date and a numeric value, runs a series of forecasting algorithms, and outputs the results in plain CSV format.

It’s vendor-neutral — meaning you can use it for anything:

• AWS or cloud costs
• Revenue
• Transactions
• User counts
• Energy usage
• Any number that changes over time

It includes several models you can mix and match:

• Simple moving average (SMA)
• Exponential smoothing (ES)
• Holt-Winters
• ARIMA and SARIMA
• Theta
• NeuralProphet
• Darts
• And an ensemble (average) across all models

How to use it

Start with any time series in CSV form. If you’ve already exported from cost_and_usage.py, that’s a great place to begin.

Example:

python forecast_costs.py --input costs.csv --date-column PeriodStart --value-column Cost --milestone-summary

You’ll get:

• A forecast for each method
• Milestone summaries (end of month, next month, next quarter)
• A combined ensemble forecast

You can graph the results, join them with your KPI plan, or pipe them into another process.

Why it matters

Forecasting is not about predicting the future — it’s about understanding possible futures. It’s a way to talk about expectations, risks, and trade-offs.

When you compare different methods, you’re not looking for the “right” one; you’re looking for the one that fits your context — your workload, your volatility, your business cycle.

That’s the essence of context-first FinOps: choosing not the perfect algorithm, but the one that fits the story you’re trying to tell.

Why I love it

There’s something magical about seeing curves that reflect reality — even roughly. Each model interprets the same past differently. Each offers a new perspective.

That’s why I find forecasting so powerful: it reminds us that data is not destiny; it’s a set of clues about what might happen next.

And because the tool is small and open, you can extend it, add models, or automate comparisons. It’s not just about getting answers — it’s about learning through exploration.

Design philosophy

forecast_costs.py was built to be:

• Vendor-neutral: any CSV, any metric, any domain.
• Multi-model: several algorithms at once, to expose uncertainty.
• Composable: works with pipes and simple files, not APIs.
• Transparent: plain CSV outputs — nothing hidden behind charts.
• Extendable: add your own models or adjust parameters easily.

It’s a laboratory, not a calculator.

See the demo

You can see it directly in the browser: 🎨 https://fcontrepois.github.io/finops-toolkit-ui/forecast-demo

Upload a CSV with a date and a number, and see forecasts generated using the same engine that powers the CLI.

A relatable use case

You have daily cost data for your production environment. You export it, run:

python forecast_costs.py --input costs.csv --date-column PeriodStart --value-column Cost --milestone-summary

You get several forecasts: one smooth, one reactive, one cautious. You compare them, overlay your growth target, and see where they diverge.

Now you can talk about uncertainty instead of pretending it doesn’t exist. That’s clarity — not prediction.

What’s next

Forecasting opens the door to smarter conversations — not just about costs, but about behaviour.

The next step is connecting these projections with budgets and anomalies, closing the loop between planning, tracking, and reacting.

That’s what the next tools in the FinOps Toolkit aim to do.

👉 Explore forecast_costs.py on GitHub 🎨 Try the live demo (Open-source, MIT licensed, contributions welcome.)