this is probably still the most important software project on the site for me, even though it was always meant as an internal tool and not something public. for a while it was one of the websites i used the most because it gave me one place to understand what i had, what i spent, what i moved out, and where things actually went.
it started from a pretty simple frustration: the data existed, but it was scattered across too many explorers, wallets, exchange screens, card views, and half-broken dashboards. what i actually wanted was one place where i could understand the state of things without translating between five different mental models first.
stack
- frontend in react
- backend with node.js, express, sequelize, and postgresql
- data across evm, cosmos, solana, and sui
- dockerized setup behind a reverse proxy
the stack matters less than the shape of the problem. it was really a data normalization and product clarity problem wearing a crypto label.
what the work actually is
most of the work is not flashy. it is normalizing data, handling ugly apis, filtering noise, tagging wallets, and keeping the whole thing usable as the sources change.
more concretely, that means things like:
- aggregating balances and token positions across different chains
- tagging wallets so the interface reflects how i actually think about them
- dealing with provider differences, missing fields, inconsistent symbols, and rate limits
- deciding what should be shown, collapsed, grouped, or ignored
- keeping the ui readable even when the underlying data is messy
on evm, a big part of the experience came from using the rabby / debank-style data layer and then mounting my own logic and extra data onto it. that was the only realistic way to get the kind of evm overview i wanted without running more infrastructure myself. it is also why this will probably never have a public demo: those api calls are expensive, and the dashboard was always tied to private data anyway.
for other chains like cosmos, solana, and sui, i could rely much more on public endpoints and chain-specific sources. so the project became a mix of expensive high-value evm aggregation and cheaper public multi-chain stitching for everything else.
what made it useful
the point was not just portfolio tracking in the abstract. i wanted the real money flow in one place:
- exchange balances and exchange api data
- wallet balances and token positions
- gnosis pay card spending
- withdrawals from exchanges
- liquidity moving out through tools like rubic and xmr routes
- a clearer sense of how much actually came in, went out, or got spent
that made it much more than a token list. it became a personal control panel for crypto activity, spend behavior, and exits.
what i am up to with it
right now it matters a bit differently than before, because i do not have nearly as much money in crypto anymore. but that does not make the project smaller in my head. if anything, it shows more clearly what kind of work it really was: a serious internal system built around my own use case, not a fake demo product.
that is also why there is no public demo and probably never will be. too much of the value comes from private account data, and too much of the evm side depends on expensive provider access. but the architecture, aggregation logic, and product thinking are still very real.
why this one stays featured
because it pulls together a lot of the work i actually want to keep doing: backend structure, messy external systems, data cleanup, interface decisions, and building tools around real use instead of just a demo.
why it belongs here
because it combines a lot of the work i actually like: systems, interfaces, data cleanup, backend structure, and tools i would want to use myself. and because it was not a toy. it was private, messy, useful, expensive in the right places, and heavily used when i needed it most.