Technology & Architecture

From Data to Decisions: Building an Intelligence Engine from a Complex Domain

An architectural journey from raw events in a complex domain to metrics, patterns, insights, and actions, with a focus on evidence quality, interpretation, profiling, and responsible decision-making.

Visual representation of the journey from DATA to METRICS, PATTERNS, INSIGHTS, and ACTIONS

When I started working on this project, the question seemed simple:

how do we transform thousands of raw events into genuinely useful information for making better decisions?

The project began as a personal engineering lab applied to a domain I know well: online poker.

I was not interested in simply building another tracker capable of displaying statistics. I wanted to understand what happens when we try to trace the entire journey from raw data to a decision.

A personal engineering lab

Over the past few years, my work has progressively shifted from software development towards architecture, Project and Delivery Management, and the coordination of increasingly complex teams and organisations.

Building this product gave me the opportunity to work directly across the full cycle again:

domain → data → architecture → backend → frontend → analytics → intelligence → UX.

It is a technical exercise, but above all a way to think through problems found across many information systems.

Because collecting data is relatively simple.

Turning it into reliable knowledge is much less so.

The initial problem seemed simple

A hand history contains a large number of events:

  • players;
  • positions;
  • stacks;
  • actions;
  • bets;
  • cards;
  • streets;
  • results;
  • tournament context.

Taken individually, they are facts.

The first challenge is to make them structured, consistent, and queryable.

The system must recognise the events, normalise them, and store them while preserving their domain meaning.

From raw data to structured, consistent, and queryable data through parsing, normalisation, and processing.

But establishing a reliable data foundation is only the beginning.

From data to knowledge

The conceptual pipeline I started using is this:

DATA → METRICS → PATTERNS → INSIGHTS → ACTIONS

The journey that transforms data into metrics, patterns, insights, and ultimately actions.

At each step, the value of the information increases, but so does the risk of introducing incorrect interpretations.

An event may be correct.

A statistic calculated from that event may be correct.

And yet the conclusion derived from the statistic may be completely wrong.

This is where the problem stops being solely about software engineering.

A percentage is not yet information

Suppose a player has a certain fold percentage in a particular situation.

On its own, the number says much less than it appears to.

How many opportunities have we observed?

Based on what sample?

In which positions?

In what context?

How stable is that measurement?

Displaying a number is easy. Deciding how much we can trust that number is much harder.

This creates the need to consider at least three elements together:

metric, sample size, and confidence.

It is not enough to know that a behaviour occurred in 70% of cases.

We need to know whether that 70% comes from 3 opportunities or 300.

This radically changes the meaning of the information.

From metrics to profiling

Once we have built sufficiently reliable metrics, we can begin to look for patterns.

Aggression.

Propensity to steal.

Blind defence.

Postflop pressure.

Passivity.

Discipline.

Positional tendencies.

Taken together, these signals make it possible to build a behavioural profile that is more interpretable than a simple list of statistics.

From metrics to behavioural patterns, then to a player profile and actionable opportunities.

The point is not to assign a definitive label to a person.

It is to summarise what the observed data suggests, while also indicating how confident we can be in that interpretation.

The most interesting step: from insights to actions

The part I find most interesting begins when the system tries to transform patterns into actionable opportunities.

For example:

  • an excessive fold frequency may suggest applying more pressure;
  • a very low 3-bet frequency may change how we interpret certain actions;
  • particularly tight blind defence may create steal opportunities;
  • a passive calling range may change how we build pressure across later streets.

But a recommendation without an explanation is of little use.

This is why I am working with the idea of an explicit chain:

diagnosis → evidence → confidence → possible action

An intelligence system should not only say what it has found. It should be able to explain why it found it.

Explainability is therefore not an aesthetic addition to the interface.

It is part of the model.

Intelligence also means responsibility

When we begin to build behavioural profiles, another question emerges.

Just because we can derive something from data, does that mean we should always do so?

The issue naturally extends beyond poker.

Profiling, decision-making systems, the GDPR, the AI Act, and privacy-by-design are making it increasingly important to distinguish between technical capability and responsible use.

A good intelligence system must therefore consider not only the accuracy of its models, but also the transparency of its inferences and how they are used.

From the individual to the population

Analysing an individual profile is useful.

But many behaviours become truly interesting when we can compare them with a population.

An isolated statistic tells us what a player does.

A distribution helps us understand how normal or unusual that behaviour is within the observed context.

This leads to a second layer of the project: Population Intelligence.

Not only:

“how often does it happen?”

but:

“how far does this behaviour deviate from what we normally observe?”

It is an important step because it transforms the database from a historical archive into a tool for comparison.

And artificial intelligence?

AI entered the project primarily as an accelerator for the engineering process.

Code analysis.

Refactoring.

Testing.

Exploring architectural alternatives.

Documentation.

Review.

Prototyping.

But the model I find most useful is not:

prompt → code → product.

It is instead:

Human-driven engineering. AI-accelerated execution.

Decisions about the domain, architecture, trade-offs, and the meaning of the data remain a human responsibility.

AI can dramatically compress the time required to explore, implement, and verify those decisions.

Building the product is teaching me more than the product itself

The most interesting outcome of this project, at least for me, is not the software itself.

It is the questions it continues to generate.

  • When does a sample become meaningful?
  • How do we represent uncertainty?
  • How explainable should a recommendation be?
  • Where does a statistic end and an interpretation begin?
  • How far should we separate persisted facts from derived information?
  • How do we build an architecture that can evolve without losing reliability?

These are technical questions.

But they are also questions of product, governance, and decision-making.

And this is probably what I find most interesting about returning to hands-on building:

behind every line of code are decisions.

And learning to make better decisions is far more interesting than simply writing software.


Read the original post on LinkedIn

← Back to all Insights