DEV Community: Sanjaya Bhatta

A week of Learning Solana #100DaysOfSolana

Sanjaya Bhatta — Tue, 28 Apr 2026 15:47:49 +0000

I spent 7 days learning Solana wallets — here’s what actually clicked

I’ve mostly worked in Web2 stuff, so when I started Solana, I expected something like:

create account
set password
get token-based auth or something

But that’s not what happens at all.

There is no “account creation” step.

You just generate a keypair and… that’s your identity.

Day 1 — Identity is just a keypair

First thing I did was generate a wallet in code:

`
import { generateKeyPairSigner } from "@solana/kit";

const wallet = await generateKeyPairSigner();
console.log(wallet.address);
`

That’s it.

No email. No signup. No backend.

Just a public key and a private key.

At this point it honestly felt like “okay but where is the account actually stored?”

Answer: nowhere.

You are the account.

Day 2 — Oh, wallets are just files

Next step was making it persistent.

So instead of generating a new wallet every time, I saved it into a JSON file.

That’s when it started feeling a bit… raw.

Because suddenly:

my “wallet” = a file on my machine
my “identity” = bytes in that file

If someone has that file, they are you on-chain.

No recovery. No reset.

Very different from Web2 where you can just email support.

Day 3 — SOL is not really what the system uses

Then I hit something small but important:

SOL is just a human label.

Under the hood it’s all lamports:

1 SOL = 1,000,000,000 lamports

Everything in code uses lamports, not SOL.

So if you mess up and send 1 instead of 1e9, you didn’t send 1 SOL… you sent basically nothing.

This is one of those “good to know early or suffer later” things.

Day 4 — Browser wallets feel like the “real product”

Then I tried Phantom.

This felt closer to what most people think “wallets” are.

Setup looked like:

create seed phrase
set password
install extension
connect to app

But the important part:

My app never sees my private key.

Instead it just asks:

“can you sign this?”

And Phantom handles the rest.

That was the first time Solana started feeling like a real ecosystem, not just scripts.

Day 5 — There isn’t one wallet type

This day was more comparison than coding.

I tried CLI, browser, and mobile wallets and realized something simple:

They are all the same thing underneath.

Just stored differently:

CLI → file on disk (fast, insecure)
Browser → encrypted extension (balanced)
Mobile → secure storage + biometrics (more protected)

So it’s not really “which wallet is best”

It’s more:

what are you trying to do?

scripts, dApps, or holding funds

Day 6 — Identity finally clicked

This was the big mental shift.

In Web2:

identity = database record
platform owns access

In Solana:

identity = ability to sign
no one can “reset” it for you

If you have the private key → you are the account
If you lose it → it’s gone

That’s it.

No middle layer.

No support tickets.

Kind of scary, but also… very clean.

Day 7 — Sharing it made it clearer

The last step wasn’t technical.

It was just writing and sharing what I learned.

And honestly, that’s where things started making sense properly.

Because when you try to explain it simply, you realize:

wallets are just key storage
identity is just cryptographic proof
apps don’t “log you in” — they just verify signatures

🧠 Final takeaway

If I had to reduce everything I learned:

A Solana wallet is just a keypair. Everything else is UX around signing.

That’s it.

No accounts. No passwords. No central identity.

Just keys.

And once that clicks, everything else (tokens, NFTs, DeFi) becomes way easier to understand.

If you’re coming from Web2, this is probably the hardest mindset shift:

You don’t “log in” to Solana.

You just prove you are already you.

This post is part of my #100DaysOfSolana series. Follow along as I go from zero to building on Solana, one day at a time.

I Thought Solana Identity Would Be Complicated… It’s Actually Just SSH Keys (Kind Of)

Sanjaya Bhatta — Tue, 28 Apr 2026 15:18:57 +0000

Day 5 of Learning Solana: I Finally Understand Identity (It’s Just SSH Keys 😅)

I have been learning Solana for the past few days, and I’ll be honest:

“Identity on blockchain” sounded like one of those things I would pretend to understand… but actually didn’t.

I expected:

complicated concepts
heavy cryptography
lots of “just trust me” explanations

But after a week, it finally clicked.

And now I feel like I was overthinking it the whole time.

What I Was Expecting vs Reality

Before this, my mental model was:

Blockchain identity = some new complicated system I need to memorize

Actual reality:

It’s basically SSH keys.

That’s it.

Once I saw it that way, everything started making sense.

Quick Reality Check: How Web2 Identity Works

As a Web2 dev, this is our default:

user signs up
we store username/email + password
we handle auth
we reset passwords
we manage sessions

We have all built this 100 times.

And we don’t question it anymore.

But also… we don’t really own anything here.

If your app uses my database:

I can lock you out
I can delete your account
I control access

“Your account” is kind of an illusion.

Solana: No Accounts, Just Keys

Here’s the shift.

On Solana, there are:

no usernames
no passwords
no central database

Your identity is just:

a public key (your address)
a private key (your proof)

You generate this yourself.

No signup.
No email.
No “create account” button.

That part alone felt weird at first.

The SSH Moment (Where It Finally Clicked)

The turning point for me was thinking about SSH.

With SSH:

you generate a keypair
you give the server your public key
you prove who you are using your private key

Now replace:

“server” → with the entire Solana network

And suddenly:

Oh.

This is the same idea.

Just bigger.

The Ugly Truth: Your Identity Looks Like This

Instead of a nice username like username_dev, you get this:

14grJpemFaf88c8tiVb77W7TYg2W3ir6pfkKz3YjhhZ5

Very user-friendly. Totally memorable.😅

It’s a public key (Base58 encoded, which just avoids confusing characters).

Important part:

you didn’t pick it
no one gave it to you
it’s not stored in some company DB

You just have it.

The Part That Actually Changed My Thinking

This is where things got real for me.

In Web2:

I “own” my account because a company says I do.

In Solana:

If I have the private key, I own it. Period.

No support team.
No admin panel.
No “forgot password.”

Also no safety net.

If you lose your private key, that’s it.

Game over.

That sounds scary (and it kind of is), but also:

No one can randomly ban you or lock you out.

That’s a big shift.

Why This Is More Powerful Than It Looks

At first I thought:

“Cool, so it’s just login but more annoying.”

But it’s not just login.

This identity is used for everything:

holding tokens
interacting with programs
signing transactions
voting in governance
basically proving “this action is mine”

And the crazy part:

It works across every app.

No separate accounts.
No repeated signups.

It’s like if your SSH key worked on every server on the internet by default.

The Mental Model I’m Keeping

This is what I’ve settled on:

Web2 → accounts controlled by companies
Solana → keys controlled by you

Or even shorter:

Web2 = “they manage you”

Web3 = “you manage your keys”

That one line helped everything stick.

Final Thought (From Someone Still Learning)

I’m only a few days into this, but this was one of those moments where things suddenly felt simple.

Not easy.

But simple.

The hardest part wasn’t the tech.

It was letting go of the idea that: someone else is managing identity for me

On Solana, that responsibility is yours.

And that’s kind of the whole point.