What I Learned Taking a Liquid-Staking Protocol Past $500M+ TVL as a Founding Engineer
I joined Stader Labs as an intern in my final year at DTU. Somewhere between my first CosmWasm contract and the dashboards ticking past half a billion in staked assets, the title “founding engineer” got attached to me on a ~7-person team building multi-chain liquid staking. Nobody hands you that title. It’s just what’s left over when there are seven of you and half a billion dollars. Here’s the part that generalizes.
“Founding engineer” means you own the seams
On a small team nobody’s job is the boring glue. The validator doesn’t talk to the dashboard. The on-chain state doesn’t match the off-chain cache. A new chain integration breaks an assumption three modules deep, and all of it is yours.
The most valuable thing I did wasn’t one clever contract. It was owning the reconciliation between systems that were each individually correct and collectively drifting. If you want to grow fast early, volunteer for the seams. That’s where you learn how a system actually holds together, as opposed to how the design doc says it does.
Money bugs are not normal bugs
A web app that drops a request shows a spinner. A staking contract that mishandles a rounding boundary silently misallocates real value, and you hear about it from users, not tests. Crossing half a billion changed how I write code permanently.
- Invariants over assertions. Think in properties that must hold across every state transition — total staked = sum of positions, always — not “does this function return the right number.”
- Reconciliation is a feature, not a chore. Build the job that re-derives state from first principles and screams when it disagrees with what you stored. It catches things your unit tests never imagined.
- Blast radius sets the review bar. Code whose worst case is “a chart looks wrong” and code whose worst case is “funds are gone” should not get the same scrutiny, even in the same PR.
On-chain, your data model is your cost model
A lot of my time went into gas-fee analysis — benchmarking storage patterns and swap costs on Terra/CosmWasm so execution stayed economical at scale. The lesson that stuck: how you lay out storage is a user-facing decision, because someone pays for every byte and every read. Engineers from web2 underrate this for months. Profile gas the way you’d profile a hot loop.
Multi-chain forces honesty about your abstractions
Supporting liquidity pools across chains meant constantly catching which of my “general” abstractions were just the first chain’s quirks wearing a trenchcoat. Every new integration is a test of whether your core logic is actually chain-agnostic or secretly coupled and lying about it.
The analytics taught me more than the contracts
I built a system monitoring 1M+ nodes (React, MongoDB, Ethereum APIs) with APR dashboards. Watching real validator behavior at that scale is the fastest way to learn what your protocol actually incentivizes versus what you intended. The on-chain logic writes the rules. The analytics tell you the game people are really playing, which is never the one you wrote. Instrument the behavior before you tune the mechanism.
Why this still shapes how I work
Today I work where crypto meets traditional payments — systems where on-chain state has to reconcile with real money movement to the cent. Same seam I learned to love at Stader, just with a card network on the other side.
The expensive lesson wasn’t a technique. It was a posture: assume your two sources of truth will diverge, and make the divergence loud. They always diverge. The only choice you get is whether you find out from a monitor or from a user.
I’m Prajjwal Chittori, a backend engineer working across crypto infrastructure and payments. More at prajjwalchittori.com · GitHub · LinkedIn.