Onchain data and indexing
Indexing looks like a solved problem until you notice that chains rewrite recent history. A naive indexer serves data a reorg has already invalidated, confidently and without an error, which is the worst way for a data system to be wrong.
Why this work is different
Wrong chain data does not announce itself. It flows into dashboards, accounting, and trading decisions looking exactly like correct data, and the gap is usually found by a user rather than by a monitor.
Current and correct are two different guarantees, and most indexing setups quietly trade one for the other. Deciding which one a given consumer actually needs is a design question, not a tuning question.
How we work
Reorg-safety and backfill are first-class requirements from the first commit. Our indexers track finality, roll back invalidated data on reorgs, and only serve state that is safe to rely on.
We use subgraphs where the data model genuinely suits them and build custom where it does not, drawing on the same node-internals knowledge we bring to execution-client work. We will tell you which one your case is.
What that means we build
Indexing pipelines that ingest blocks, logs, and traces, handle reorgs correctly, and expose clean query APIs over the result.
The reliability layer around the data. Backfills, reorg handling, and freshness guarantees, so downstream consumers see chain state that is both current and correct rather than one of the two.
Common questions
- Subgraphs or custom indexers?
- Whichever fits. Subgraphs are fast to ship where the data model suits them. Custom indexers win when you need performance, expressiveness, or reorg handling they can't provide. We build both and advise on the trade-off.
- How do you handle chain reorganisations?
- As a first-class concern. Recent history can be rewritten, so our indexers track finality, roll back invalidated data on reorgs, and only serve state that is safe to rely on.
- What can consume the indexed data?
- Apps, dashboards, analytics, and real-time systems. Anything that needs fast, structured queries over chain state instead of raw RPC calls against a node.
Have something hard to build?
Tell us the hard part: the protocol, the client, the mechanism, or the system that has to hold.