Forem: Peter Okoh

Week 2 of #100DaysOf Solana: Understand Transaction Anatomy

Peter Okoh — Tue, 05 May 2026 13:57:43 +0000

Not just clicking “send” and moving on, I actually looked under the hood.

I broke it down into signatures, instructions, accounts, and the exact data being passed. And honestly, it changed how I see blockchain completely.

What used to feel like a black box now feels structured and intentional. Every transaction is just a set of instructions, signed and verified by the network. No hidden logic. No backend magic.

It’s a bit uncomfortable at first because you’re closer to the raw data than in Web2, but that’s where the clarity comes from.

Still connecting all the dots, but one thing is clear: understanding what’s really happening behind a transaction makes everything else easier to grasp.

This is where things are starting to click.

100DaysOfSolana

Week 2 of #100DaysOfSolana: My Early Experience With Solana

Peter Okoh — Tue, 05 May 2026 12:29:40 +0000

Coming into Solana, I honestly expected blockchain data to feel abstract and complicated, like something hidden behind layers of cryptography that would be hard to reason about.

In my head, I thought it would look nothing like the databases I was used to in Web2. But the reality surprised me. Once I started working with accounts and RPC calls, it began to feel less like “mystery tech” and more like a different kind of database, just one that’s public, distributed, and stricter about how data is accessed and modified.

The biggest “click” moment for me was realising that Solana is basically a public database where everything revolves around accounts. Instead of tables and rows, you have accounts and programs. Instead of backend logic controlling access, the network enforces rules through signatures and ownership. That shift, from “my server controls everything” to “the network enforces everything", really changed how I think about building applications.

One thing that surprised me was how direct RPC calls are. In Web2, I’m used to clean APIs that return structured JSON designed for my app. With Solana, you’re closer to the raw data.

You fetch account info, and it’s on you (or your program) to understand what those bytes mean. It’s powerful, but also a bit uncomfortable at first because there’s less abstraction.

At the same time, it made me appreciate how transparent everything is. Reading on-chain data feels like querying a system where nothing is hidden. There’s no “private backend” doing magic behind the scenes. What you see is what exists. That’s very different from traditional APIs where you only get what the server decides to expose.

That said, I’m still wrapping my head around a few things. Program-Derived Addresses (PDAs) are one. I understand the idea, but I haven’t fully internalised when and why to use them.

I also want to get more comfortable with structuring account data and designing programs that manage state properly.

Overall, this has been a mindset shift more than anything else. I’m not just learning new tools; I’m learning a new way to think about data, identity, and ownership. And I’m starting to see why that matters.

100DaysOfSolana

Week 2 of #100DaysofSolana: Comparison Between Traditional Databases vs Solana Accounts

Peter Okoh — Tue, 05 May 2026 10:12:47 +0000

It was a beautiful thing comparing traditional databases and Solana accounts.

Below is a comparison table showing how they both work.

100DaysOfSolana

Week1 of #100DaysOfSolana: Understanding Identity on Solana (A Simple Guide for Web2 Developers)

Peter Okoh — Mon, 04 May 2026 11:28:14 +0000

If you’re coming from Web2, identity probably means a username and password. You sign up for a service, create credentials, and the platform stores your data. Whether it’s GitHub, your email, or a banking app, your identity exists because a company manages it.

Solana works differently.

On Solana, your identity starts with something called a keypair. This is made up of two things: a public key and a private key.

Think of the public key as your username (or wallet address) and the private key as your password, but much more powerful. Instead of typing your password, you use your private key to cryptographically sign actions. That’s how you prove ownership.

A helpful way to understand this is through SSH keys. If you’ve ever connected to a server using SSH, you know you don’t always use a password. Instead, you generate a keypair, put the public key on the server, and keep the private key on your machine. When you connect, the server checks if you can prove you own the private key. If you can, you’re in.

Solana works in a very similar way, except the “server” is the entire network.

One big difference from Web2 is that there are no usernames or centralised accounts. Your identity looks like a long string of characters (your public key), and you generate it yourself. No company approves it or stores it for you. That means your identity isn’t tied to any single platform; it works across every app built on Solana.

Another important shift is ownership. In Web2, you don’t fully own your account. A company does. They can suspend you, reset your password, or restrict access. On Solana, ownership is purely based on who controls the private key. If you have it, you have full control. If you lose it, there’s no “forgot password” option. That responsibility is entirely yours.

This might sound risky, but it also unlocks something powerful. Your identity becomes portable. The same keypair you use to hold tokens can also be used to interact with apps, vote in governance systems, or build a reputation. You don’t need to create a new account for every platform. You just connect your wallet and go.

From a developer’s perspective, this changes how you think about users. You’re no longer managing accounts with emails and passwords. Instead, users bring their own identity (their wallet), and your app interacts with it. Authentication becomes “sign this message” instead of “enter your password".

Of course, there are tradeoffs. Managing private keys safely is critical. That’s why there are different wallet types, CLI wallets for development, browser wallets for everyday use, and mobile or hardware wallets for better security. They all manage the same keypair but in different ways.

At its core, identity on Solana is simple: you are your keypair. There’s no middleman, no centralised control, and no dependency on a single platform. Once you understand that, the rest of the ecosystem starts to make a lot more sense.

I am happy to be sharing, and I anticipate your thoughts.