It’s been seven months since I started working on the nns-dapp (live at nns.ic0.app) on November 4th, 2024. If you check the commit history, you’ll see my fingerprints all over the place. Coming from a traditional enterprise background, this has been a shift. A big one.

Here’s what I’ve learned.

The Weight of Open Source

In my previous life, "security through obscurity" was a valid (if lazy) defense. Here? Everything is out in the open.

Working on an open-source project like the NNS Dapp means you can't hide your messy code. But more importantly, you have to be incredibly careful. One bad commit could have visible consequences for the community governance of the Internet Computer.

The scrutiny is high, but so is the quality bar. You learn to double-check everything, not because your manager is watching, but because everything is watching.

The Half-Billion Dollar Onboarding

Speaking of scrutiny, let's talk about the stakes.

The NNS Dapp isn't just a toy project; it controls roughly half a billion dollars in value. Onboarding into a codebase of this magnitude, with these kinds of stakes, is humbling.

You don't just "move fast and break things" when a bug could lock users out of their life savings or disrupt the governance of the entire network. The mental model shift from "shipping features" to "shipping secure features" is immediate and non-negotiable. The codebase is vast, complex, and requires a level of rigor I hadn't experienced before.

Moving at the Speed of Light

I came from the insurance world. To be fair, I was lucky enough to work at a startup that moved significantly faster than the industry average. I thought I knew what "fast" looked like.

But DFINITY? This is another level entirely.

In this project, we ship. We iterate. The pace is frantic but exhilarating. You merge a PR, and it’s live. You get instant feedback.

It’s a different kind of pressure. You have to be fast, but you can’t break things (see above). It forces you to be indispensable with your tools and precise with your logic.

Svelte: From "Weird" to "Wow"

When I first saw Svelte, I’ll be honest: I thought it was weird.

Coming from React, the idea of a compiler-first framework felt alien. Where was the Virtual DOM? Why does it look so much like vanilla HTML?

But after a few weeks, it clicked.

<script>
  let count = 0;
  function handleClick() {
    count += 1;
  }
</script>
 
<button on:click={handleClick}>
  Clicked {count} {count === 1 ? 'time' : 'times'}
</button>

No useEffect dependency arrays to debug. No complex state management boilerplate for simple things. It just works. Now, I actually prefer it. It gets out of your way and lets you build.

The Blockchain Complexity

This isn't just a web app. It's a frontend for a decentralized governance system.

On a normal web app, you open the Network tab in DevTools to debug API calls. Here? The Network tab lies to you.

Because we're interacting with the Internet Computer (IC), the "requests" aren't simple REST calls. We have a custom network layer that handles certification and communication with canisters (smart contracts). You can't just curl an endpoint.

We have to rely on agent libraries to securely verify the state of the blockchain. It forces you to understand what's actually happening under the hood—cryptography, consensus, and state certification—rather than just blindly consuming JSON.

Final Thoughts

These 7 months have been a crash course in modern, high-stakes development. I'm writing better code, shipping faster, and finally understanding how decentralized networks actually function.

If you're thinking about making the jump to crypto or open source: do it. Just be ready to run.

Want to know more? Hit me up on X.