Stop measuring Web3 growth with Web2 metrics — Contribution > DAU

orville wang — Sun, 21 Jun 2026 10:03:32 +0000

Disclosure: I work on Opennomos (linked at the end). This is a thinking-out-loud post about a problem we've spent the last year trying to model.

The numbers we report are mostly lies

Ship a Web3 product launch and you've watched this play out:

Week 1: 10,000 wallets connect, TVL spikes, Twitter +5K followers. The CFO smiles. The VC retweets.

Week 8: daily active addresses drop to 300. TVL bleeds back to launch-day levels. The Discord is mostly bots talking to bots.

You know the truth — most of those 10K wallets were airdrop hunters running scripts across three browsers. But you can't write "DAU 12,000 (11,000 are bots)" in the investor update. So we round, we squint, we ship the dashboard.

This isn't any one team failing. It's that we're measuring a fundamentally different system with the wrong instruments.

The Web2 funnel quietly assumes three things Web3 broke

Acquisition → Activation → Retention → Revenue. It assumes:

One user_id ≈ one human. Web3: wallets and humans are many-to-many. One person, ten wallets. Or ten people, one wallet.
Repeated usage signals value. Web3: half the meaningful on-chain actions are one-shots (claim, bridge, swap once and leave).
Behavior correlates with revenue. Web3: there are ten translation layers between a user click and a protocol fee.

Almost every Web3 dashboard in production is built on these broken assumptions, then patched with sybil filters and bot-detection on the way out. We keep trying to make Web2 metrics stop lying about Web3, instead of asking what we should be measuring in the first place.

Stop counting users. Start counting contribution.

The reframe that unstuck us:

Don't measure "who showed up." Measure "who did something, and what that something was worth to the ecosystem."

This view rotates a few things:

A real person operating 3 wallets making 3 meaningful actions has more contribution than one wallet farming 3,000 claims. DAU can't see this. Contribution can.
An AI agent that completes a complex on-chain strategy has measurable contribution — and in Web3 we can actually price and pay it, because wallets are identity and transfers are payment. Web2 filters agents out as "non-human traffic." Web3 should treat them as first-class participants.
A community translation, a bug report, a governance vote — those are real contributions. The funnel model has no slot for them. A contribution model does.

This isn't new economics — "contribution-based rewards" already exists in mechanism design literature. What's new is making it operational in code.

What "operational contribution" needs at the engineering layer

Four hard problems, none of which ship in a weekend:

1. Full-stack event capture

Not just on-chain tx. You need:

Off-chain product actions (clicks, views, dApp social shares)
Community contributions (governance, content, support)
Agent actions — the structural differentiator vs. Web2

In code: SDK + Webhook + Indexer + Agent SDK, four pipes converging into one normalized event table.

2. Auditable attribution

Whose reward, why, traceable end-to-end. Black-box incentive distribution is just rug-pull-on-delay. The model needs at least:

Source attribution — which channel brought this action in
Multi-touch — one conversion can split across multiple contributors with weights
Time decay — early contributors weighted higher than late-arriving airdrop arbitrageurs

3. A rule engine, not hardcoded `if/else`

"What counts as contribution" varies wildly per project: quests in gaming, repeat purchase in commerce, liquidity depth in DeFi, governance quality in a DAO. A growth or PM person needs to define and revise these rules without filing a PR each time. That means a DSL or a visual rule designer, not a Solidity if-tree.

4. Two-way: humans AND agents

This will hit everyone in the next 12 months: a real fraction of your dApp's activity will come from agents — the user's, third-parties', protocol-deployed. Tracking agent contribution and rewarding agents directly — with those rewards routable back to a human operator — is something Web3 can do that Web2 structurally can't.

What we built — Opennomos

An open-source attempt at the above: github.com/NomosGrowth/opennomos

In one paragraph: ingest events (on-chain + product + agent), score contribution (rule engine + multi-touch attribution + sybil resistance), distribute rewards (points / tokens / NFT badges / airdrop weights — composable and auditable). The Studio lets a PM design "5 on-chain actions + 1 governance vote → tier X reward" without writing code.

Current stage is early; the schema is still settling and we're integrating with a handful of partner projects to harden it. Issues, ideas, and "this doesn't match how my project actually works" notes are extremely welcome on the repo.

The open question

Most of the interesting Web3 problems are at the seams where Web2 abstractions don't fit. Growth measurement is one of those seams.

If you've shipped Web3 user incentives at any scale: what do you measure, beyond DAU, that actually correlates with the growth you care about?

Drop a comment or open an issue on the repo. The harder the edge case, the more useful.

Links: GitHub · opennomos.com

DEV Community: orville wang