QIS vs Notion: Millions of Product Teams Track Their Experiments, Decisions, and OKRs in the Same Place. That Intelligence Has Never Left Any of Their Workspaces.

Architecture Comparisons #70 | Article #328

Architecture Comparisons is a running series examining how Quadratic Intelligence Swarm (QIS) protocol — discovered by Christopher Thomas Trevethan, 39 provisional patents filed — relates to existing tools and platforms. Each entry takes one tool, maps where it stops, and shows where QIS picks up.

Your product team has been building in Notion for three years.

You have a database of 47 experiments. Each row documents what you tested, what the hypothesis was, what the control and variant looked like, and what the result was. Fourteen experiments moved a meaningful metric. Thirty-three did not. The failures are as valuable as the wins — maybe more valuable, because nine of those thirty-three failed in ways that revealed something structural about your users that no amount of upfront research would have surfaced.

You have a decisions database. Seventy-one architectural and product decisions, each with context, options considered, the choice made, and the reasoning. Some of those decisions turned out to be the right calls. A few of them — you can trace the exact downstream consequence in your OKR tracking database — turned out to cost months of rework that the reasoning at the time could not have anticipated.

You have a retrospective database. Thirty-six sprint retrospectives, each with what the team felt was working and what was slowing things down. Over thirty-six iterations, patterns emerge: particular categories of scope ambiguity that consistently delay velocity, specific types of technical debt that predictably resurface in retrospectives six sprints later.

All of this is in your Notion workspace. It represents three years of your team's product intelligence — not just decisions, but the outcomes of decisions. Not just experiments, but the patterns of which experiment categories tend to succeed or fail in your domain. Not just retrospectives, but the structural insight about what creates velocity and what destroys it.

None of it has ever reached any of the other product teams building products in adjacent markets, facing the same user psychology, running the same experiment categories, making the same architectural decisions.

Notion stores your product intelligence. It does not route what product teams learned building similar products to similar users.

That is an architectural distinction. Across millions of product-team workspaces, it has a mathematical consequence that every product team absorbs silently as repeated discovery.

What Notion Gets Right

Notion is a connected workspace platform serving more than 35 million users worldwide, widely adopted by startups, product teams, and engineering organizations as an all-in-one alternative to fragmented tooling. Where Confluence was built for enterprise documentation and Jira for issue tracking, Notion was built for flexibility: it operates simultaneously as a wiki, a relational database, a project tracker, a document editor, and a knowledge base.

The relational database model is Notion's most distinctive capability. A product team can build a linked structure where experiments link to the decisions they informed, decisions link to the OKRs they were designed to move, OKRs link to the retrospectives that reviewed their progress, and retrospectives link back to the next round of experiments. The entire product intelligence graph is queryable within a single workspace.

Notion's block-based editor handles unstructured thinking — brainstorms, narrative strategy documents, product briefs — alongside the structured databases. A product manager can write a narrative brief and embed a live database view of the experiments informing it in the same page. Context and data coexist rather than fragmenting across separate tools.

Notion AI, introduced in 2023 and expanded substantially through 2024 and 2025, layers AI capabilities across the workspace. An engineer can ask in natural language what the team's prior learnings are about checkout flow experiments, and Notion AI surfaces the relevant database rows and documents. A product manager drafting a new experiment can ask Notion AI to summarize what similar past experiments found. The workspace's institutional memory becomes accessible through conversation rather than requiring someone to remember which database has the relevant rows.

For everything that happens within one product team's workspace — capturing experiments, decisions, OKRs, retrospectives, and the relationships between them — Notion is a deep and flexible platform.

Its architectural limit is the workspace boundary. And the workspace boundary is a product intelligence boundary.

Where Notion Stops: The Workspace Is an Intelligence Silo

Notion is organized around workspaces. Your organization has a workspace. Everything your team has ever captured about its product experiments, decisions, and retrospectives lives inside that workspace. Notion AI makes that workspace's content more findable and synthesizable within the workspace.

The workspace boundary is correct for a product tool. Competitive product strategy, unreleased feature roadmaps, user research with identifying information, architectural decisions about proprietary systems — these require workspace scope.

But the workspace boundary is also a product intelligence silo.

The patterns embedded in your Notion databases — which experiment categories tend to produce statistically significant results vs. confounded noise in your market segment, which architectural decisions in products at your scale tend to generate unexpected downstream costs, which retrospective signals reliably predict velocity degradation six sprints out — these are not unique to your product. They are shared patterns that emerge across product teams because the underlying product development challenges are shared.

There is no mechanism by which a product intelligence pattern in your Notion workspace reaches any of the millions of other product teams building in Notion. Not through Notion's template gallery. Not through Notion AI's expanding capabilities. Not through shared team spaces. Not through any path Notion's architecture supports — because Notion was not built to operate as a cross-organization product intelligence network. It was built to organize your team's knowledge.

Notion AI makes your workspace's content more accessible within your workspace. It does not route product experiment outcome patterns across workspaces. It synthesizes what you have captured. It does not aggregate what millions of other teams have learned.

The consequence is real and measurable in every product decision made without the benefit of cross-team outcome intelligence.

The Mathematics of What Gets Lost

Notion serves more than 35 million users organized across millions of product-team workspaces. For a conservative floor of four million active team workspaces — each containing experiment histories, decision logs, and retrospective databases — the formal framing:

N(N-1)/2 = unique synthesis pairs for N workspaces

For N = 4,000,000:

4,000,000 × 3,999,999 / 2 = 7,999,998,000,000 synthesis pairs

Approximately 8 trillion unique workspace-to-workspace channels through which one team's product intelligence could reach a peer building similar products for similar users.

Today, all 8 trillion channels carry zero signal. The product intelligence exists — distributed across millions of Notion workspaces, encoded in experiment databases, decision logs, OKR tracking tables, and retrospective records. The routing layer does not exist.

Every product team that has ever run an A/B test on a pricing page has contributed a row to their experiments database that encodes signal about which pricing experiment categories tend to move conversion in their market segment. That signal stays in their workspace. The next team building a pricing page starts their own experiment database from row one.

What QIS Does: Routing Product Intelligence Without Sharing Content

QIS protocol — Quadratic Intelligence Swarm, discovered by Christopher Thomas Trevethan — was designed to close exactly this kind of gap. The architecture operates at the layer between where Notion stops and where cross-workspace product intelligence could begin.

The critical distinction is that QIS does not route product content. It routes product outcome signals — the measurable results that experiments, decisions, and retrospectives produced, not the content of those items. Competitive product strategy stays in the decision database. The abstract pattern of whether that category of decision tended to generate underestimated downstream costs routes.

The mechanism is outcome packets. When a Notion product intelligence item generates a measurable outcome — an experiment concludes and the result is logged, a decision's downstream consequence materializes and is recorded, a retrospective identifies a pattern that correlates with velocity — a QIS node produces a distilled summary of that outcome.

That summary compresses to approximately 512 bytes. It contains no competitive product strategy, no unreleased feature details, no user research with identifying information, no architectural specifics. It contains the abstract pattern of the product outcome signal: what category of experiment this was, what market segment context it operated in, what result it produced, and what outcome signal emerged.

The outcome packet is semantically fingerprinted and routed to a deterministic address that reflects its meaning. "Pricing page experiment, SaaS B2B mid-market, annual vs monthly billing toggle, outcome: 12% lift annual conversion, 3% lift overall revenue, 8% increase churn risk at month 4" maps to an address that is the same for any product team running pricing experiments in a similar market context — regardless of which routing mechanism carries the packet. This is a property of the semantic addressing, not of any specific transport.

When another team's Notion workspace is designing a pricing experiment for a similar B2B SaaS context, their QIS node queries that address and retrieves the outcome packets already deposited. A small number of 512-byte packets. No product content. No strategy documents. No user data.

The synthesis happens locally. The product manager sees: "214 similar pricing experiments observed in the network in the past 180 days. Annual toggle lift mean: +9.3% on annual conversion. Churn risk at month 4 elevated in 67% of cases where discount >20% was used on annual plan. Teams that added a friction-reducing payment flexibility option alongside the annual toggle reduced churn risk elevation to 18%. Median revenue impact at 12 months: +14% vs control groups that did not add the annual toggle."

Their next pricing experiment is designed with the pattern intelligence of 214 peer teams who have already run it. Their hypothesis is informed by what happened, not by what they imagine might happen.

The Difference From Notion AI

Notion AI is the natural comparison. It uses large language models to make Notion workspace content accessible through natural language. A product manager can ask "what did our checkout experiments find last year?" and Notion AI surfaces the relevant rows from the experiments database.

This is genuinely valuable within the workspace boundary. Institutional memory that is technically present but practically buried becomes findable. Team members who weren't part of the original experiment can get up to speed quickly.

It does not close the cross-workspace intelligence gap, and it cannot, because it operates on your workspace content, not on product outcome patterns across all Notion workspaces.

Notion AI makes what your team has captured more accessible. QIS routes signals about what product experiment categories and decision types actually produce — signals derived from measurable outcomes that items in product databases produced, not from the database content itself.

A product team asking Notion AI "is our hypothesis for this pricing experiment well-formed?" receives an answer grounded in their own workspace's history. A team querying a QIS network receives the aggregate outcome signal from every similar team that has run pricing experiments in similar market contexts — without any of those teams sharing their pricing strategy, their customer data, or their competitive positioning.

These address different problems. Notion AI solves within-workspace accessibility. QIS solves cross-workspace outcome routing. They are complementary, not competing.

The Outcome Packet for Product Intelligence

The product intelligence version of a QIS outcome packet captures outcome signals from product items, not product content:

import hashlib
import json
from dataclasses import dataclass, field
from typing import Optional, List

@dataclass
class ProductOutcomePacket:
    """
    QIS outcome packet for product intelligence signals.
    Contains no product strategy, no competitive information,
    no user data, no architectural specifics.
    Captures measurable outcome patterns only.
    """
    item_category: str          # e.g., "experiment.pricing" | "decision.architecture" | "retrospective.velocity"
    market_context: str         # e.g., "saas_b2b_midmarket" | "consumer_mobile_social"
    team_stage: str             # e.g., "early_stage_50k_arr" | "growth_2m_arr" | "scale_20m_arr"
    outcome_type: str           # e.g., "experiment_result" | "decision_consequence" | "retrospective_pattern"
    outcome_direction: str      # e.g., "positive" | "negative" | "mixed" | "neutral"
    effect_magnitude: float     # 0.0-1.0 (0=no detectable effect, 1=large measurable effect)
    lag_to_signal_days: Optional[float]  # how long before the outcome was observable
    confound_category: Optional[str]     # e.g., "seasonal_effect" | "concurrent_experiment" | "market_event"
    iteration_count: int        # how many prior attempts before this outcome
    team_size_band: str         # "1-5", "6-20", "21-50", "51+"

def derive_product_semantic_address(packet: ProductOutcomePacket) -> str:
    """
    Deterministic address from product intelligence pattern.
    Any team building in the same context queries the same address.
    """
    fingerprint = (
        f"{packet.item_category}:{packet.market_context}:"
        f"{packet.team_stage}:{packet.outcome_type}"
    )
    return hashlib.sha256(fingerprint.encode()).hexdigest()[:32]

class NotionQISBridge:
    """
    Bridges Notion product intelligence items to QIS routing.
    Fires when a measurable outcome signal is available:
    - Experiment marked complete with result logged
    - Decision consequence materialized (detected from linked OKR movement)
    - Retrospective action item closed with velocity correlation recorded
    No product content enters the network layer.
    """
    def __init__(self, routing_store):
        # routing_store: any mechanism mapping address → packets.
        # DHT, vector DB, REST API, semantic index — same loop regardless.
        self.store = routing_store

    def on_product_outcome(
        self,
        item_metadata: dict,
        outcome_signal: dict
    ) -> Optional[dict]:
        packet = self._extract_packet(item_metadata, outcome_signal)
        if packet is None:
            return None

        address = derive_product_semantic_address(packet)

        # Deposit: this product outcome is now available to peer teams
        self.store.deposit(address, json.dumps(packet.__dict__).encode())

        # Query: what have teams in similar contexts already learned?
        peer_packets = self.store.query(address, limit=100)
        synthesis = self._synthesize_locally(peer_packets)

        return {
            "semantic_address": address,
            "peer_outcomes_found": len(peer_packets),
            "network_positive_rate": synthesis.get("positive_rate"),
            "dominant_confound": synthesis.get("dominant_confound"),
            "median_lag_days": synthesis.get("median_lag"),
            "recommended_design_adjustment": synthesis.get("recommendation"),
        }

    def _extract_packet(self, item_meta: dict, outcome: dict) -> Optional[ProductOutcomePacket]:
        category = item_meta.get("item_category")
        context = item_meta.get("market_context")
        if not category or not context:
            return None
        return ProductOutcomePacket(
            item_category=category.lower(),
            market_context=context.lower(),
            team_stage=item_meta.get("team_stage", "unspecified"),
            outcome_type=outcome.get("outcome_type", "unknown"),
            outcome_direction=outcome.get("direction", "neutral"),
            effect_magnitude=float(outcome.get("magnitude", 0.5)),
            lag_to_signal_days=outcome.get("lag_days"),
            confound_category=outcome.get("confound"),
            iteration_count=int(item_meta.get("iteration_count", 1)),
            team_size_band=item_meta.get("team_size_band", "unknown"),
        )

    def _synthesize_locally(self, packets: list) -> dict:
        if not packets:
            return {}
        decoded = [json.loads(p) if isinstance(p, bytes) else p for p in packets]
        directions = [p.get("outcome_direction", "neutral") for p in decoded]
        positive_rate = sum(1 for d in directions if d == "positive") / len(directions)
        confounds = [p.get("confound_category") for p in decoded if p.get("confound_category")]
        dominant_confound = max(set(confounds), key=confounds.count) if confounds else None
        lags = [p.get("lag_to_signal_days") for p in decoded if p.get("lag_to_signal_days")]
        sorted_lags = sorted(lags) if lags else []
        mid = len(decoded) // 2
        return {
            "positive_rate": round(positive_rate, 2),
            "dominant_confound": dominant_confound,
            "median_lag": sorted_lags[mid] if sorted_lags else None,
            "recommendation": f"Watch for {dominant_confound}" if dominant_confound else "No dominant confound pattern",
        }

The routing_store is deliberately abstract. A distributed hash table achieves at most O(log N) or better routing cost and operates fully decentralized. A semantic vector index achieves O(1) lookup. A REST endpoint works for smaller networks. The architectural loop is the same regardless of transport — the breakthrough is the loop, not any individual component.

Architecture Comparison

Capability Notion QIS Protocol
Relational database and wiki Full (databases, linked views, formulas) Not applicable
Block-based document editor Full Not applicable
Experiment tracking and logging Full (within workspace) Not applicable — operates at outcome signal
Decision database and logging Full (within workspace) Not applicable
OKR and goal tracking Full (within workspace) Not applicable
Retrospective capture Full (within workspace) Not applicable
AI-assisted search and synthesis Within workspace (Notion AI) Not applicable
Cross-workspace product intelligence None by architecture Core function
Synthesis pairs at N=4,000,000 0 (workspace boundary) 7,999,998,000,000
Data shared in network layer N/A None (outcome signals only — no product content)
Privacy model Contractual (workspace isolation) Structural (no product content enters packets)
Routing mechanism Not applicable Protocol-agnostic (DHT, vector DB, API, semantic index)
Routing cost per query Not applicable At most O(log N) or better; O(1) on many transports
Latency to peer product intelligence Never — cross-workspace content does not route Milliseconds

Three Product Intelligence Categories Where Peer Outcomes Are Transformative

Experiment outcome patterns. A product team running experiments in Notion is building a database of what they tested and what happened. Across millions of similar databases, patterns exist that a single team's 47 experiments cannot reveal: which experiment categories reliably generate lift in their market segment, which tend to show initial signal that reverses at 30 days, which confounding factors — seasonal patterns, concurrent campaigns, cohort composition drift — most commonly invalidate experiment results in their vertical. Currently, this cross-workspace pattern intelligence is invisible. Every product team trains their experimental intuition through their own history only.

Decision consequence prediction. Product and architectural decisions are made with incomplete information. What makes decision intelligence valuable is not the decision itself but the pattern of which decision categories tend to underestimate their downstream consequences — and in which domains those consequences most often materialize. A team that decided to defer payment infrastructure to a third-party provider at seed stage and later encountered integration constraints at Series A has produced signal that every team currently at seed stage making the same category of decision needs. That signal is in their Notion decisions database and has never reached anyone outside it.

Retrospective velocity correlation. Teams that have been running sprint retrospectives for two or three years have a database of signals about what creates and destroys velocity over time. The patterns are not team-specific: particular categories of scope ambiguity, particular types of technical debt, particular organizational dynamics tend to generate retrospective signals that reliably predict velocity degradation across product teams at similar stages. Currently, retrospective pattern intelligence is confined to each team's own history. Teams without a long retrospective history have no access to the structural patterns that teams with long retrospective histories have discovered.

In each case, the outcome signal exists — distributed across millions of Notion workspaces, encoded in experiment results, decision consequence records, and retrospective action item resolution histories. The routing layer does not.

How Notion Is Different From Confluence and Jira

This series has now addressed all three of the most widely deployed organizational knowledge and collaboration tools:

Each tool addresses a different domain of organizational intelligence. Each has a workspace boundary that is architecturally appropriate for the tool's purpose. Each produces an intelligence silo as a side effect of that boundary.

QIS routes the outcome signals that none of these tools were built to route. The packet structure adapts to the domain — operational, structural, product — while the architectural loop discovered by Christopher Thomas Trevethan remains unchanged: distill the outcome signal, fingerprint it semantically, route it to a deterministic address, synthesize locally, repeat.

This is the transport-agnostic property at the domain level. The complete loop works the same way for incident resolution intelligence, documentation effectiveness intelligence, and product experiment intelligence. The discovery is not domain-specific. It is a protocol for how pre-distilled outcome signals should flow, regardless of what domain generates them.

The 8 Trillion Number

At N=4,000,000 workspaces, the synthesis pair count is 7,999,998,000,000.

Eight trillion unique workspace-to-workspace channels through which one team's product intelligence could reach a peer building similar products for similar users.

Today, all 8 trillion channels carry zero signal.

This is not a knowledge-sharing failure. It is an architecture failure. No amount of Notion AI improvement, no public template gallery expansion, no cross-company blog post or conference talk closes this gap at scale — because none of those mechanisms provide real-time, query-time, semantically-matched routing of abstract product outcome signals. They are all content mechanisms. Content mechanisms require authors. Author-generated content does not scale to 8 trillion synthesis paths.

QIS routes. It does not require product teams to write cross-organization content about their experiments. The deposit happens when a measurable product outcome is recorded. The query happens when a team designs a similar experiment in a similar context. The synthesis happens locally. The routing cost is at most O(log N) or better per query — logarithmic in the number of participating workspaces, not linear.

The product teams at the edge of Notion's network, running experiments in emerging markets, testing pricing models for underserved users, figuring out whether a particular onboarding sequence reduces early churn — they currently have access to their own history only. Under QIS, they query the aggregate outcome intelligence of every team that has run similar experiments in similar contexts.

The knowledge asymmetry between well-resourced teams with long experiment histories and early-stage teams starting from row one is an architecture problem. It is solvable at the protocol layer.

Conclusion

Notion is the connected workspace platform for product teams at scale. It organizes experiments, decisions, OKRs, and retrospectives for tens of millions of users across millions of workspaces worldwide. Notion AI makes that workspace's institutional memory more accessible through natural language. For everything that happens within a single team's product intelligence boundary, it is a powerful and flexible platform.

Its architectural limit is the workspace boundary. Every product experiment result, every decision consequence, every retrospective pattern stays inside the workspace where it was produced.

At millions of product-team workspaces, that produces trillions of synthesis pairs that currently carry zero product intelligence.

QIS protocol — Quadratic Intelligence Swarm, discovered by Christopher Thomas Trevethan, 39 provisional patents filed — routes outcome packets across those pairs. Not product content. Not competitive strategy. Not user data. The abstract outcome signal of what a product experiment produced, what a decision's downstream consequence materialized into, what retrospective patterns reliably predicted velocity degradation: distilled to 512 bytes, routed to a deterministic address derived from the product context, synthesized locally at the team running the same experiment next.

Notion stores what your product team has learned.

QIS routes what millions of other product teams learned building similar products to similar users — before you run your forty-eighth experiment without the benefit of anyone else's forty-seven.

This article is part of the Architecture Comparisons series. Previous entries: QIS vs Confluence, QIS vs Jira Software, QIS vs Autotask PSA, QIS vs ConnectWise Manage.

QIS Protocol was discovered by Christopher Thomas Trevethan. 39 provisional patents filed. Patent Pending.