Product case

ProductOS — decisions that leave a trail.

Engineering has Git. What about product decisions? This case shows a system that connects signal, evidence, hypothesis, experiment and decision in a single causal graph.

ProductOS — decisions that leave a trail

NuvemDesk Financial demo workspace — fictional data created for this case.

01 — The problem

Engineering has Git. What about product decisions?

In engineering, almost every important change leaves a trail. A commit shows what changed. A pull request shows the context. History makes it possible to see who changed it, when and why.

In Product, the picture is often different. A decision may start in a meeting, on Slack, in an interview, in Analytics, in a support ticket or in a sales request.

Months later, the team finds the same decision and cannot answer the essential question:

Why did we do this?

That pile-up of lost context is the problem I call Decision Debt.

02 — Decision Debt

The cost of forgetting why we decided

Decision Debt happens when the knowledge needed to understand a decision becomes fragmented, outdated or simply disappears.

Re-litigation

Old problems return to the agenda because the original context was lost.

Inconsistent decisions

New teams decide without knowing what was learned before.

Redundant alignment

People have to rebuild context through meetings and conversations.

Lost learning

An experiment ends, but its learning does not necessarily stay.

ProductOS was designed as a response to that problem.

03 — The idea

A continuous causal graph for the product

The core hypothesis of ProductOS is that a decision must stay connected to the context that produced it.

Continuous Causal Graph

01

Signal

What happened?

02

Insight

What did we notice?

03

Opportunity

Which problem deserves attention?

04

Evidence

Which facts support this?

05

Hypothesis

What do we believe might work?

06

Experiment

How will we test it?

07

Result

What happened?

08

Decision

What did we decide to do?

09

Learning

What did we learn?

That chain is the Continuous Causal Graph of ProductOS. Each element answers a different question — and stays linked to the others.

04 — The Product Loop

The product cycle does not end at delivery

The full flow was structured so learning returns and becomes part of the context of the next decisions.

  1. Discovery
  2. Signals
  3. Insights
  4. Opportunities
  5. Prioritization
  6. Hypothesis
  7. Experiment
  8. Result
  9. Decision
  10. Learning
  11. learning feeds the cycle again

05 — The NuvemDesk case

A fictional workspace to show the full loop

To show the platform working, I created the NuvemDesk Financial workspace: a financial-management SaaS for small and mid-size companies.

25,482

active users

1,842

paying customers

R$ 3.8M

ARR in the scenario

148

#erro-ofx tickets

Every figure in this scenario is demonstrative and was created to represent a plausible product situation.

06 — Discovery

Starting from the signals

The first step is to observe what is happening. In the case, signals come from different sources — and they only make sense when they intersect.

Telemetry

A drop in onboarding conversion.

Support

Tickets related to OFX import problems.

NPS

Customers reporting friction with bank reconciliation.

Research

Interviews with finance and accounting users.

Combining those signals moves the team from an isolated observation to a problem hypothesis.

07 — Finding the problem

The problem did not come from a single source

Onboarding telemetry showed a significant drop at the bank-setup step.

68.2%

Baseline

42.0%

setup completion at the OFX file upload step

Crossing that metric with support tickets revealed a pattern: new customers were struggling to import and interpret bank files.

The problem was identified by triangulating quantitative and qualitative data — not from a single source.

08 — From evidence to opportunity

Turning an observation into a work object

From the signals, the PM can create a structured Opportunity.

Direct bank connection via Open Finance

problemevidenceimpactconfidenceefforthypothesesexperimentsdecisions

That turns an observation into a Product work object.

09 — Prioritization

An explicit criterion makes the decision transparent

ProductOS uses an ICE matrix to structure prioritization: Impact × Confidence ÷ Effort.

Impact

5

Confidence

4

Effort

2

ICE Score

10.0

The opportunity then sits first among those evaluated in the scenario. The point is not to claim ICE is the only method — it is to show how an explicit criterion makes the decision more transparent.

10 — Hypothesis

A hypothesis has to be testable

If we connect bank accounts via Open Finance, for new customers during onboarding, we expect bank-setup completion to rise from 42% to over 60%, because the data indicate that a relevant share of drop-off is tied to importing and reading OFX files.

Specific

Defines the action and the audience.

Measurable

Defines the expected impact.

Falsifiable

Can be confirmed or rejected.

Evidence-based

Makes the rationale explicit.

11 — Experimentation

The hypothesis becomes an experiment

A/B test

Baseline

Current flow with OFX upload.

Variant B

Bank connection via Open Finance.

Sample

1,200 new companies

Duration

30 days

Primary metric

Bank-setup completion

12 — Result

The experiment produces evidence — not just an opinion

42.0%

Baseline

58.4%

Variant B

+39%

relative lift

-41%

related support tickets

98.4%

confidence in the scenario

These numbers belong to the case's demonstrative dataset, used to simulate the full decision loop.

13 — Decision Log

Git Blame for Product

SCALE

The decision records outcome, rationale, owner, next steps, evidence and learning — and stays attached to the context that originated it.

  • What did we decide?
  • Why?
  • Based on what?
  • What happened next?

The decision history works like Git Blame for Product: not to track code, but to answer those four questions.

14 — Product architecture

A platform organized around the decision loop

Each module represents a stage or a need in the process.

Overview

A snapshot of metrics and the decision funnel.

Insights

Signals and evidence gathered in one place.

Opportunities

Problems structured as work objects.

Experiments

Hypotheses under test, with metric and scope.

Decisions

An auditable record of what was decided and why.

AI Copilot

AI with access to workspace context.

15 — The traceability core

Opportunity as the center of the model

The Opportunity screen is the center of the model. The intent is for the user to navigate context without rebuilding it by hand.

Opportunity

  • Evidence
  • Hypothesis → Experiment → Result
  • Decision

16 — Contextual AI

AI with product context — not a generic chatbot

The Copilot operates on the context available in the workspace. It can analyze signals, find patterns in feedback, summarize evidence, suggest hypotheses, calculate prioritization and help interpret experiments.

Example

“Which problems show up most often in the last 30 days?”

The AI queries available signals before producing an answer.

Tool calling

The conceptual architecture uses specialized tools so the AI works with structured product information instead of relying on text generation alone.

  1. AI Copilot
  2. AI Orchestrator
  3. Workspace Tools
  4. Workspace Data
  5. LLM
calculateIceRankings()searchWorkspaceSignals()suggestHypothesisTemplate()

18 — Integrations

Signals coming in from different systems

The model was designed to receive signals from Analytics, support, research and Open Finance. In the NuvemDesk scenario, bank connection via Open Finance is the intervention proposed in the experiment.

Analytics

Mixpanel · Amplitude · PostHog

Customer Support

Zendesk · Intercom · Freshdesk

User Research

NPS · Typeform · Hotjar

Open Finance

Pluggy · Belvo

19 — Technical architecture

A working web app, not a mock

ProductOS was built as a navigable product, with domain rules and local-first persistence.

Frontend

React 19 + TypeScript

Build

Vite

Backend

Node.js + Express

Interface

Tailwind CSS

Icons

Lucide React

AI

Google GenAI SDK

Persistence

ProductOSStorage — local-first

Data

NuvemDesk demonstrative dataset

20 — An important technical decision

Product state cannot skip steps

One principle was to block inconsistent transitions. An opportunity should not be marked Resolved without a formal decision attached.

  1. Opportunity
  2. Investigating
  3. Prioritized
  4. Experiment
  5. Resolved

That rule is enforced by the persistence engine. Technology does not only store information — it helps preserve product logic.

21 — Internal structure

Components aligned with the domain

The component architecture follows the product's core concepts, instead of being organized only as generic screens.

src/
├── main.tsx
├── App.tsx
├── types.ts
├── data/
│   ├── nuvemdesk-seed.ts
│   └── storage.ts
└── components/
    ├── Navigation
    ├── DashboardView
    ├── OpportunitiesView
    ├── OpportunityDetailModal
    ├── InsightsView
    ├── ExperimentsView
    ├── DecisionsLogView
    ├── AICopilotDrawer
    ├── PortfolioCaseModal
    ├── NewOpportunityModal
    └── GuidedTourBanner

22 — MVP

Scope meant to prove a core hypothesis

Can the full product decision loop live in a single, traceable experience?

That is why the first scope focused on what was essential to walk the loop.

OverviewInsightsOpportunitiesExperimentsDecisionsAI CopilotDemonstrative datasetGuided tour

Broader features can come later. The MVP exists to prove the concept, not to exhaust it.

23 — Guided Tour

The product itself demonstrates the case

Because the product was created as a portfolio case, there is a guided tour. The goal is for someone who has never used the platform to grasp the concept quickly.

Signal → Insight → Opportunity → Hypothesis → Experiment → Result → Decision

24 — What I wanted to show

Not just development capability

The goal was to build a project that showed work at the intersection of product, experience, data, AI and technology.

Product

Discovery, prioritization, hypotheses, experimentation and decision.

UX

Information architecture, flows and context organization.

Data

Metrics, evidence and quantitative plus qualitative analysis.

AI

Contextual use of language models and tools.

Technology

Architecture, business rules, state and implementation.

25 — The rationale

The interface is the model made visible

The build followed a simple logic. The real work is the structure that connects each step.

  1. Understand
  2. Structure
  3. Prioritize
  4. Test
  5. Measure
  6. Decide
  7. Learn

26 — The outcome

A full loop, with context still connected

The result is a working platform that can represent a complete product decision loop. From a set of signals, the user can:

identify a problem → structure an opportunity → assess priority → form a hypothesis → create an experiment → read a result → record a decision

Context stays connected throughout the process.

27 — Explore the product

The best way to understand the concept is to walk the flow

The environment uses demonstrative data created specifically for this case.

ProductOS — decisions that leave a trail
Explore ProductOS

There is a guided tour inside the platform itself.

28 — Learnings

What building this made clearer

Decisions need architecture too

It is not enough to organize screens and data. The relationships between them have to be structured.

Context is a product asset

A decision without its context loses part of its value over time.

AI needs context

The closer it is to domain data and rules, the more useful an AI application tends to be.

Business rules can live in software

The application can help ensure the process defined by the product is respected.

A good product connects discovery and execution

The distance between understanding a problem and measuring a solution needs to stay small.

29 — Next steps

From a decision log to an intelligence layer

As a concept, ProductOS could evolve into a platform integrated with the real Product ecosystem.

Integrations

Analytics, CRM, support, research and management tools.

Automation

Automatic anomaly detection and opportunity generation.

AI

Continuous signal analysis and pattern detection.

Experimentation

Integration with testing platforms and metrics.

Decision Intelligence

Contextual recommendation based on decision history.

The natural evolution would be to turn ProductOS from a decision-recording system into a continuous intelligence layer for Product.

Decisions leave a trail.

ProductOS was built to make that trail useful.

Shall we build something better?

If you're looking for someone who can talk to Marketing, Product, Design and Technology — let's talk.