When I began working on PokerBeacon, the problem seemed relatively straightforward: start with raw data, interpret it and turn it into useful information.
Then the complexity began to shift.
Parsing opened up the question of data quality. Data quality led to metrics. Metrics required confidence and benchmarks. From there came signals, explainability, UX, new backend requirements and, finally, all the implications of packaging, persistence and the lifecycle of a desktop application.
Meanwhile, AI accelerated development, but made it even more important to distinguish execution speed from decision quality.
At that point, the project was no longer merely a technical exercise. It had become a small product engineering laboratory.
Perhaps the most important lesson is this: significant problems rarely remain confined within a single layer.
These are the eight main lessons I am taking with me.
1. Data Is Not the Starting Point. It Is a Responsibility
It is easy to think of data as something that simply arrives: a file, an event, a record to process.
But before it can be used, we need to answer much less straightforward questions: what does it actually represent? Where did it come from? Is it complete? Is it duplicated? Can we trust its semantics?
A parser can finish without errors and a database can contain formally valid records while the analytical result is still wrong.
For this reason, over the course of the project, the pipeline gradually became something closer to:
source → parsing → semantic validation → normalisation → persistence → analytics
rather than simply:
file → database
The difference seems small until decisions are built on top of that data. At that point, it becomes fundamental.
2. Persist Facts. Derive Interpretations
One of the most important architectural decisions was to separate what is observed from what is interpreted.
A played hand, an action or a board are facts. Definitions of metrics, thresholds, benchmarks, signals, archetypes and confidence rules can instead evolve.
If interpretation is crystallised too early in persistence, every future change risks becoming a rewriting of history.
The principle that emerged is simple:
persist facts, derive intelligence.
It is a pattern that goes beyond PokerBeacon: when events are relatively stable but the way we read them can improve, it is better to preserve the former and allow the latter to evolve.

3. A Metric Without Context Is Just a Number
A percentage can be mathematically correct and operationally of little use.
An 80% value calculated from five observations and an 80% value calculated from five hundred observations have the same numerical value, but they do not tell the same story.
For this reason, a useful metric is not merely a value. At the very least, it needs its context: number of observations, opportunities, confidence, benchmark and distance from the reference population.
This decision cuts across the entire product. It changes the analytical engine, the API contract, the UI and, above all, the way the user interprets what they see.
An apparently statistical problem quickly becomes a product problem.
4. Intelligence Does Not Mean Producing More Conclusions
As the number of metrics grows, it is natural to want to increase the number of insights as well.
But the value of an intelligence system does not grow in proportion to the number of badges it can display.
At a certain point, the problem becomes the opposite: reducing complexity without losing important information.
One hundred metrics do not necessarily need to produce one hundred conclusions. They can produce three, provided they are relevant, explainable, contextualised and verifiable.
It is a form of information compression: selecting what genuinely distinguishes a behaviour and bringing it to the surface.
It is also the point at which analytics and product design begin to overlap.
5. Explainability Must Be Designed from the Start
Adding a classification is simple. Explaining why the system produced it is much harder.
If a conclusion must be verifiable, the system needs to retain enough context to reconstruct it: the metrics involved, opportunities, benchmarks, confidence, applied conditions, evidence and even any counter-evidence.
Explainability, therefore, is not a tooltip to add at the end.
It affects the data model, the analytical engine, the API and the interface.
The design consequence is important: if we want to explain a decision tomorrow, today we must retain the information that will make it possible to reconstruct it.
6. UX Is Not About Showing Everything
As the product began to accumulate data, metrics and signals, completeness increasingly became the enemy of readability.
The solution was not simply to remove information, but to organise different levels of depth.
In the Player Profile, for example, the path became:
summary → signals → metrics → hands
The summary provides direction. The signal draws attention to something interesting. The metric explains. The underlying data makes verification possible.
This led to one of the most transferable principles from the entire project:
zoom out to understand, zoom in to verify.
It applies to an analytical dashboard, a monitoring system, a management report and, more generally, any interface that needs to make a large amount of information readable.

7. A Desktop Application Still Has Distributed-System Concerns
The word “desktop” can suggest a simple system because everything runs on the same machine.
In reality, an application composed of Angular, Electron, Spring Boot, a Java runtime and SQLite still has separate processes, lifecycles, boundaries and failure modes typical of distributed systems.
The shell must start and control the backend, manage readiness and shutdown, prevent concurrent instances and keep software separate from user data.
SQLite brings locks, migrations, backup and recoverability. The loopback interface introduces security considerations. Packaging must govern the runtime as well.
The physical deployment is local, but the systemic complexity remains.
Local-first does not mean architecture-free.
8. AI Accelerates Everything, Including Wrong Decisions
AI has radically changed the speed at which it is possible to analyse code, generate implementations, produce tests, document, refactor and explore alternatives.
But the same acceleration also applies to overengineering, regressions, unnecessary abstractions and out-of-scope changes.
For this reason, the process became increasingly explicit:
Problem → Read → Scope → Constraints → Acceptance Criteria → Implementation → Build/Test/Benchmark → Review → Accept or Iterate
AI is extremely useful in execution, but it does not remove responsibility for the decision.
Sometimes the best result of AI-assisted analysis is understanding that the code should not be changed yet.
The principle I am taking with me is therefore:
use AI to accelerate execution, not to outsource judgement.
The Hardest Parts Were Not the Ones I Expected
At the beginning, I would probably have identified parsing, statistics and the interface as the most difficult areas.
In reality, many of the most delicate decisions emerged at the boundaries.
Between data and analytics, when it is necessary to establish what an opportunity actually represents. Between analytics and UX, when confidence must be communicated without creating false certainty. Between backend and frontend, when the API contract must carry enough context to make a metric explainable. Between the desktop shell and the backend, when the lifecycle must be governed. Between AI and engineering, when execution speed and decision quality do not coincide.
Boundaries are often where the real complexity lies.
The Product Also Changed How I Think About Delivery
Optimising a single layer is relatively simple.
The backend wants clean contracts. The frontend wants data that is easy to consume. The database wants efficient queries. UX wants simplicity. Packaging wants reliability.
The product has to hold everything together.
This continually leads to choosing solutions that are not perfect for any single component, but are better for the system as a whole.
It is also the point at which product engineering and delivery management become very close: both require priorities, trade-offs, sequencing, risk management, an understanding of dependencies and the ability to recognise when something is solid enough to move forward.
The Best Solution Is Often the One That Leaves More Options Open
Throughout the project, I increasingly tried to avoid making irreversible decisions too early.
Separate the parser from the domain. Do not embed the source in the model. Derive signals rather than persist them as absolute truths. Keep software and user data separate. Introduce new abstractions only when there is a concrete problem that justifies them.
Reversibility reduces the cost of change.
And, ultimately, this is what good architecture is primarily for: making change sustainable.
Measure Before You Optimise
Many times, something seems slow, large or fragile.
The temptation is to intervene immediately. But the most useful step is often to measure.
In the project, this approach made it possible, for example, to verify the actual effect of lazy loading on the frontend and to measure the parser’s reliability and throughput before deciding whether to optimise it further.
Numbers are not there to make a generic claim that a product is fast or efficient.
They are there to establish the actual state before making the next decision.
Measure first. Optimise second.
Not Everything Needs to Become a Feature
A side project continually generates new ideas: metrics, visualisations, signals, filters and classifications.
But a product does not necessarily improve by adding more.
Sometimes it improves when we consciously decide that something will not be included.
Time, resources and the user’s cognitive capacity are limited. For this reason, the question cannot simply be “is it useful?”.
It must become:
is it useful enough to justify the complexity, maintenance and cognitive space it introduces?
From Feature to System
Looking back over the journey, the project progressively moved through data, architecture, data quality, statistics, behavioural intelligence, UX and AI-assisted engineering.
But these elements are not truly independent.
An error in the data can emerge in the UI. A UX decision can require a new backend contract. A metric can force us to rethink how opportunities are modelled. An architectural decision can change the packaging. An AI-assisted change can propagate across all these layers.
A product is not the sum of separate layers.
It is a network of decisions that influence one another.

In this system, exploit insights are produced through offline, post-hand analysis of imported hand histories, not as assistance during play.
Eight Lessons, One Idea
If I had to condense the entire journey into one sentence, it would be this:
building a product means governing the relationships between different problems, not solving them one at a time.
Code matters. Architecture matters. Data quality matters. Metrics matter. UX and testing matter. AI can accelerate almost everything.
But value comes primarily from the coherence between these decisions.
This is probably what I am taking away most from the project: not a technology or a framework, but a different way of looking at complexity.
Not merely asking whether a solution works.
Also asking what changes in the rest of the system when we decide to adopt it.
From Product to Method
This article brings the series dedicated to building PokerBeacon to a close.
The project will naturally continue to evolve, but the editorial narrative is changing perspective.
Many of the questions that emerged are not only about software. They are about how we make decisions when technology, people, processes and organisations need to work together.
When does it make sense to introduce a new technology? How do we distinguish a genuine opportunity from a solution looking for a problem? How do we introduce AI while maintaining governance, accountability and control? How do we measure value? How do we turn a successful experiment into something an organisation can actually adopt?
These questions are increasingly close to delivery and governance.
And this is where I want to continue from.
The Next Perspective: AI in Projects
On Lead From Tech, I will continue to use concrete cases such as PokerBeacon, but with a broader objective: turning technical experiences into useful frameworks for governing technology, AI and delivery.
The next strand will begin with a deliberately simple question:
do all projects really need AI?
I will discuss use case selection, AI readiness, data and processes, human-in-the-loop, accountability, governance, adoption and value measurement.
These are topics I am also exploring through the CPMAI programme, but I want to continue examining them primarily from the perspective of those who need to bring them into real projects.
PokerBeacon was the laboratory.
The next step is now to abstract what I have learned.
From product to project.
From technology to governance.
From AI as a tool to AI as a capability to introduce and govern within an organisation.
