I fell in love with Web3 because it promised a trustless, decentralized future - a world where you can truly own your digital assets and identity. But it seems as the space has grown, in some areas, so has the gap between that promise and reality.
The indexing problem
One of the biggest gaps is that most Web3 apps still rely on trusted indexers to turn raw on-chain data into something their app can actually use. It's bad, but understandable when you consider the options. There are basically three:
One: run your own indexer. No middleman, full control. Historically that's a heavy engineering lift. People spend months just getting the pipeline working, and that usually turns out to be the easy part, because then the maintenance begins. Reorgs, schema changes, RPC failures, scaling, all while staying in sync with a chain that never stops. It's notoriously draining. For most teams, it's a non-starter.
Two: a centralized indexer. It's the fastest way to ship, so it's where most teams start. But now there's a single, closed-source company in the middle of your "decentralized" app. You can't verify what it returns, and if it goes down or gets something wrong, so do you and your users. That won't work.
Three: a decentralized protocol like The Graph. This was an awesome innovation for its time, but there's a caveat that is glaring today. To stay decentralized, the protocol has to let anyone run a node. So your app ends up trusting data served by some anonymous operator you've never met.
A weaker model bolted onto a stronger one
How do you ensure that operator is serving you good, correct, uncensored data? The industry's answer is cryptoeconomics: stake tokens, slash bad actors, make lying expensive. But making something expensive doesn't make it impossible. And that's kind of what the whole trustlessness thing is about in crypto.
Ethereum is built on cryptography. Every piece of data on it is verifiable. When you read from the chain directly, you can verify that what you got is real.
The moment you outsource indexing to a cryptoeconomic protocol, you trade that away. You're no longer verifying data. You're betting that lying is too expensive to be worth it. A weaker security model bolted on top of a stronger one. Why did we settle for that?
Why no one had solved it
The answer is because the alternative is extremely hard. It was an area of research, not something we could have today. Cryptographic proof systems are brutal to build. The math is complex and the proofs are often huge and slow. A real-time app can't wait a minute for a block, and multi-megabyte proofs break everything downstream.
But despite being difficult, I believed it was achievable, especially as AI systems were starting to make previously extremely difficult tasks more accessible.
So I built Willow
So I embarked, and what we have today is Willow - the first truly end-to-end cryptographically verifiable blockchain indexing protocol, built on peer-reviewed cryptography and state-of-the-art proof systems. Willow indexes on-chain data and proves it, with proofs small and fast enough for real-time apps. You don't trust the indexer, you verify it, right in your app.
No anonymous operators. No cryptoeconomic hand-waving. Just the security the chain always promised, now extended to your data.
Where we are, and what's next
Today we're live on hosted devnet and looking for:
- Partners to build with
- Developers to put Willow through its paces
- Independent reviewers to pressure-test the cryptography
- Contributors who want to help shape where it goes.
If any of that sounds like you, please reach out.
This is the trustless future Web3 promised. Not as an ideal, but as something you can build on today. Live on hosted devnet and decentralizing from here. Start building verifiable data pipelines.
Follow along, there's a lot more coming.