This analysis is grounded in a data-driven framework built on pass network structures and Expected Threat (xT). Rather than relying on surface-level metrics, it evaluates how each team organizes possession, how value flows through their passing network, and how attacking sequences evolve under pressure. By combining network centrality, progression patterns and xT dynamics, the objective is to translate what is typically seen qualitatively on the pitch into measurable, repeatable insights — revealing not just where teams play, but how and why their structure generates or destroys value.

Most people will watch Manchester City vs Arsenal trying to answer a simple question:

Who is playing better?

That question is not just incomplete — it actively leads you to the wrong conclusion in this type of match.

Because this is not a game where territorial dominance, possession share, or even isolated chance creation will give you a reliable read. Both teams will have control phases. Both teams will reach their preferred zones. Both teams will produce moments that look like superiority.

And yet, the match will not be decided there.

It will be decided in something much more fragile:

What happens when structure meets resistance.

This is a game where control is constantly tested, where attacking sequences are repeatedly challenged, and where the difference between sustained threat and structural collapse often comes down to a single moment of pressure.

And that is exactly what you should be tracking live.

At the end of this article, there is a live betting checklist designed to help you identify when the match is actually shifting — not when it simply looks like it is.

Poisson probabilities and fair odds

Before getting into the structural layer, the probabilistic baseline already tells you something critical — and it goes against the intuitive narrative.

From the Poisson matrix:

• Manchester City win: 42.00%

• Draw: 32.86%

• Arsenal win: 25.13%

Fair odds:

• Manchester City: 2.38

• Draw: 3.04

• Arsenal: 3.98

This is not a dominant-favorite game.

The draw probability is extremely high, which usually signals a very specific type of match:

• prolonged control phases

• structural cancellation

• limited clean separation

In other words, a match where both teams can impose their structure — but neither can consistently convert that structure into value without something breaking first.

That’s the key dynamic:

This match is structurally stable… until it isn’t.

And when that break happens, it tends to be decisive.

If you want to explore full score distributions and simulation layers, the complete model is available here:

https://app.footballhacking.com

Structural collision

This is not a matchup defined by stylistic opposition in the simple sense of possession versus control.

It is a matchup between two teams that both want to regulate the game through structure, but do so with different value maps.

Manchester City arrive as the more efficient attacking system and the more forceful defensive influence. Arsenal arrive as the more conservative progression structure, with a clearer commitment to central access in the final-third approach, but with weaker attacking conversion from that access.

Both teams show a midfield bottleneck profile, which means the match is likely to be decided less by raw territorial occupation and more by what happens when circulation reaches congestion.

The key question is not who has the ball.

It is which team can preserve value after first resistance.

Structural collision in practice: left vs center

City’s attacking map is tilted toward the left corridor as the main final-third entry lane.

That does not mean they are purely left-sided; it means their possession structure repeatedly finds its most stable route into advanced territory there. They can originate from the left corridor and remain on the left, or begin centrally and still finish on the left. The left corridor is therefore not just a wing outlet but a destination corridor for the whole structure.

Arsenal, by contrast, prefer to progress into the final third through the central corridor. Their highest-frequency and one of their highest-value patterns both terminate centrally, and their strongest value route comes from the right half-space into the central corridor.

Structurally, Arsenal want the game to narrow near the box.

City want to stretch it first and often land on the left before deciding whether to attack the box or recycle.

So the collision is clear:

City want to draw Arsenal across the width and then stabilize on the left corridor.
Arsenal want to protect central access and use central occupation as their own launch point.

Resistance should therefore appear in two main zones.

First, Arsenal will try to compress City’s access once City circulate through midfield and begin leaning toward the left corridor.

Second, City will try to suffocate Arsenal’s central progression before it can become a stable final-third platform.

What happens after resistance is where the matchup separates.

Response to resistance: the central asymmetry

City’s resistance-response profile is mostly constructive.

Even under pressure, they still produce progressive escapes, especially from the right half-space or central defensive zones into advanced territory. That tells you their structure can absorb pressure and still re-emerge facing forward.

Arsenal’s response profile is less stable.

Under resistance in midfield-right or advanced central zones, they are more likely to produce forced value loss, lateral escape, or backward escape.

In structural terms, Arsenal can still reach their preferred zones, but they are less reliable at preserving attacking continuity when the opponent contests the route.

That is the central asymmetry of the match.

Progression pattern

City’s progression pattern is built around recurrence rather than one direct lane.

The most frequent route is left corridor to left corridor, followed closely by central corridor to left corridor. That indicates a system that uses central circulation as a drawing mechanism and the left corridor as the release point.

There is also an important cross-structure pattern:

left half-space → right half-space

This carries very high value relative to its frequency.

That suggests City are not merely wing-loading; they are using one side to disorganize the block and then attacking the far half-space with greater threat.

So City’s underlying pattern looks like this over time:

circulation forms → pressure invited → ball reaches left corridor → second wave → structural relocation

The key point is continuity.

The first entry is often not the decisive one.
The decisive action is frequently the next structural relocation.

Arsenal progression pattern

Arsenal’s progression pattern is narrower and more vertical in intent.

Central corridor to central corridor is their dominant route by volume, and it also carries solid value.

But the most important pattern is right half-space to central corridor, which generates by far the highest value among their listed routes.

That means Arsenal’s best attacking progression is not simply “through the middle.”

It is created when the right half-space becomes the launching pad for central access.

There is also a strong left half-space to central corridor route, so the system can feed the center from either interior lane.

But the right-to-central connection appears to be the sharper one.

🔒 Continue reading to unlock the full breakdown of frequency vs value, defensive reactions, attack continuity and the live betting checklist for this match.

Read more

Manchester United’s 2025/26 season tells a very specific story — one that doesn’t show up in traditional stats, league tables, or even most tactical breakdowns.

On the surface, this is a team that:

• progresses the ball consistently

• reaches the final third at high volume

• imposes territorial control

But underneath, there’s a structural contradiction:

United can arrive in dangerous zones. They just can’t consistently stay there.

That single idea explains almost everything about their season.

Where Manchester United Stand in the Table (Probabilistic View)

Manchester United currently sit 3rd in the table with 55 points, but their position becomes much more interesting when we look at probabilistic outcomes rather than just the standings.

According to the model:

• Title probability: 0.0%

• 2nd place: 0.68%

• 3rd place: 33.48%

• 4th place: 37.05%

• 5th place: 18.29%

• 6th place: 6.80%

Lower positions quickly become negligible.

What this actually means

United are not in a title race.

They are in a tight distribution around Champions League qualification.

The model concentrates ~70% of outcomes between 3rd and 4th place.

That’s crucial.

Because it tells us:

• The team is structurally competitive

• But lacks the consistency to break into the top tier (Arsenal/City level)

The key interpretation

This is not a volatile team.

It’s a bounded team.

Their performance distribution is narrow — but capped.

They are very likely to:

• stay in the top 4 fight

• finish near their current position

But very unlikely to:

• collapse

• or overperform into a title push

Why this matters for the analysis

This probabilistic profile perfectly matches what we see in the structure:

• Strong progression → keeps them competitive

• Weak final-third continuity → prevents elite jump

In other words:

The table is not lying.
It’s just incomplete without structure.

⚡ Want to see this before the match even starts?

If you’re reading this and thinking “this is exactly the kind of edge I need pre-match” — that’s literally what the Football Hacking app is built for.

👉 https://app.footballhacking.com/

Inside the app you get:

• Poisson + Dixon-Coles probabilities (not xG guesses — actual betting-grade modeling)

• Monte Carlo robustness analysis (is the edge stable or fragile?)

• League-specific calibration (ρ adjustment) — no generic models

• Full probability matrices (correct score, match odds, BTTS, totals)

This isn’t just prediction.

It’s decision support under uncertainty.

Structural Identity: Multi-Entry, Center-Finishing

Manchester United are not predictable in how they build.

They are predictable in where the move becomes dangerous.

The data shows:

• Central → Central progression

  • 62.4% of entries

  • +0.0203 ΔxT

• Left half-space → Central

  • +0.0184 ΔxT

• Right half-space → Central

  • +0.0224 ΔxT

This creates a very clear identity:

Multiple entry points. One payoff zone: the central corridor.

That’s actually a good thing.

It means:

• flexibility in buildup

• consistency in attacking intention

But it also creates a hidden risk…

What is ΔxT (Delta Expected Threat)?

ΔxT measures how much a single action increases or decreases a team’s probability of creating a goal.

In simple terms:

• Positive ΔxT → the action moves the ball into a more dangerous area

• Negative ΔxT → the action reduces attacking potential

Unlike basic stats, ΔxT doesn’t just track possession — it tracks how valuable that possession becomes over time.

The Real Problem: Final-Third Instability

United average:

• 95.8 final-third passes per match

That’s elite territory access.

But:

• Final-third net value: negative

This is where things break.

They:

• arrive well

• circulate poorly after arrival

• lose attacking value after first contact

This is not a creativity issue.

It’s a continuity problem.

Progression Patterns That Actually Work

1. Central progression is real (not cosmetic)

This isn’t sterile possession.

High frequency + high ΔxT means:

United genuinely break lines through the middle.

2. Left half-space = decision hub

From this zone, United can:

• go inside (high value)

• go wide (low value)

• recycle

But here’s the key:

Inside continuation is ~3x more valuable than wide continuation.

That’s a decision-making bottleneck, not a structural one.

3. Right side only works if it collapses inward

Right-sided play becomes dangerous only when:

• it feeds the central corridor

Otherwise, it becomes:

• possession without threat

• width without penetration

The Network: Bruno Fernandes Is the System

This isn’t subtle.

Bruno dominates:

• Load centrality → 9 matches

• Closeness → 14

• Eigenvector → 13

• PageRank → 15

That’s not influence.

That’s structural dependency.

What that means in practice

• Bruno = organizer

• Casemiro = stabilizer

• Shaw / Lisandro = left-side continuity

• Dalot = outlet

This is a hierarchical network, not a distributed one.

And that matters because:

When Bruno is disrupted, the entire system loses coherence.

Hidden Mechanism: Progression via Reset

Some of the strongest edges in the network are:

• Defender → Goalkeeper

• Deep reset → Relaunch

Example:

• Shaw → Lammens

• Lisandro → Lammens

This tells us:

United often recover structure by going backwards.

That’s not inherently bad.

But it becomes a problem when combined with…

Dead Circulation Loops

Negative-value connections include:

• De Ligt → Shaw

• Yoro → Dalot

• Mazraoui → De Ligt

These are:

• horizontal

• outward

• low-threat

They:

• keep possession

• kill momentum

This is where attacks quietly die.

Defensive Reality: Control Without Destruction

United’s defensive profile is fascinating.

• Territorial pressure: 0.999 (elite)

• Suppression: 0.672

• Destabilization: 0.425

Translation:

They control where the game happens… but not always how it ends.

Where they actually hurt opponents

• Attacking third (central)

  • negative opponent ΔxT

• Right half-space (high)

• Midfield right half-space

This is where pressing works.

Where they don’t

• Defensive third (central): high volume, low impact

• Defensive right side: even positive opponent ΔxT

Meaning:

When the press is broken, the structure behind it is vulnerable.

Assine agora

Resistance Response: Where Attacks Collapse

This is the key weakness of the season.

After pressure:

Instead of:

• staying near the action

They:

• reset wide or deep

• lose ΔxT

Examples:

• Final third → midfield reset → negative value

• Half-space → defensive third → loss of threat

This confirms the core diagnosis:

United lose continuity after resistance.

Home vs Away: Two Versions of the Same Team

At Home

• xT per 100 passes: 0.794

• Final-third net: positive

• Defensive influence: 0.791

This is the functional version of United.

• broader progression

• stable final-third play

• bottleneck stays in midfield

Away

• xT per 100 passes: 0.368

• Final-third net: negative

• Efficiency drops sharply

Here:

• progression still exists

• but breaks later

• continuity collapses in attack

Most important stat:

Bottleneck reaches the final phase in 31% of away matches (vs 0% at home).

⚡ If you’re betting or trading this team…

You don’t need more opinions.

You need structure + probability.

That’s exactly what the app gives you:

👉 https://app.footballhacking.com/

Use it to:

• compare your read vs model probabilities

• detect over/undervalued markets

• measure risk (Monte Carlo robustness) before entering

Because spotting patterns is step one.

Knowing when to trust them is step two.

Structural Risk Summary

There are three core vulnerabilities:

1. Final-third breakdown

Access is not the issue.

Retention is.

2. Wide/deep recycling

Kills attacking momentum.

3. Defensive gaps (right side, deeper zones)

Expose the team after press bypass.

Final Tactical Insight

Manchester United are:

A Bruno-led, center-finishing system with strong access — but fragile continuity.

They can:

• reach danger zones

• impose structure

• control territory

But they struggle to:

• sustain pressure

• maintain attacking value after disruption

🎯 Final Call-to-Action

If you want to anticipate this BEFORE kickoff — not react to it mid-game:

👉 https://app.footballhacking.com/

Inside you’ll find:

• probability models built for betting (not storytelling)

• robustness layers (so you don’t get trapped in fake edges)

• league-adjusted dynamics most models ignore

Live Match Checklist (Use This)

When watching Manchester United:

• Is Bruno central to circulation?

• Are entries finishing centrally or stuck wide?

• After pressure, do they stay or reset deep?

• Is left half-space feeding inside or outside?

• Is the press creating negative xT or just forcing passes?

• When the opponent breaks the press, especially right side — control or chaos?

If you can answer those in real time…

You’re not watching the game anymore.

You’re reading it.

Assine agora

This match will be played on Saturday, April 18, for Round 33 of the Premier League.

At first glance, this looks like a classic high-profile Premier League clash.

Two big teams. Big names. Big expectations.

But structurally, this is something much more specific.

This is a match between two teams that both experience their main friction in midfield — but react to that friction in completely different ways.

And in games like this, the winner is rarely the team that “plays better.”

It’s the team whose structure survives the interaction.

At the end of this article, you’ll find a live betting checklist designed to help you track whether the game is unfolding as expected — and whether that supports your betting decisions in real time.

Why this matchup is not about possession

It’s tempting to frame this game through familiar lenses:

• Who dominates the ball

• Who creates more chances

• Who controls territory

But those are outputs.

The real question sits earlier in the chain:

👉 What happens when each team meets resistance?

Chelsea arrive as the more efficient and structurally stable side.

Their profile shows:

• higher xT generation per 100 passes

• better final-third efficiency

• stronger defensive suppression

They don’t need long sequences to create value. They need functional sequences.

Manchester United, by contrast, are more structure-oriented but less productive in outcome.

Their profile shows:

• lower progression output

• negative net value in the final third

• heavy dependence on central access

So this match is not about volume.

👉 It’s about whether that volume translates into sustained value.

Understand the edge before the market does

If you want to quantify this kind of structural edge instead of relying on intuition:

👉 The Football Hacking web app gives you:

• Poisson-based match probabilities

• Dixon-Coles adjustments (low-score realism)

• Monte Carlo simulations (robustness of outcomes)

• Fair odds for match, BTTS, and totals

• League-specific diagnosis (pre-live vs live reliability)

👉 https://app.footballhacking.com/

1. Structural collision: right vs central

Chelsea’s attacking structure is not just right-leaning.

It is right-resolving.

Even when they originate centrally or from the left corridor, the attack often ends up on the right side — particularly in the right half-space.

That distinction matters.

👉 Right corridor = volume
👉 Right half-space = value

This pattern is sustained through:

• Enzo Fernández (connective distribution)

• Caicedo (stability and recycling)

• Reece James (right-side facilitation)

Manchester United, on the other hand, are structurally pulled toward the center.

Their most meaningful attacking routes are:

• central corridor → central corridor (frequency)

• half-space → central corridor (value)

Everything converges toward:

👉 Bruno Fernandes as the relational hub

Read more

This analysis is derived from a large-scale database where matches are decomposed through pass networks, expected threat (xT), and graph theory centrality metrics.

That allows us to move beyond what most analyses capture.

Because football at this level is not defined by:

• possession percentages

• shot counts

• or isolated chances

It is defined by:

👉 how teams organize space
👉 how they progress through corridors
👉 and how they reproduce attacking patterns under pressure

This is not a ranking battle — this is a structural confrontation

On paper:

• Borussia Dortmund → 2nd

• Bayer Leverkusen → 6th

But structurally, this game lives in a different dimension.

Dortmund:

• stable positional structure

• repeatable progression routes

• controlled home environment

Leverkusen:

• fluctuating structure

• inconsistent away identity

• reactive spatial behavior

This is not about better vs worse.

👉 It is about structure vs variability

Game environments — what kind of match each team creates

Dortmund at home does not just win games.

They shape them.

• high scoring output

• low concession rate

• consistent defensive control

• stable rhythm

👉 their matches become predictable in structure

Leverkusen away:

• score enough to compete

• concede frequently

• fail to stabilize defensive phases

• oscillate between control and chaos

👉 their matches become unstable environments

Why environment matters

Because when a structured system meets an unstable one:

👉 the unstable system is forced into uncomfortable states

And that is where structural weaknesses appear.

Build-up origins → final third entry: where the game truly begins

To understand this matchup, we need to connect:

👉 where possession starts
👉 where attacking value is generated

Because progression is not random.

It follows paths.

Dortmund — a directional progression model

Dortmund’s attacking identity is not symmetrical.

It is directional and repeatable.

Build-up origin:

• central defensive corridor

• left defensive corridor

These zones:

• stabilize possession

• structure spacing

• initiate progression

Final third entry distribution:

Across matches:

• right corridor → dominant entry lane

• right half-space → consistent secondary channel

• central → situational penetration

• left → minimal contribution

👉 This creates a very clear pattern:

central/left build-up → diagonal progression → right-side entry

Why this matters more than it seems

Dortmund does not rely on unpredictability.

They rely on:

👉 repetition + efficiency

The same pathways:

• are executed repeatedly

• become faster

• become more precise

This leads to:

• consistent final third access

• reduced decision friction

• structural dominance

Progression chains — where attacking value is concentrated

Dortmund’s key passing dynamics show:

• full-backs as vertical accelerators

• central defenders as distribution anchors

• forwards as terminal nodes

And crucially:

👉 the highest-value actions concentrate on the right corridor and right half-space

This aligns perfectly with their entry distribution.

Midfield — not dominant, but essential

Dortmund’s midfield is often misunderstood.

It does not dominate progression.

Instead, it:

• connects phases

• stabilizes transitions

• supports directional play

👉 value is created after midfield, not within it

Leverkusen — absence of structural repetition

Now the contrast.

From the dataset:

👉 there is no consistent relationship between build-up origin and final third entry

This is critical.

Because it means:

• no dominant corridor

• no repeatable attacking route

• no structural reinforcement

Final third entry behavior:

• right corridor → inconsistent

• left corridor → inconsistent

• half-spaces → irregular

• central → occasional

👉 Leverkusen does not arrive in the same spaces consistently

What this means in practice

Without a stable progression route:

• attacking patterns do not consolidate

• efficiency does not increase

• decisions become reactive

This leads to:

👉 variability
👉 unpredictability
👉 and structural fragility

Midfield comparison — continuity vs fragmentation

Dortmund:

• integrated midfield

• supports progression

• maintains continuity

Leverkusen:

• inconsistent midfield role

• unstable connections

• breaks between phases

👉 one connects the game
👉 the other interrupts it

Final third behavior — persistence vs breakdown

Dortmund:

• consistent entry zones

• low breakdown rate

• persistence under pressure

👉 when pressured → they stay in the same corridor

This creates:

• overloads

• defensive fatigue

• eventual structural collapse

Leverkusen:

• inconsistent entry zones

• higher breakdown rate

• reliance on individual actions

👉 attacks are not structurally protected

Resistance vs reaction — how each team behaves under pressure

Dortmund:

• attacking corridors → progressive continuation

• midfield → recirculation

• central attacking zones → high-value progression

👉 pressure does not disrupt structure

Leverkusen:

• pressure → fragmentation

• progression → unstable

• attacks → frequently collapse

👉 pressure breaks their structure

Defensive behavior — disruption vs exposure

Dortmund:

• central defensive control

• disruption of opponent rhythm

• forced low-value actions

In advanced zones:

👉 defensive pressure can collapse entire attacking sequences

Leverkusen:

• inconsistent defensive structure

• poor transition control

• high exposure

👉 they do not control defensive phases

🔒 Premium Section — Tactical Exploitation, Interaction Layer & Where the Game Breaks

From this point forward, we are no longer describing teams.

We are analyzing how they collide.

Because matches like this are not decided by:

• who plays better

• but by whose structure survives the interaction

Read more

If you’ve spent any serious time in football betting, you’ve probably noticed something frustrating: you can be “right” about a game… and still lose money.

You read the match well.
You identified the stronger team.
You even anticipated dominance.

And yet — your bet on goals fails.

Why?

Because most bettors (and even many models) focus on averages, not behavior under pressure.

This is exactly why, in my view, match odds and handicap markets consistently outperform goals markets — both pre-match and especially live.

Let’s break this down properly.

The Core Misconception: Football Is Not Just About Averages

Most betting approaches revolve around things like:

• Average goals scored

• Average goals conceded

• xG numbers

• Historical over/under frequencies

These are useful. But they miss something critical:

Football is a dynamic system driven by necessity, not averages.

A team doesn’t play the same way when:

• It’s winning

• It’s drawing

• It’s losing

And more importantly:

A team’s true strength is revealed when it needs to change the game.

“When It Needs To” — The Most Underrated Concept in Betting

This is the key idea.

Let me put it simply:

• A strong team is not just one that scores more goals on average

• It’s a team that can impose its will when the game demands it

This has huge implications.

Scenario 1 — Favorite Is Losing (or Drawing)

• Time remaining: enough to react

• Game state: unfavorable

• Incentive: maximum

What happens?

• The favorite increases pressure

• Risk-taking increases

• Offensive structure becomes more aggressive

• Game volatility rises

👉 This is where match odds and handicap markets shine

Because you’re not betting on goals — you’re betting on the team’s ability to recover control

Assine agora

Scenario 2 — Favorite Is Winning

• Time remaining: irrelevant in many cases

• Game state: favorable

• Incentive: control, not expansion

What happens?

• Tempo drops

• Risk is minimized

• Possession becomes conservative

• Attacks become selective

👉 This is where goals markets become traps

You may think:

“This game is underperforming in goals — it should correct.”

But in reality:

There is no reason for correction. The game is already solved.

Why Goals Markets Mislead You

Goals betting assumes something like:

“If the match is below average, it will revert upward.”

But football is not a random distribution system.

It is strategic and state-dependent.

Let’s look at the two classic traps:

Trap #1 — Low Goals, Favorite Winning

• You see: “Expected goals not reached yet”

• You think: “There’s value in Over”

But:

• The favorite has no incentive to push

• The opponent may lack quality to break through

• The game enters control mode

👉 Result: slow death → losing bet

Trap #2 — High Goals, Favorite Not Winning

• You see: “Too many goals already”

• You think: “Game is overextended”

But:

• The favorite still needs a result

• Pressure continues

• Game remains open

👉 Result: chaos continues → goals keep coming

What the Market Gets Wrong

Bookmakers are not naive.

But they are constrained by:

• Pre-match goal expectations

• Public betting behavior

• Statistical baselines

This leads to a subtle inefficiency:

Markets often underprice the “reaction capacity” of strong teams

Especially live.

Because:

• They anchor heavily to pre-match expectations

• They adjust slower to behavioral shifts than to raw stats

Why Match Odds and Handicap Markets Capture This Edge

These markets don’t care about how many goals happen.

They care about:

• Who controls the game

• Who needs the result

• Who can impose change

Which aligns perfectly with:

“What the team is capable of doing when it needs to.”

Match Odds

Simple but powerful.

You’re betting on:

• Structural superiority

• Adaptation capacity

• Game state response

Handicap Markets

Even better in many cases.

Why?

Because they allow you to:

• Price partial dominance

• Capture comeback probability

• Reduce variance compared to correct score or goals

Pre-Match vs Live — Same Logic, Different Speed

Pre-Match

You’re essentially asking:

• Which team has higher latent control capacity?

• If the game becomes difficult, who adapts better?

This is where structured models matter.

Live

Now things get interesting.

You can observe:

• Current game state

• Time remaining

• Alignment (or misalignment) with expectations

And ask:

Is the stronger team still in a position where “when it needs to” applies?

If yes → opportunity
If no → avoid

This Is Where Most Bettors Lose Money

Let’s be blunt.

If you’re betting goals without understanding:

• Game state

• Incentives

• Structural strength

You are likely:

👉 Overpaying for variance
👉 Underestimating control
👉 Misreading necessity

And that translates directly into:

Long-term losses — even if your reads feel “correct”

How I Approach This (And Why It Works)

At Football Hacking, I don’t treat matches as static probability distributions.

I treat them as:

Adaptive systems driven by pressure, structure, and necessity

That’s why the web app focuses on:

• Poisson models (properly adjusted)

• Monte Carlo simulations (50,000 runs per match)

• League diagnostics (pre-match vs live reliability)

• Fair odds across key markets (including match odds and handicap)

• Final table simulations (context matters more than you think)

👉 https://app.footballhacking.com/

The Real Question You Should Be Asking

Not:

“How many goals should happen?”

But:

“What is this team capable of doing if the game demands it?”

That single shift changes everything.

Final Thought — And a Warning

If you keep betting based only on:

• Goal averages

• xG totals

• Historical over/under trends

You’re playing a game that:

👉 The market already understands
👉 The public overuses
👉 And where margins are razor thin

Meanwhile, the real edge sits in:

Understanding behavior under pressure

And that’s exactly what match odds and handicap markets allow you to exploit.

Assine agora

Want to Go Deeper?

If this way of thinking resonates with you, you’re going to like what I share regularly.

👉 Subscribe to the newsletter for deeper breakdowns, models, and real betting insights.

And if you’re serious about gaining an edge:

👉 Explore the Football Hacking Web App

Because the truth is simple:

If you’re not using structured probabilities, simulations, and league diagnostics…
you are very likely leaving money on the table.

👉 If you want to truly understand how football behaves beyond surface-level stats — and turn that into decision-making — subscribe now. This is where models become actionable.

Most bettors think live betting is about speed.

It’s not.

It’s about context.

Because the same situation —
a favorite losing at 60’ —
means completely different things depending on the league.

And if you ignore that, your model isn’t wrong.

You are.

The Real Problem: Treating All Leagues as Equal

Here’s what almost nobody does:

They build a model…
they validate it…
and then they apply it uniformly across leagues.

That’s the mistake.

Because football leagues are not just different in quality.

They are different in structure.

And that structure determines one thing:

Does your model improve… or degrade… when the game goes live?

Assine agora

Base and Slope: The Hidden DNA of Each League

Let’s simplify this in a way that actually matters for betting.

• Base → how stable the league is at its core (low-score dependency, structural consistency)

• Slope → how the league reacts when volatility increases (game state changes)

Now translate that into live betting:

• High positive slope → the model adapts and often improves

• Near-zero slope → the model holds structure but doesn’t evolve much

• Negative slope → the model becomes less reliable under pressure

But here’s the nuance most people miss:

Slope alone does NOT define live quality.

The interaction between base + slope is what matters.

Read more

If you’ve ever used a football model—even a good one—you’ve probably asked yourself this:

“Can I really trust this prediction?”

Not just in general… but specifically:

• Can I trust this before kickoff?

• Or does this game only become reliable once it starts?

That question is exactly what most models fail to answer.

And that’s precisely what we just solved.

🧠 The Hidden Problem in Football Models

Most football models—Poisson-based or not—give you:

• probabilities

• odds

• maybe even correct score distributions

But they don’t tell you when they are reliable.

And that’s a massive blind spot.

Because the truth is:

Not all leagues behave the same way.

Some leagues are:

• stable

• predictable

• well-behaved pre-match

Others are:

• chaotic

• reactive

• only understandable once the game unfolds

Until now, this was something you had to “feel”.

Now it’s measurable.

Assine agora

⚙️ Introducing League Reliability Diagnosis

We’ve just added a new feature to the app that does something simple—but powerful:

It tells you how reliable each league is for pre-live and live betting scenarios.

No formulas. No complexity exposed.

Just:

• Pre-Live Suitability Score

• Live Suitability Score

• A clear interpretation of what that means

All of this is calculated internally using structural league behavior derived from real match data (not guesswork).

👉 Try it yourself with a 7-day free trial

📊 What This Actually Means in Practice

Let’s break it down.

1. Pre-Live Suitability

This tells you:

How much you can trust the model before kickoff

High score =

• stable scoring patterns

• low structural noise

• consistent behavior

Low score =

• heavy or irregular leagues

• higher model uncertainty

• more caution required

2. Live Suitability

This tells you:

How much the game itself adds useful information

High score =

• strong reaction to match dynamics

• game state matters

• live opportunities emerge

Low score =

• game flow doesn’t add much

• what you saw pre-match is basically what you get

🔥 Why This Changes Everything

This feature answers something that was previously implicit:

Where is the edge actually coming from?

Because now you can clearly separate:

🟢 Pre-Live Driven Leagues

• model already captures most of the truth

• good for early positions

🔴 Live-Driven Leagues

• game state reveals hidden value

• ideal for in-play strategies

🟡 Hybrid Leagues

• both approaches can work

Assine agora

🧩 Real Insight: Same Sport, Different Physics

One of the most surprising discoveries behind this feature is:

Football is not statistically uniform across leagues.

Two leagues can look similar on the surface…

…but behave completely differently under the hood.

Some leagues:

• suppress variance early

• explode later

Others:

• stay flat throughout

• or even become less predictable

This is not opinion.

It’s measurable behavior.

And now it’s visible inside the app.

👉 Unlock league-level intelligence now (7-day free trial)

🧠 Built on Real Model Behavior (Not Heuristics)

This is not a “tagging” system or subjective classification.

It’s derived from how the model behaves under different conditions.

The same engine that powers:

• Poisson score distributions

• Dixon-Coles adjustments

• dispersion and skew analysis

…is used to evaluate:

• structural stability

• responsiveness to match dynamics

So when the app tells you a league is:

• “Excellent for live”

• or “Difficult for pre-live”

It’s not a guess.

It’s a reflection of how reality behaves in that competition.

⚡ From Theory to Action

Let’s make this practical.

Before this feature, your workflow probably looked like:

“This looks like a good spot… I think I’ll enter.”

Now it becomes:

“This league is strong for live, the favorite is not winning, and the game confirms dominance.”

That’s a completely different level of decision-making.

You’re no longer relying on:

• intuition

• isolated stats

You’re combining:

• model output

• league behavior

• game state

🧩 Where This Fits in the App

This feature is already integrated into the main workflow.

Right after selecting a league, you now see:

• Pre-Live Suitability

• Live Suitability

• League Profile (Hybrid / Live-Oriented / Pre-Live Oriented)

This sits before match selection, which is exactly where it belongs.

Because:

Context comes before prediction.

And that’s a principle most tools completely ignore.

🚀 Why This Matters Long-Term

This is not just a UI improvement.

It’s a shift in how betting models should be used.

Instead of asking:

“What is the probability?”

You start asking:

“When should I trust this probability?”

That single shift is what separates:

• casual users

• from structured, data-driven decision makers

💡 Final Thought

There’s a common belief in betting:

“Models don’t work.”

The reality is more nuanced:

Models work—but only if you understand when they work.

This new feature exists to answer exactly that.

And once you start thinking this way…

…it’s very hard to go back.

👉 Start your 7-day free trial and test it yourself

If you’ve been looking for a more structured, data-driven approach to football betting, this is one of those features that quietly changes everything.

And it’s just getting started.

Assine agora

👉 Quick note before we dive in:
If you want to move beyond intuition and start thinking like a data-driven bettor, subscribe to the Football Hacking newsletter and explore the Football Hacking Web App.
Everything you’re about to read—Poisson modeling, Dixon-Coles adjustments, Monte Carlo robustness—is already being applied there in real scenarios.

And one important detail:
this is an ongoing research process.
More leagues are constantly being studied, refined, and added—so the insights you’ll see here are just the beginning of a much deeper framework that keeps evolving.

The Hidden Layer Most Bettors Ignore

Most people think they’re analyzing matches.

They’re not.

They’re reacting to narratives, recent results, or market movement.

But if you’re using a Poisson model—especially with a Dixon-Coles adjustment—you’re already operating at a different level. And once you introduce league-specific base and slope parameters, you unlock something even more powerful:

You stop modeling matches… and start modeling league behavior.

And that changes everything.

The Core Idea (Without Overcomplicating It)

At the heart of this approach is a simple but profound adjustment:

rho = base + slope * (d_total_goals - 1)

This is not just math—it’s interpretation.

• Base tells you how structured a league is

• Slope tells you how that structure reacts to instability
  

Together, they define:

• Predictability

• Stability

• Reliability of your model
  

And ultimately:

Whether your edge is real—or just noise.

Base: The Structural DNA of a League

Think of base as the league’s personality when everything is “normal.”

When dispersion is around 1 (i.e., matches behave close to Poisson expectations), base defines how much low-score outcomes deviate from independence.

What the Data Tells Us

Across the leagues you’ve calibrated, a pattern emerges very clearly:

🔹 Strongly Negative Base (≈ -0.20)

Leagues like:

• LaLiga

• Serie A

• Ligue 2

• Eredivisie
  

These are leagues with strong structural discipline.

Matches tend to:

• Follow tactical expectations

• Respect game state

• Produce more “controlled” outcomes

👉 In practical terms:

These leagues are predictable—not in outcomes, but in distribution of outcomes.

Read more

A small change on the surface…
but a very important step behind the scenes.

👉 The Football Hacking app is officially moving to a new home:

At first glance, you might think: “Okay, just a new URL.” But this move is actually about something much bigger.

🔧 This Isn’t About New Features (Yet)

Let’s be clear — nothing changes in terms of functionality right now.

• Same models

• Same data

• Same dashboards

• Same logic you’re already used to

This is not a “new version” of the app.

👉 It’s the foundation for what comes next.

🧱 Why This Step Was Necessary

Until now, the app was running in an environment that made fast iteration… difficult.

If you want to build something serious — something that evolves consistently — you need the right structure behind it.

Moving to a dedicated domain allows:

• More control over the platform

• Better organization of the system

• A cleaner path for future development

• The ability to scale without friction

In simple terms:

👉 This move is what makes continuous improvement possible.

Assine agora

💡 Why the App Will Become a Separate Subscription

As the app grows, so does the work required to maintain and evolve it.

Even without new features today, there’s already:

• Ongoing model calibration

• Data processing and validation

• Infrastructure management

• Continuous monitoring

Separating the app into its own subscription is what allows:

• Consistent development over time

• Proper support for users

• Long-term sustainability of the project

👉 It’s not about changing the product —
it’s about making sure it keeps improving.

🎁 Premium Newsletter Subscribers — You’re Covered

If you’re already a Premium subscriber to the Football Hacking newsletter, you will:

✅ Continue to have Premium access to the app for a limited period

No disruption. No sudden changes.

This transition is designed to be smooth — and fair to those who’ve been supporting the project.

🧠 Building for the Long Term

This move marks a shift in mindset.

Football Hacking is no longer just something that works today —
it’s something being structured to evolve continuously.

That means:

• More flexibility to improve models

• Faster iteration cycles

• A stronger, more reliable platform

👉 The goal isn’t to change everything overnight.

It’s to build something that gets better every week.

🔮 What This Unlocks

Even though you don’t see new features today, this step unlocks:

• Future improvements without technical bottlenecks

• Better integration between tools

• A more professional and scalable ecosystem

Think of it like this:

👉 Before, development had limits.
👉 Now, those limits are gone.

📬 The Newsletter Is Still the Core

The Football Hacking newsletter remains at the heart of everything.

That’s where you’ll continue to find:

• Deep analytical insights

• Model breakdowns

• Strategy discussions

• Context that makes the data actually usable

👉 If you’re not subscribed yet, this is the best time to join.

Because as the ecosystem grows, the newsletter becomes even more valuable.

📈 Why This Matters for You

If you’re already using Football Hacking, this change means:

• A more stable platform going forward

• Continuous improvements over time

• A project that is being taken seriously at every level

And if you’re considering joining:

👉 You’re getting in at the exact moment things start scaling.

⚡ Final Thoughts

No new features. No flashy updates.

Just something much more important:

👉 A solid foundation to keep building.

This is the kind of step that often goes unnoticed —
but it’s exactly what separates short-term projects from long-term platforms.

Football Hacking is choosing the second path.

👉 Join the newsletter. Follow the evolution. Be part of what’s coming next.

If you build football prediction models long enough, you eventually encounter a frustrating reality.

Sometimes the model works beautifully.

Other times it fails completely.

And the strange part is that the model itself hasn’t changed.

What changed was the league.

Some competitions follow statistical patterns that align remarkably well with probabilistic models. Others produce erratic outcomes, unstable goal distributions, and unpredictable tactical dynamics.

In other words:

Football leagues themselves have different levels of predictability.

This insight is rarely discussed in mainstream football analytics, but it has enormous implications for anyone working with:

• sports data science
• predictive modeling
• betting market analysis
• probability forecasting.

Over the past weeks I ran a large modeling experiment across dozens of professional football leagues to answer a simple but powerful question:

Which football leagues are actually predictable?

To answer that, I evaluated three different prediction tasks:

• Match Odds (Home / Draw / Away)
• BTTS — Both Teams to Score
• Over 2.5 Goals

Each league was ranked using three probabilistic evaluation metrics:

• Log Loss
• Brier Score
• Global Goal Dispersion Index

Together these metrics reveal something deeper than simply “which team wins”.

They reveal how stable the statistical structure of a league actually is.

👉 Explore the Football Hacking web app

Free Preview

If two leagues have the same average number of goals per match, it does not mean they behave the same statistically.

In reality, football competitions vary enormously in terms of:

• tactical consistency
• attacking patterns
• defensive structures
• goal variance.

Some leagues follow distributions that fit extremely well with Poisson-based probability models.

Others exhibit significant overdispersion, where goal variance exceeds theoretical expectations.

This difference has a direct impact on prediction accuracy.

Even a well-designed model will struggle in a chaotic league, while a relatively simple model can perform surprisingly well in competitions where statistical patterns are stable.

In this study, I evaluated dozens of leagues by running rolling predictions and measuring how accurately the model estimated probabilities for:

• match outcomes
• both teams to score
• total goals.

The results produced a ranking of leagues based on their predictability under probabilistic models.

And some of the results are genuinely surprising.

👉 Explore the Football Hacking web app

Methodology: How the League Rankings Were Built

The predictions used in this analysis are based on a structured probabilistic framework built around expected goals.

For each match, the model estimates:

• expected goals for the home team
• expected goals for the away team.

These values are derived from historical attacking and defensive strengths relative to league scoring averages.

Once expected goals are calculated, a Poisson goal distribution is used to estimate the probability of every possible scoreline.

For example:

0–0
1–0
1–1
2–1
2–2
3–1
and so on.

From this distribution we can derive probabilities for various betting markets.

However, real football results deviate slightly from pure Poisson assumptions — particularly for low-scoring matches.

To address this, the model applies Dixon–Coles adjustments, which correct the probabilities of outcomes like:

• 0–0
• 1–0
• 0–1
• 1–1.

These corrections significantly improve the realism of football probability models.

Once probabilities are generated, predictions are evaluated using proper scoring rules.

The Three Metrics Used to Rank Leagues

Read more

If you work with football analytics, sports betting research, or machine learning, access to a large, clean, and structured dataset is often the difference between theoretical ideas and real, testable models.

That’s why I’m excited to announce the release of the Football Matches Dataset (100,000+ Games with Betting Odds) — a structured historical dataset designed specifically for quantitative football analysis, betting market research, and predictive modeling.

This dataset brings together match results, bookmaker odds, implied probabilities, and market margins across more than 100,000 professional football matches, covering multiple leagues and seasons.

Whether you’re a data scientist, bettor, researcher, or football analyst, this dataset provides a solid historical foundation for building and validating football prediction models.

Why Historical Football Data Matters

Most football analytics projects eventually hit the same bottleneck:

Data availability and data quality.

Public football datasets often have one of two problems:

1. They only contain match results

2. They lack structured betting market information

Without odds data, you can’t properly study market efficiency, bookmaker margins, or betting value strategies.

This dataset was designed specifically to solve that problem.

It combines match results and betting market data in a clean structure ready for analysis.

What Makes This Dataset Valuable

The Football Matches Dataset (100,000+ Games with Betting Odds) includes key variables used in sports analytics and betting research.

Core Match Data

Each row represents a professional football match and includes:

• League

• Country

• Season

• Round

• Match date (UTC)

• Home team

• Away team

• Final score

• Match result (home win / draw / away win)

This structure allows you to easily build models based on historical match outcomes and league-level dynamics.

Betting Market Data

Where this dataset becomes particularly powerful is the inclusion of bookmaker market data.

Each match contains:

• Home odds

• Draw odds

• Away odds

• Implied probabilities

• Bookmaker margin (overround)

• Favorite team according to the market

• Indicator showing whether the favorite actually won

This makes it possible to study:

• Market efficiency

• Favorite-longshot bias

• Betting value strategies

• Closing-line value proxies

• Market pricing behavior

These are essential ingredients for serious sports betting research.

Dataset Structure

The dataset contains the following columns:

match_id
league
country
season
season_status
round
date_utc
home_team
away_team
home_goals
away_goals
result
odd_home
odd_draw
odd_away
implied_prob_home
implied_prob_draw
implied_prob_away
bookmaker_margin
favorite_side
favorite_won

The structure follows a flat tabular format, which makes it extremely easy to load and analyze.

For example, loading the dataset in Python is straightforward:

import pandas as pd

df = pd.read_csv("football_matches_dataset.csv")

From there, you can immediately begin building models, visualizations, and research pipelines.

Get the Full Dataset

If you’re serious about football analytics, sports betting research, or predictive modeling, having access to a large historical dataset is essential.

This 100,000+ football matches dataset with betting odds gives you the raw material needed to build models, run backtests, and explore betting market behavior at scale.

Instead of spending weeks collecting and cleaning data, you can start analyzing immediately.

👉 Get instant access to the dataset here:

What You Can Build With This Dataset

This dataset opens the door to a wide range of football analytics and betting research projects.

Here are some of the most powerful applications.

1. Poisson-Based Football Prediction Models

One of the most common approaches in football modeling is the Poisson distribution, which estimates the probability of goals scored by each team.

With over 100,000 matches, you can build robust estimates of:

• Attack strength

• Defensive strength

• Expected goals distributions

• Match outcome probabilities

These can then be compared against bookmaker odds to identify potential value bets.

2. Betting Strategy Backtesting

If you want to test betting strategies, historical data is essential.

This dataset allows you to backtest ideas such as:

• Betting on market underdogs

• Betting on home favorites

• Value betting based on model probabilities

• Strategies based on bookmaker margin

• Filters by league or season

Instead of guessing whether a strategy works, you can simulate thousands of historical bets.

3. Machine Learning Models

Because the dataset is large and structured, it can easily be used for machine learning experiments.

Examples include:

• Logistic regression models

• Gradient boosting classifiers

• Neural network predictors

• Outcome probability estimators

Potential target variables include:

• Match result

• Favorite wins

• Probability calibration

You can also generate additional features such as:

• Rolling team performance

• League-level goal averages

• Market-implied strengths

4. Betting Market Efficiency Research

Another fascinating application is studying how efficient football betting markets actually are.

Using this dataset, you can analyze:

• Whether favorites win as often as the market predicts

• How bookmaker margins vary across leagues

• Whether implied probabilities are well calibrated

• Market bias patterns across seasons

These insights are particularly valuable for academic research and professional betting analysis.

5. Football Data Visualization Projects

For those who enjoy building dashboards or analytics tools, this dataset is also perfect for visualization.

You can build charts such as:

• League goal distributions

• Favorite win rates

• Odds vs result comparisons

• Market margin analysis

• Season-level trends

If you want inspiration for what this kind of analysis can look like, you can explore the Football Hacking analytics app:

The app demonstrates the type of data-driven football insights that can be built from structured datasets like this one.

File Format and Compatibility

You will receive the dataset in a clean CSV file:

football_matches_dataset.csv

It works seamlessly with:

• Python (Pandas, NumPy, Scikit-Learn)

• R

• SQL databases

• Excel

• Google Sheets

• Data visualization tools

This makes it suitable for both advanced data scientists and analysts working with spreadsheets.

Built for Data Science Workflows

The dataset was intentionally structured to integrate easily with data science pipelines.

Because it follows a simple tabular format, you can:

• Import it directly into Python or R

• Store it in SQL databases

• Use it in machine learning workflows

• Create dashboards and analytics tools

In other words, it is designed to get you analyzing immediately instead of spending hours cleaning raw data.

Important Note About Current Seasons

Some leagues in the dataset may still be in progress.

These matches are clearly labeled using the:

season_status

column.

This allows you to easily filter between completed seasons and ongoing competitions when performing analysis or backtests.

Created by Football Hacking

This dataset is part of the Football Hacking ecosystem, a project dedicated to:

• Data-driven football analysis

• Probabilistic modeling of football matches

• Sports betting research

• Quantitative football analytics

The goal is simple:

Use data to understand football outcomes and betting markets more objectively.

If you’re interested in seeing the type of models and analytics that can be built from structured football data, explore the Football Hacking app:

Final Thoughts

Football analytics and sports betting research both depend heavily on high-quality historical data.

The Football Matches Dataset (100,000+ Games with Betting Odds) provides exactly that: a large, structured dataset combining match results and betting market information.

With over 100,000 matches, it becomes possible to:

• Build robust predictive models

• Backtest betting strategies

• Study betting market efficiency

• Train machine learning algorithms

• Create football analytics dashboards

For anyone serious about football data science or betting research, this dataset provides a powerful starting point.

If you want to explore what can be built from structured football data, take a look at the Football Hacking app:

And if you want to run your own analyses, models, and backtests, the 100,000+ match dataset gives you the raw material to do exactly that.

Turn Football Data Into Real Insights

Behind every serious football model, betting strategy, or analytics project is one thing: reliable historical data.

This dataset gives you 100,000+ structured football matches with betting market information, ready for immediate use in Python, R, SQL, Excel, or any analytics workflow.

Whether you want to build prediction models, analyze betting markets, or backtest strategies, this dataset gives you the data infrastructure to do it.

👉 Get the Football Matches Dataset (100,000+ Games) here:

If you build prediction models for football — especially models based on probability distributions like Poisson — sooner or later you face a crucial question:

How do you know if your model is actually good?

Many people evaluate models using simple metrics like:

• accuracy

• hit rate

• ROI

But these metrics hide a fundamental problem.

A probabilistic model is not supposed to guess outcomes.

It is supposed to estimate probabilities.

And that is exactly where log loss becomes essential.

Log loss is one of the most important metrics in machine learning, forecasting, and predictive modeling. If you work with sports betting models, understanding this metric is absolutely crucial.

Why Accuracy Is a Misleading Metric

Imagine two models predicting the same football match.

Match: Barcelona vs Villarreal

Model A

Outcome Probability

Barcelona win 51%

Draw 25%

Villarreal win 24%

Model B

Outcome Probability

Barcelona win 90%

Draw 5%

Villarreal win 5%

Now imagine Barcelona wins the match.

Both models predicted the correct outcome. If you measure accuracy, both models look equally good.

But in reality they are not.

Model B was extremely confident.
Model A was much more cautious.

If Villarreal had won the match, Model B would have made a massively wrong prediction.

Accuracy completely ignores this difference.

Log loss does not.

What Log Loss Actually Measures

Log loss evaluates how good your probability estimates are.

It measures whether your model assigned appropriate probability to the event that actually occurred.

The principle is simple:

• If your model assigns high probability to the correct outcome, the log loss is low (good).

• If your model assigns low probability to the correct outcome, the log loss is high (bad).

This means log loss punishes overconfidence.

And in probabilistic forecasting, that is extremely important.

Assine agora

The Log Loss Formula

The log loss formula is extremely simple.

Log Loss = -log(p)

Where:

• p = probability assigned to the outcome that actually happened

For example, imagine the real outcome occurs and your model assigned the following probabilities.

Probability assigned Log Loss

0.90 0.105

0.70 0.357

0.50 0.693

0.20 1.609

0.05 2.996

Notice something important.

If your model assigns very low probability to the event that actually happens, the penalty becomes extremely large.

This forces models to stay well calibrated.

Why Log Loss Is Perfect for Betting Models

Football models — especially those based on Poisson distributions — generate probabilities, not predictions.

For example:

Outcome Probability

Home win 47%

Draw 28%

Away win 25%

These probabilities can then be transformed into:

• fair odds

• expected value

• value betting opportunities

But before trusting these probabilities, you must answer one fundamental question:

Are these probabilities actually reliable?

Log loss helps answer exactly that.

It tells you whether your model is:

• well calibrated

• overconfident

• unstable

• poorly specified

Without this type of evaluation, a model might look good just because of variance.

Example: Comparing Two Models Over a Season

Imagine evaluating two models over an entire league season.

Model Average Log Loss

Model A 0.92

Model B 1.12

Even if both models have similar accuracy, Model A is clearly better.

Why?

Because its probability estimates are closer to the true uncertainty of football matches.

This is exactly what matters when building probability-driven betting strategies.

The Relationship Between Log Loss and Market Efficiency

Here is where things become really interesting.

Bookmakers publish odds.

Those odds imply probabilities.

If your model consistently produces lower log loss than the implied probabilities from bookmakers, that suggests something important.

Your model may be capturing information the market is not fully pricing.

This does not guarantee profit.

But it strongly suggests that your model has predictive value.

Where Log Loss Fits Inside Football Hacking

Inside the Football Hacking ecosystem, probabilistic models are evaluated using metrics designed to measure prediction quality rather than just profit.

These include:

• log loss

• probability calibration

• Monte Carlo robustness simulations

• probability dispersion analysis

These tools help distinguish between models that:

• truly understand uncertainty

• only appear good due to variance

If you want to explore how these models behave in practice, you can experiment directly in the Football Hacking web app.

👉 Explore the prediction tools here:

Why Many Betting Models Ignore Log Loss

Many betting models focus only on profit backtests. But profit alone is a very noisy signal.

Short-term variance can easily hide weak models.

Log loss measures something deeper: the quality of probability estimates themselves.

This is why it is widely used in:

• machine learning competitions

• forecasting research

• predictive modeling systems

It is one of the most reliable ways to evaluate probabilistic models.

Turning Probability Models Into Practical Tools

Understanding log loss is only the first step. The real challenge is transforming probability models into decision-making tools.

Inside the Football Hacking platform you can explore:

• Poisson match predictions

• probability distributions

• Monte Carlo robustness simulations

• league table forecasts

All built around transparent, data-driven models.

👉 Try the web app here

Join the Football Hacking Community

If you’re interested in data-driven football forecasting, the Football Hacking newsletter covers topics like:

• statistical modeling in football

• betting market inefficiencies

• probability calibration

• advanced prediction techniques

Some articles are free, while premium subscribers get access to deeper analysis and additional tools.

👉 Subscribe (Free or Premium):

Assine agora

Final Thoughts

In predictive modeling — especially in sports betting — the biggest mistake is confusing correct predictions with good models.

A model can be correct by luck.

But a good model consistently assigns accurate probabilities to events.

That is exactly what log loss measures.

It is not a glamorous metric.

But it answers one of the most important questions in predictive modeling:

Does your model actually understand uncertainty?

A Quick Note Before We Begin

This article is available to both free (partially) and premium subscribers.

However, most advanced articles, deep analytical breakdowns, and the full Football Hacking web app are reserved for premium members.

Premium members get:

• Full access to the Football Hacking web app

• Advanced analytics and prediction tools

• Exclusive research articles on betting markets and modeling

• Detailed breakdowns of football prediction methodologies

👉 Become a Premium Subscriber:

Note: Access to the web app is granted manually after subscription and may take a few hours to activate.

The Invisible Cost Behind Every Betting Market

When bettors look at odds, they usually focus on just one thing:

“What probability does this odd represent?”

For example:

Outcome Odds

Home 2.00

Draw 3.40

Away 3.60

At first glance, this seems straightforward.

But there is a hidden layer that many bettors ignore.

That layer is called bookmaker juice — also known as:

• Overround

• Margin

• Vig

• House edge

And it is one of the most important concepts in sports betting.

If you don’t understand bookmaker margin, you are essentially trying to evaluate markets without seeing their true probabilities.

What is Bookmaker Juice?

Bookmakers do not create fair markets.

Instead, they create markets with built-in margin.

This ensures that the bookmaker always has a mathematical edge over bettors.

Let’s look at the example odds again:

Outcome Odds

Home 2.00

Draw 3.40

Away 3.60

To understand the bookmaker’s margin, we first convert odds into implied probabilities.

The formula is simple:

Probability = 1 / Odds

So we get:

Outcome Odds Implied Probability

Home 2.00 50.00%

Draw 3.40 29.41%

Away 3.60 27.78%

Now we sum the probabilities: 50 + 29.41 + 27.78 = 107.19%

But probabilities should sum to 100%.

The extra 7.19% represents the bookmaker margin.

This is the juice embedded in the market.

Why Juice Matters More Than Most Bettors Realize

Many bettors try to identify value by simply comparing odds with their model predictions.

But there is a critical mistake in that approach.

Bookmaker odds do not represent true probabilities.

They represent probabilities plus margin.

👉 Explore the Web App:

If you compare your model directly to bookmaker odds without adjusting for juice, you are comparing:

• Your fair probabilities

• Against distorted market probabilities

That comparison is flawed.

Professional betting analysis requires removing this margin first.

Only then can you see what the market actually believes.

For full access to all analytical features, research articles, and advanced betting tools:

👉 Become a Premium Subscriber:

Read more

If you like data-driven football analysis, consider subscribing to the Football Hacking newsletter (free or premium).
Premium members get full access to my tools, models, and the complete dataset behind the web app across all leagues in my database.
You can also explore the live models here:

👉 https://footballhacking.streamlit.app/

Poisson-based models are everywhere in football analytics. They’re elegant, interpretable, and often very effective—when the competition behaves in a reasonably stable way.

But not all leagues do.

Some competitions produce tight, controlled matches. Others regularly explode into wild scorelines. If you ignore that difference, your model will quietly misprice the tails—exactly where big wins, big losses, and big mistakes live.

That’s why I rely on a small set of diagnostic metrics to understand how close reality is to a Poisson world and how the extremes behave:

• d_home: dispersion of home goals

• d_away: dispersion of away goals

• d_total_goals: dispersion of total goals

• d_skellam: dispersion of goal difference

• skew: asymmetry of extremes (which side produces more blowouts)

Let’s go through them in practical terms.

Assine agora

Why Dispersion Matters

In a “perfect” Poisson process, variance ≈ mean. So we track dispersion as:

Dispersion = Variance / Mean

• ≈ 1.0 → The data behaves like Poisson expects.

• > 1.0 → Overdispersion: more chaos, fatter tails, more extreme outcomes than the model assumes.

• < 1.0 → Underdispersion: results are more concentrated and controlled than the model assumes.

This directly affects:

• How often your model misses blowouts and collapses

• Whether you overprice or underprice extreme scorelines

• How much you should trust handicaps, totals, and margin markets

d_home: Dispersion of Home Goals

d_home tells you how variable home team goals are compared to a Poisson process.

• ≈ 1.0 → Home goals behave like Poisson.

• > 1.0 → Home scoring is more volatile than expected: more games where the home team either stalls or explodes. The model tends to underestimate big home wins.

• < 1.0 → Home goals are more controlled and concentrated. The model may overestimate extreme home scores.

Decision tip:
If d_home is high, be cautious with large home handicaps and extreme home scorelines.

d_away: Dispersion of Away Goals

d_away measures the same thing for away team goals.

• ≈ 1.0 → Away goals fit Poisson well.

• > 1.0 → Away scoring is more chaotic than expected. The model may underestimate rare high away scores.

• < 1.0 → Away goals are more predictable and concentrated. The model may overestimate extreme away scores.

Decision tip:
If d_away is low, be skeptical of markets that rely heavily on high away scoring (for example, aggressive away team totals or BTTS driven mainly by the away side).

d_total_goals: Dispersion of Total Goals

d_total_goals looks at home + away goals and is especially relevant for Over/Under markets.

• ≈ 1.0 → Total goals behave like Poisson expects.

• > 1.0 → Matches are more chaotic in total scoring. The model may underestimate very high or very low totals.

• < 1.0 → Matches are more controlled. The model may overestimate extreme Overs and wild scorelines.

Decision tip:
If d_total_goals is high, be more conservative with high Over lines and extreme totals.

d_skellam: Dispersion of Goal Difference

Goal difference (home − away) follows a Skellam distribution if both teams are Poisson. A practical diagnostic is:

d_skellam = Var(Home − Away) / Mean(Total Goals)

• ≈ 1.0 → Winning margins look like the model expects.

• > 1.0 → Margins are more spread out: more big wins and heavy defeats. The model may underestimate wide handicaps.

• < 1.0 → Margins are more concentrated: more narrow wins and draws. The model may overestimate big winning margins.

Decision tip:
If d_skellam is high, be extra cautious with large handicaps and exact margin markets.

Skew: This Is NOT Home Advantage

Here’s the crucial clarification:

Skew does NOT measure home advantage or away advantage.

Home advantage is about average performance.
Skew is about the tails: it tells you to which side the extreme results (blowouts, big margins) tend to go.

In football terms, skew answers this question:

When games break, do they break more often into big home wins or big away wins?

• Skew ≈ 0 → Symmetric tails. Big home wins and big away wins happen with similar frequency.

• Skew > 0 → Right-skewed. Extreme results are more often big home wins. The model may underestimate very large home victories.

• Skew < 0 → Left-skewed. Extreme results are more often big away wins. The model may underestimate very large away victories.

This is about blowouts and heavy margins, not about who is better on average.

You can have:

• Strong home advantage but skew ≈ 0 (extremes balanced), or

• Modest home advantage but positive skew (when games explode, they usually explode in favor of the home side).

Decision tip:

• Positive skew → be careful with large home handicaps being too cheap.

• Negative skew → be careful with large away handicaps being too cheap.

How to Use These Metrics Together

Think of them as context and risk filters:

• Dispersion near 1.0 → Poisson assumptions are well supported.

• Dispersion well above 1.0 → More chaos → be conservative with extremes.

• Dispersion below 1.0 → More control → extremes are rarer than the model suggests.

• Skew tells you which side tends to produce the blowouts.

They don’t replace your model. They tell you how much you should trust it, and where it’s likely to fail first.

Explore This in the Football Hacking Web App

All these metrics are available in my tools so you can inspect league behavior before trusting any prediction.

👉 Visit the app: https://footballhacking.streamlit.app/

And an important note:

Premium subscribers get access to the full dataset behind the web app for all leagues in my database.
That means you can download and analyze the same data used in the models.

Final Call to Action

If you care about:

• Football analytics

• Probabilistic modeling

• Understanding when a model should (and should not) be trusted

👉 Subscribe to the Football Hacking newsletter (free or premium).

👉 Explore the web app and the data:

The real edge is not just building models—it’s understanding the environments they live in. That’s how you avoid being fooled by averages and start respecting the extremes.

👉 If you want full access to my models, data, and interactive tools, become a premium subscriber to Football Hacking. Premium members get complete access to the web app, more leagues, and deeper analytics. This is where I publish and maintain everything I actually use in practice.

Football fans love certainty. Bettors love probabilities. Data scientists love models. And somewhere in the middle of all that sits one of the most popular tools in football analytics: the Poisson model.

If you’ve ever tried to predict football scores, you already know the drill: estimate expected goals (λ) for each team, run a Poisson distribution, build a score matrix, and out come the probabilities. Simple. Elegant. Powerful.

But there’s a catch.

If you’ve tested this seriously across multiple leagues, you’ve probably noticed something strange:
the same Poisson model can look great in one league and pretty mediocre in another.

That’s not a bug. That’s a feature of reality.

In this article, I’ll explain why the accuracy of Poisson-based models is strongly related to the technical and structural level of a league, what’s really going on under the hood from a statistical point of view, and how you can use this insight to become more selective, more realistic, and more profitable with your models.

And if you want to explore these ideas in practice, with real data and interactive tools, you can check the Football Hacking web app here:
👉

https://footballhacking.streamlit.app/

The Hidden Assumptions Behind Poisson

Let’s start with something most people skip: what Poisson is actually assuming about football.

When you model goals with a Poisson distribution, you are implicitly assuming that:

1. Goals are rare, discrete events

2. They occur with a stable average rate (λ) over the match

3. Each goal is approximately independent of the previous one

4. The process is stationary enough to be summarized by a single parameter

In plain English, Poisson works best when:

The game behaves like a reasonably stable random process with a consistent scoring rate.

Of course, football is not perfectly like that. Tactics change, red cards happen, teams adapt, psychology matters, and randomness is everywhere. But in some environments, reality is much closer to these assumptions than in others.

And that’s where league quality and structure come in.

Assine agora

High-Level Leagues: More Signal, Less Noise

In top leagues and major competitions, you usually see:

• Better tactical organization

• More consistent game models

• Fewer extreme, chaotic matches

• Higher technical quality in finishing and defending

• More predictable team behavior over time

• Better data quality and more stable lineups

All of this has a statistical consequence:

The goal-scoring process becomes more stable and more regular.

From a modeling perspective, that means:

• The estimated λ values are more reliable

• The variance is closer to what Poisson expects

• Extreme outliers are less frequent

• The distribution of scores looks more “Poisson-like”

In other words, in strong, well-structured leagues, there is more signal and less noise. And simple probabilistic models love that.

This is one of the reasons why Poisson (especially with small corrections like Dixon–Coles) often performs surprisingly well in top European leagues and major competitions.

If you want to see how this looks in practice across different leagues, you can explore the interactive models in the Football Hacking web app:
👉

https://footballhacking.streamlit.app/

Lower or More Chaotic Leagues: When Noise Takes Over

Now let’s look at the other side.

In many lower-tier or structurally unstable leagues, you often find:

• Big tactical inconsistencies

• Large quality gaps between teams

• Frequent individual mistakes leading to goals

• More red cards and game-breaking events

• Poor pitches, travel issues, or unstable squads

• Less predictable match dynamics

Statistically, this creates several problems:

• The true scoring rate is not stable

• Variance tends to be higher than the mean (overdispersion)

• You see more extreme scorelines than Poisson would expect

• The independence assumption between goals is violated more often

• A single event can completely change the nature of the match

The result?

The real data generating process moves away from what Poisson assumes.

So even if your model is coded perfectly, calibrated carefully, and backtested properly, it will naturally perform worse in these environments. Not because Poisson is “bad”, but because the league itself is more chaotic and less statistically regular.

This Is Really About Stability, Not Just “Quality”

It’s tempting to summarize this as “Poisson works better in better leagues”. But that’s a bit too simplistic.

A more precise statement is:

Poisson works better in more stable, structured, and predictable environments.

Technical quality helps, yes. But what really matters is:

• Tactical consistency

• Behavioral regularity of teams

• Lower variance in match dynamics

• A more stationary scoring process

You can even find leagues that are not elite in global terms, but still very stable and structured, where Poisson performs reasonably well. And you can also find high-profile competitions with crazy schedules, heavy rotation, and wild match dynamics, where performance drops.

So the key variable is not fame. It’s statistical stability.

Overdispersion: The Silent Enemy of Simple Models

One of the clearest ways to see this effect is through overdispersion.

In a perfect Poisson world, we expect:

Variance ≈ Mean

But in many real leagues, especially chaotic ones, you often observe:

Variance > Mean

This means:

• More blowouts than expected

• More weird scorelines

• Fatter tails in the distribution

• More uncertainty than your λ can capture

When overdispersion is high, a simple Poisson model will:

• Underestimate extreme results

• Misprice longshots

• Look poorly calibrated in the tails

• Appear “inaccurate”, even if your average predictions are decent

This is not a small technical detail. It’s a structural mismatch between model and reality.

Where Dixon–Coles Helps (And Where It Doesn’t)

The Dixon–Coles adjustment is a smart, practical fix for one very specific problem:
the dependence between low-score outcomes like 0–0, 1–0, 0–1, and 1–1.

In many organized leagues, this correction:

• Improves calibration

• Fixes systematic bias in low scores

• Makes the joint distribution more realistic

But notice something important:

Dixon–Coles does not fix chaos.

If your league suffers from:

• Highly unstable team behavior

• Frequent game-breaking events

• Massive overdispersion

• Rapid regime changes inside matches

Then the problem is much bigger than low-score correlation. You’re no longer dealing with a small correction to a mostly Poisson-like process. You’re dealing with a different process altogether.

What Betting Markets Already Know (And Show You)

Here’s the cool part: bookmakers already encode this uncertainty in the odds.

Remember the concept of overround / juice?

• Big leagues, high liquidity → low margin, tight prices

• Small or risky leagues → higher margin, worse prices

That higher margin is not just greed. It’s risk management.

It’s the market saying:

“This environment is harder to price. There is more uncertainty here.”

Which is exactly the same conclusion your Poisson model is quietly reaching when it starts to miss more often.

Practical Implications for Your Modeling

If you’re building Poisson-based models (like I do in Football Hacking), this leads to some very practical rules:

1. Segment performance by league instead of trusting global metrics

2. Measure overdispersion and calibration per competition

3. Demand a higher edge in noisier leagues

4. Consider shrinking, regularizing, or smoothing λ more aggressively where instability is high

5. Be selective: not all leagues deserve the same confidence or stake size

In other words:

Your model’s accuracy is not just about your code. It’s about the statistical nature of the league you’re modeling.

You can see how this plays out across different competitions in the Football Hacking web app, where I expose the same framework to multiple leagues and markets:
👉

https://footballhacking.streamlit.app/

A Useful Mental Model: Signal vs Noise

Here’s the simplest way to think about all this:

• Strong, stable leagues → More signal, less noise

• Chaotic, unstable leagues → Less signal, more noise

Poisson is a signal-hungry model. It needs a world where the average rate actually means something.

When noise dominates, no amount of elegance in your probability theory will save you.

So, Are You Right?

Yes. Absolutely.

Your intuition is correct: the effectiveness of a Poisson model is strongly related to the technical and structural level of the league—more precisely, to how stable and regular the goal-scoring process is in that competition.

This is not a philosophical opinion. It’s a direct consequence of:

• The assumptions behind Poisson

• The variance structure of different leagues

• The presence (or absence) of chaos in match dynamics

Final Thoughts

Poisson is not magic. It’s a tool. A very good one—when reality cooperates.

The real edge is not just building a better model. It’s knowing where your model deserves to be trusted and where it should be treated with skepticism.

That’s how you move from “I have a model” to:

“I understand the environment my model lives in.”

And that’s where real, long-term edges are built.

Assine agora

👉 If you want full access to my Poisson models, multiple leagues, and the tools I actually use in practice, become a premium subscriber to Football Hacking and use the web app here:
👉 https://footballhacking.streamlit.app/

If you’ve ever wanted a clean, explainable baseline for football predictions—something you can implement in a few functions, test quickly, and ship into a web app—then the Poisson model is still one of the best places to start.

In the Football Hacking web app, the Poisson Predictions page (Poisson Preds) takes match-level data from your MongoDB pipeline, estimates expected goals for each team, builds a scoreline probability matrix with Poisson, applies a Dixon–Coles correction for low scores, and then converts that matrix into the “betting-friendly” views people actually want: 1X2, Double Chance, Draw No Bet, BTTS, and Over/Under lines—plus a heatmap that makes the whole thing instantly readable.

In this post, I’ll walk through your code in detail, but in a way that’s friendly to beginner/intermediate Python users who know pandas and basic stats, and are now leveling up into “real app logic.”

Open the Football Hacking web app and check the Poisson Preds page while you read—seeing the UI and the output tables side-by-side makes everything click faster.

You can also check it on Github.

Why Poisson Works (and Why It’s Not “Perfect”)

In football modeling, Poisson is popular because it maps nicely from a single parameter—λ (lambda), the expected goals—into a full distribution:

So if you estimate:

• λ_home = expected home goals

• λ_away = expected away goals

You can compute the probability of every realistic scoreline: 0–0, 1–0, 1–1, 2–1, and so on.

The catch: goals aren’t perfectly independent. Low scorelines (0–0, 1–0, 0–1, 1–1) often behave slightly differently than vanilla Poisson suggests. That’s exactly why your page includes the Dixon–Coles adjustment.

The Big Picture: What This Script Does End-to-End

At a high level, your page logic has six layers:

1. Pull match stats from MongoDB (FotMob pipeline stored in db.fotmob_stats)

2. Transform raw stats into a tidy DataFrame (stats_to_df)

3. Let the user pick a league and choose teams (Streamlit UI + form)

4. Estimate expected goals from league averages + attack/defense “capacities” (get_goals_metrics)

5. Create a Poisson score matrix and apply Dixon–Coles (get_matrix_poisson + apply_dixon_coles_to_matrix)

6. Compute probabilities and fair odds for common markets + show a heatmap and a performance chart

That’s a solid architecture: small, testable functions + a clean UI orchestration section at the bottom.

Imports and Page Setup: Streamlit + Data + Viz + Stats

import streamlit as st
import pandas as pd
import numpy as np
import plotly.express as px
from football_main_app import db
from scipy.stats import poisson
import matplotlib.pyplot as plt
from matplotlib.colors import LinearSegmentedColormap
import seaborn as sns

What matters here

• Streamlit (st) is the UI engine.

• pandas / numpy handle transformation and numeric work.

• db comes from your main app module, and is presumably a MongoDB client/connection.

• scipy.stats.poisson provides pmf and cdf.

• matplotlib + seaborn render the “Weighted Performance” chart and the colormap for heatmaps.

You also import Plotly Express (px) but you don’t use it in this script. Not a problem, but you can remove it to keep things clean.

Then you configure the page:

st.set_page_config(
    page_title='Poisson Predictions', 
    layout='wide', 
)

Wide layout makes sense here because your UI is very “dashboard-y” (heatmap + chart + multiple tables).

MongoDB Fetch Layer: Cached for 12 Hours

@st.cache_data(show_spinner=False, ttl='12h')
def get_stats(year: int) -> dict:
    YEAR = year
    stats = list(db.fotmob_stats.aggregate([
        {"$match": {"general.season": {"$in": [f"{YEAR}", f"{YEAR-1}/{YEAR}"]}}}, 
        {"$project": {"_id": 0, "general": 1, "teams": 1, "stats": 1, "score": 1, 'result': 1}}
    ]))
    return stats

Why this is smart

• @st.cache_data prevents re-hitting your database every rerun.

• ttl='12h' is a good tradeoff: the page stays fast, and data refreshes twice a day.

• Aggregation pipeline does two important things:

  • $match limits by season strings that appear to be formatted either "2026" or "2025/2026"

  • $project returns only the fields you need, excluding _id

One small note: the function annotation says it returns dict, but you actually return a list of dicts. If you want to be precise, you could annotate it as list[dict].

Assine agora

Turning Raw Match Docs into a DataFrame

The stats_to_df function is doing the heavy lifting of converting nested MongoDB documents into a flat table.

Key features:

• You store league/season/team names

• You store team images (nice for future UI upgrades)

• You compute a weighted performance feature per match for home and away

• You store scoreline and result

weights = np.array([1.12, 1.25, 1.32, 1.50])

This means your weighted performance is not a naive average—it’s a hand-crafted blend where the last metric (xg_op_for_100_passes) is most influential.

You build the values arrays:

values_home = np.array([
    stat['stats']['ball_possession']['home'],
    stat['stats']['passes_opp_half_%']['home'],
    stat['stats']['touch_opp_box_100_passes']['home'],
    stat['stats']['xg_op_for_100_passes']['home']
])
weighted_performance_home = np.average(values_home, weights=weights, axis=0)

Same for away.

Why this is a nice touch in a Poisson page

Even though Poisson predictions are about goals, your page also shows “performance context.” That’s huge from a product perspective: you’re not only spitting out odds; you’re helping the user understand why a team might be stronger in that venue context.

At the end you return:

df = pd.DataFrame({
    'league': leagues, 
    'season': seasons,
    'home': home, 
    'home_image': home_images,
    'away': away, 
    'away_image': away_images,
    'weighted_performance_home': weighted_performances_home, 
    'weighted_performance_away': weighted_performances_away, 
    'score_home': score_home, 
    'score_away': score_away, 
    'goals_sum': goals_sum,
    'result': results
})

That becomes your “league dataset” driving everything else.

League and Venue Goal Averages

You compute a couple of helpful league-level baselines:

def venue_goals_avg(df, column_home, column_away):
    home_goals_avg = df[column_home].mean()
    away_goals_avg = df[column_away].mean()

    return home_goals_avg, away_goals_avg

This is the home/away venue baseline for the league:

• Average home goals

• Average away goals

You also compute total goals average:

def get_total_goals_avg(df, column):
    return df[column].mean()

These league-level averages are important because they anchor your expected goals estimates (λ). Without them, you’d be guessing in a vacuum.

Estimating Expected Goals for a Match

This function is the core of “where λ comes from”:

def get_goals_metrics(df_league, column_team_home, home_team, column_home_scores,
                     columns_team_away, away_team, columns_away_scores,
                     total_home_avg, total_away_avg):

Inside it:

Step 1: compute how much the home team scores at home (within this league dataset)

home_scored_avg = df_league[df_league[column_team_home] == home_team][column_home_scores].mean()

Step 2: compute how much the away team scores away

away_scored_avg = df_league[df_league[columns_team_away] == away_team][columns_away_scores].mean()

Step 3: compute conceding averages (defense)

home_conceced_avg = df_league[df_league[column_team_home] == home_team][columns_away_scores].mean()
away_conceced_avg = df_league[df_league[columns_team_away] == away_team][column_home_scores].mean()

So:

• home conceded = goals the opponents scored when this team was home

• away conceded = goals the opponents scored when this team was away

Step 4: convert into “capacities” relative to league baseline

home_of_cap = home_scored_avg / total_home_avg
away_of_cap = away_scored_avg / total_away_avg

home_def_cap = home_conceced_avg / total_away_avg
away_def_cap = away_conceced_avg / total_home_avg

Interpretation:

• home_of_cap > 1 means the home team scores more than league-average home teams (good attack at home)

• away_def_cap > 1 means the away team concedes more than league-average (weak defense in away matches)

Step 5: expected goals are “attack × opponent defense × league baseline”

home_goals = home_of_cap * away_def_cap * total_home_avg
away_goals = away_of_cap * home_def_cap * total_away_avg

This is a classic strength model pattern. It’s simple, explainable, and works surprisingly well as a baseline.

Building the Poisson Scoreline Matrix

def get_matrix_poisson(home_goals, away_goals, max_goals):
    home_probs = [poisson.pmf(i, home_goals) for i in range(max_goals)]
    away_probs = [poisson.pmf(i, away_goals) for i in range(max_goals)]
    goal_matrix = np.outer(home_probs, away_probs) 

    return goal_matrix

Here’s the important idea:

• home_probs[i] is P(home scores i)

• away_probs[j] is P(away scores j)

• np.outer(home_probs, away_probs) creates a matrix where each cell is:

You set max_goals=7 later, meaning you model scorelines 0..6 for both teams.

Practical note: This “truncates” probabilities above 6 goals. For typical football λ values (like 0.8 to 2.0), the missing mass is small. If you ever start modeling leagues with higher scoring, you might bump this to 9 or 10.

Dixon–Coles Correction: Fixing Low-Score Dependence

This section is gold, because it handles the biggest “Poisson feels a bit off” issue.

You define the τ adjustment:

def dc_tau(i, j, lam_home, lam_away, rho):
    if i == 0 and j == 0:
        return 1 - (lam_home * lam_away * rho)
    if i == 1 and j == 0:
        return 1 + (lam_away * rho)
    if i == 0 and j == 1:
        return 1 + (lam_home * rho)
    if i == 1 and j == 1:
        return 1 - rho

    return 1.0

Then apply it only to the (0,0), (1,0), (0,1), (1,1) cells:

def apply_dixon_coles_to_matrix(P, lam_home, lam_away, rho, normalize=True):
    P_dc = P.astype(float).copy()
    for i in (0, 1):
        for j in (0, 1):
            P_dc[i, j] *= dc_tau(i, j, lam_home, lam_away, rho)

    if normalize:
        s = P_dc.sum()
        P_dc /= s

    return P_dc

Why normalize?

Because once you tweak a few cells, the matrix might no longer sum to 1. Normalization brings it back into a valid probability distribution.

Where does rho come from in your code?

def get_rho(goals_avg):
    if goals_avg >= 3.0:
        rho = -0.02
    elif goals_avg <= 2.6:
        rho = -0.1
    else:
        rho = -0.05

    return rho

This is a heuristic: lower-scoring leagues get stronger negative rho (more correction effect). It’s a nice practical choice for an app feature—simple and stable.

Converting Matrix → Tables and Markets

Heatmap table (scoreline probabilities)

def matrix_to_df(goal_matrix, home_team, away_team):
    max_goals = goal_matrix.shape[0]
    goals_table = pd.DataFrame(
        goal_matrix, 
        columns=[f"{away_team} {i}" for i in range(max_goals)],
        index=[f"{home_team} {i}" for i in range(max_goals)]
    )
    goals_table = goals_table * 100

    return goals_table

This just formats the matrix into a readable DataFrame and converts to percentage.

1X2 + Double Chance + Draw No Bet

home_win_prob = np.tril(goal_matrix, k=-1).sum() * 100
draw_prob = goal_matrix.diagonal().sum() * 100
away_win_prob = np.triu(goal_matrix, k=1).sum() * 100

• np.tril(..., k=-1) = below diagonal → home goals > away goals

• diagonal = draw

• np.triu(..., k=1) = above diagonal → away goals > home goals

Then:

• Double chance “Home” = home win + draw

• Double chance “Away” = away win + draw

• “No Draw” = home win + away win

Draw No Bet is derived by conditioning on “a win occurs”:

any_win_double_chance_prob = home_win_prob + away_win_prob
home_handicap_0 = home_win_prob / any_win_double_chance_prob * 100

That’s exactly what DNB is: probability of home winning given the match is not a draw.

Finally, you compute “fair odds”:

'Odd': np.round(100 / home_win_prob, 2)

Because you’re working in percent. (If you were in decimals, it would be 1/prob.)

BTTS: Both Teams To Score

btts_yes = goal_matrix[1:, 1:].sum()
btts_no = 1 - btts_yes

This is a very clean slice:

• [1:, 1:] means goals ≥ 1 for both teams.

Then fair odds are 1 / probability.

Over/Under Lines (0.5 to 5.5)

Instead of summing the matrix by total goals, you use a Poisson shortcut:

goals = home_goals + away_goals
under = poisson.cdf(i, goals)
over = 1 - under

This works because the sum of two independent Poisson variables is also Poisson:

So totals are easy and fast.

You loop 0..5, creating O/U 0.5 … 5.5 markets.

Formatting Probabilities into a MultiIndex Table

def probs_to_df(probs):
    reform = {(outerKey, innerKey): values
              for outerKey, innerDict in probs.items()
              for innerKey, values in innerDict.items()}
    df = pd.DataFrame.from_dict(reform, orient='index').transpose()
    df.columns = pd.MultiIndex.from_tuples(df.columns)

    return df.round(2)

This is a neat pattern: it produces a single DataFrame with MultiIndex columns like:

• (“Match Odds”, “Home”) → {Prob, Odd}

• (“Match Odds”, “Draw”) → {Prob, Odd}

• etc.

It’s perfect for a dashboard.

Styling: Highlighting the “ROI Zone” Odds

styled_df = df.style.highlight_between(
    color='#5A915A',
    left=1.7,
    right=2,
    axis=1,
    subset=pd.IndexSlice[['Odd'], :]
).format(precision=2)

This is a Football Hacking signature detail: it visually emphasizes odds between 1.70 and 2.00 (your “historical ROI sweet spot” narrative).

Also note: you highlight only the Odd rows via subset=pd.IndexSlice[['Odd'], :].

Plotting Weighted Performance Bars (Home vs Away Context)

def plot_venue_performances(df, home_team, away_team):
    df_home = df[df['home'] == home_team]
    df_away = df[df['away'] == away_team]

    fig,ax = plt.subplots(figsize=(8, 5))
    ax.set_title('Weighted Performance Home/Away', fontweight='bold')
    ...
    sns.barplot(data=df_home, x='home', y='weighted_performance_home', ax=ax,                
               color='#213991')
    sns.barplot(data=df_away, x='away', y='weighted_performance_away', ax=ax,     
                color='#915221')

This chart provides narrative support: you’re not just modeling goals—you’re showing performance metrics that correlate with attacking dominance (possession, touches in box per 100 passes, open-play xG per 100 passes, etc.).

The UI Orchestration: Where Everything Comes Together

At the bottom:

1. Load data:

stats = get_stats(year=2026)
df = stats_to_df(stats=stats)

2. Select league:

league = st.selectbox(... options=sorted(df['league'].unique()))
df_league = df[df['league'] == league]

3. Show dataset:

st.dataframe(df_league.drop(columns=['home_image', 'away_image']), hide_index=True)

4. Select teams with a form:

submitted, home, away = input_form(...)

5. On submit, compute everything:

total_home_avg, total_away_avg = venue_goals_avg(...)
home_goals, away_goals = get_goals_metrics(...)
rho = get_rho(...)
goal_matrix = get_matrix_poisson(... max_goals=7)
goal_matrix = apply_dixon_coles_to_matrix(...)

6. Produce tables:

match_probs = get_match_probs(goal_matrix)
btts = get_btts_probs(goal_matrix)
goal_probs = get_unders_overs(home_goals, away_goals)

7. Render heatmap + chart:

st.dataframe(goals_table.style.background_gradient(...))
plot_venue_performances(...)

8. Render market tables and warnings:

st.warning('These are the fair odds according to the Poisson distribution...')

That warning is important: it sets expectations and protects users from confusing “fair odds” with bookmaker prices.

Practical Notes and “Next Improvements” (If You Want to Evolve It)

If you ever want to push this page from “strong baseline” to “seriously sharp,” here are upgrade paths that keep your current architecture:

• Dynamic max_goals: set it based on λ (e.g., 7 for low λ, 10 for high λ)

• Totals from the matrix: for consistency, derive totals by summing matrix diagonals by (i+j), rather than Poisson-sum shortcut—especially after Dixon–Coles adjustment

• Team sample size guardrails: if a team has few matches in the selected season, shrink estimates toward the league average (simple Bayesian shrinkage)

• Home advantage parameter: explicit multiplier applied to λ_home or to attack/defense capacities

• In-play version: update λ based on time remaining and game state (you’ve already explored this idea elsewhere)

Final Takeaway

This page is a great example of what “Football Hacking style” looks like in code:

• Clean data pipeline → tidy dataframe

• Explainable expected goals estimate

• Poisson matrix for full scoreline distribution

• Dixon–Coles correction for realism at low scores

• Market probabilities + fair odds

• UI that teaches while it predicts

That’s not just a prediction tool—it’s a learning tool, which is exactly what makes it Substack-friendly.

If you want to explore Poisson predictions across leagues and matchups (and see the probability heatmap + fair odds instantly), open the Football Hacking web app and head to Poisson Preds. And if you’re reading this on Substack, consider becoming a premium subscriber—I’ll be publishing deeper builds that go beyond baseline Poisson (and show how to make it survive real-world match dynamics).

If you’ve ever wanted to visualize how a team actually moves the ball on the pitch, pass networks are one of the most powerful (and elegant) tools you can use. They turn raw event data into a tactical map: who connects with whom, where players operate, and which relationships really drive the game.

Before we jump into the code, an important note: the data used to build this kind of pass network can be downloaded directly from the Football Hacking app, exactly as shown in the image above. Instead of being locked into static charts, you can grab the raw CSV files and create your own visualizations, tweak them, and run your own analysis in Python.

That independence is the whole point here. Once you control the data, you control the questions you can ask.

In this article, I’ll walk you through a complete Python script that:

• Loads pass data from a CSV file

• Filters it to a single team (AC Milan, in this case)

• Computes average player positions

• Counts passing interactions between players

• Builds a directed pass network using NetworkX

• Plots everything on a football pitch using mplsoccer and matplotlib

By the end, you’ll not only understand what each line does, but you’ll also know how to adapt this to any team, any match, any league — especially using data downloaded from the Football Hacking app.

Why Pass Networks Matter in Football Analysis

A pass network is more than a pretty graphic. It’s a compact way to answer questions like:

• Who are the main hubs in possession?

• Which players connect most often?

• Is the team building through the center or the flanks?

• Are there isolated players in the structure?

• Who actually controls the tempo?

Instead of looking at hundreds or thousands of individual passes, you get a structural overview of how the team plays.

And the best part? With Python and open libraries, you can build this yourself in a few dozen lines of code.

The Libraries We Use

Let’s start with the imports:

import pandas as pd
from mplsoccer import Pitch
import matplotlib.pyplot as plt
import networkx as nx

Each library has a clear role:

• pandas: for loading and manipulating the CSV data.

• mplsoccer: for drawing a proper football pitch with correct coordinates.

• matplotlib: for general plotting and figure styling.

• networkx: for creating and handling the pass network as a graph (nodes and edges).

This combination is extremely common in football analytics workflows: pandas for data, NetworkX for structure, mplsoccer + matplotlib for visualization.

Loading the Data

df = pd.read_csv('passes_mil_com.csv')
df = df[df['team'] == 'AC Milan']

Here, we read a CSV file containing pass events. This is exactly the kind of file you can download from the Football Hacking app.

Then we filter the dataset to keep only AC Milan’s passes. This is crucial: a pass network usually represents one team’s internal structure, not both teams mixed together.

At this point, df contains only passes made by AC Milan players in this match.

Computing Average Player Positions

Read more

If you’ve ever wanted to go beyond looking at charts and actually get your hands on the data, this update is for you. 👉 Visit the Football Hacking web app today, explore the matches, and you’ll see something new: all the data used to generate the charts is now available for download. And if you’re not yet a subscriber, this is the perfect moment to join the Football Hacking newsletter and follow everything that’s coming next.

Yes, you read that right. From now on, when you explore a match, a team, or a specific visualization in the app, you can also download the underlying dataset and use it however you want. No black boxes. No “trust me, this is what the numbers say.” You get the numbers. You get the control.

This is a big step toward what I believe is one of the most important principles in football analytics: independence.

Why This Changes the Game

Most platforms show you beautiful charts, dashboards, and tables—but that’s where it ends. You’re stuck with someone else’s choices:

• Someone else’s color scales

• Someone else’s chart types

• Someone else’s filters and thresholds

• Someone else’s interpretation of what matters

Now, with the Football Hacking app, you’re not limited to that anymore. You can download the exact same data used to build the visualizations and take it wherever you want: Python, R, Excel, your own dashboards, your own notebooks, your own experiments.

Want to tweak the pitch dimensions?
Change the binning of zones?
Highlight different players?
Compare two matches in a way the app doesn’t show yet?

Go for it. The data is yours.

This is especially powerful if you’re already working with Python and libraries like mplsoccer, which is quickly becoming the standard tool for football visualizations in the data community.

Build Your Own Visuals with mplsoccer

If you’re not familiar with it yet, mplsoccer is a Python library built on top of Matplotlib that makes it much easier to create football-specific charts: pitches, heatmaps, pass networks, shot maps, and much more.

With the data downloaded from the Football Hacking app, you can:

• Recreate the same charts you see in the app

• Customize them to match your style or your club’s branding

• Combine multiple matches into a single analysis

• Build entirely new visualizations that don’t exist yet in the app

For example, instead of just looking at a pass map, you might want to:

• Build a pass network with custom thresholds

• Change node sizes based on a metric you prefer (xT, involvement, touches, centrality, etc.)

• Compare first half vs second half

• Overlay tactical zones or specific patterns

And the best part? You’re no longer dependent on any single tool or interface. You’re building your own analytical workflow.

Independence Is Not a Buzzword

In football analytics, independence is everything.

When you control the data, you control:

• The questions you can ask

• The hypotheses you can test

• The stories you can tell

• The mistakes you can discover and fix

Relying only on ready-made charts is comfortable, but it also puts a ceiling on your growth. You start thinking in terms of “what the tool allows me to see” instead of “what I want to investigate.”

By making the data downloadable, the Football Hacking app becomes not just a place to consume insights, but a place to start your own analysis.

And that’s exactly the point.

👉 If you haven’t yet, go to the Football Hacking web app now, explore a match, download the data, and try building your first custom chart. Also, subscribe to the Football Hacking newsletter to stay close to everything that’s coming next.

Assine agora

A New Premium Series Is Coming (Including Pass Networks)

This update is also a preview of what’s ahead.

Very soon, I’ll be launching a new series for premium subscribers where I’ll walk you step by step through building different types of football visualizations using Python and mplsoccer.

We’ll cover things like:

• Shot maps and chance quality visualizations

• Heatmaps and positional maps

• Progressive actions and zone-based charts

• Pass networks (yes, properly built and interpreted)

• And several other practical, match-analysis-driven graphics

The idea is simple: you’ll use the same data you can download from the app, and I’ll show you how to turn it into clear, insightful, and professional-looking charts.

If you’ve ever looked at a visualization and thought, “I wish I knew how to build this myself,” this series is for you.

From Viewer to Builder

This is the shift I care most about.

Not just giving you charts.
Not just giving you metrics.
But giving you the tools and the data to become a builder of your own analysis.

Whether you’re a student, an analyst, a coach, a content creator, or just someone obsessed with understanding the game more deeply, having access to the raw data changes how you think. You stop being a spectator of analytics and start becoming an active participant in the process.

And that’s exactly what Football Hacking is about.

Start Today

Here’s what I recommend you do right now:

1. 👉 Visit the Football Hacking web app

2. Explore a match or a team

3. Download the data used in the charts

4. Open Python and try a simple mplsoccer plot

5. See how much freedom you suddenly have

And if you want to follow the upcoming tutorials, deep dives, and the full visualization series, become a subscriber to the Football Hacking newsletter—especially the premium tier, where all the hands-on content will live.

This is just the beginning. The data is now in your hands. Let’s build something great with it. ⚽📊

If you care about football beyond narratives and headlines, this is one of those moments where the numbers actually tell a fascinating story. Manchester United’s 1–1 draw against Leeds United marked the end of Rubem Amorim’s stint and the beginning of a new chapter, first under an interim setup and then under Michael Carrick. Since then, something has clearly shifted. The eye test hints at it. The table suggests it. But today, we’re going to do what really matters: follow the data.

All the metrics you’ll see discussed here were extracted directly from my MongoDB database and processed and analyzed using Python. No vibes. No highlight clips. Just structured, reproducible analysis. And if you want to explore these numbers interactively, with filters, comparisons, and intuitive visuals, make sure to visit the Football Hacking web app. It’s the fastest way to turn raw football data into real insight.

Before we dive in: if you enjoy this kind of deep, data-driven football analysis, consider subscribing to the newsletter—especially the premium tier. That’s where I publish the most detailed breakdowns, methodologies, and experimental metrics you won’t find anywhere else on the internet. If you’re serious about understanding the game through numbers, that’s where you want to be.

Now, let’s talk about what actually changed at Manchester United.

The Context: Same Squad, Different Signals

Managerial changes often come wrapped in emotional narratives: “new energy,” “fresh ideas,” “a psychological boost.” Sometimes that’s true. Sometimes it’s just noise. The only way to separate signal from storytelling is to look at performance indicators that describe how a team plays, not just what the scoreboard says.

In this article, we’ll focus on a few core pillars:

• xG from open play per 100 passes and its balance (for vs. against)

• Percentage of passes in the opponent’s half

• A split-sample comparison: matches with Amorim vs. matches without him

• Weighted Relative Performance, a custom metric I created

• Poisson-based probabilities for scoring and conceding 2+ goals

• Expected Threat (xT) and Load Centrality in the debut against Manchester City

Again, all of this comes from my own MongoDB database, cleaned, transformed, and analyzed in Python. If you want to explore these dimensions team by team and match by match, don’t forget to check the Football Hacking app.

United at the Top in Open-Play xG per 100 Passes

Let’s start with one of my favorite productivity metrics: xG from open play per 100 passes. Instead of just asking “how much xG does a team generate?”, this metric asks something more interesting: how efficient is a team at turning possession into danger?

Right now, Manchester United sits at the top of the Premier League in this metric. That alone is striking. Even more striking is that they’re also performing very well in the balance of this same metric—meaning the gap between what they create and what they allow is strongly positive.

In practical terms, this suggests two things:

1. United are generating high-quality chances relative to the amount of passing they do.

2. They are not allowing opponents to do the same at the same rate.

Read more

If you made it this far, you’re officially at the final chapter of this web scraping series. And before we write a single new line of code, I want to say Thank You.

Thank you to everyone who trusted my work enough to become a premium subscriber. Your support is what makes it possible to go deeper, build things properly, and publish content that goes beyond surface-level tutorials.

And if you’re reading this and you’re not a premium subscriber yet, this is the perfect moment to become one. This article closes the series with something extremely concrete: we finally turn scraped football data into a real, interpretable visualization.

👉 Upgrade to premium and unlock the full series.

This is also the article where everything clicks.
All the scraping, all the data cleaning, all the small technical decisions finally pay off visually.

So I strongly encourage you to read this post until the end. Not just for the final chart, but because understanding why we structure data this way will make you a much better analyst, scraper, and Python user.

And as always, you can already explore real football insights in my free web app here:
👉 https://footballhacking.streamlit.app/

A Quick Recap: Where We Left Off

Before we move forward, let’s briefly reconnect with the previous step of this journey.

In the last article, we focused on extracting shot data from FotMob, transforming raw API responses into a structured Python dictionary containing information such as:

• Minute of the shot

• Expected Goals (xG)

• Expected Goals on Target (xGoT)

• Shot outcome

• Team identifier

If you haven’t read that post yet, I highly recommend doing so first, because this article builds directly on top of it.

You can find it here:
👉 https://www.footballhacking.com/p/web-scraping-football-data-with-python-2e3?r=30n7hp

Now, instead of stopping at raw data, we’ll take the most important step in any data project:
turning numbers into something we can actually interpret.

Read more