DEV Community: Bitan Biswas

From Keypairs to Identity: My First 4 Days Learning Solana as a Web2 Dev

Bitan Biswas — Mon, 27 Apr 2026 08:51:59 +0000

When I started the #100DaysOfSolana challenge, I expected to learn tools and APIs. What I didn’t expect was how quickly my understanding of identity would change.

In Web2, identity = usernames + passwords stored by companies.
On Solana, identity = a cryptographic keypair that you own.

This post breaks that down with real code and what I built in my first 4 days.

🧠 Identity = Keypair (The Core Idea)

Every Solana identity is:

Public Key → your address (shareable)
Private Key → your authority (must be protected)

If you’ve used SSH, it’s the same model:

ssh-keygen

You generate:

id_rsa.pub → public
id_rsa → private

👉 Solana works the same way—but the entire blockchain verifies you, not just one server.

🚀 Day 1: Creating My Identity (CLI Wallet)

solana-keygen new
solana address
solana balance

This creates a keypair stored at:

~/.config/solana/id.json

👉 Insight:
My entire identity is just a file on disk

💸 Day 2: First Transaction (Ownership in Action)

solana airdrop 1
solana transfer <RECIPIENT_ADDRESS> 0.5

👉 What’s happening under the hood:

Transaction is signed with my private key
Network verifies using my public key

⚙️ Day 3: Parsing a Transaction (Programmatic Identity)

I built a script using @solana/kit:

import { createSolanaRpc, devnet } from "@solana/kit";

const LAMPORTS_PER_SOL = 1_000_000_000;

const rpc = createSolanaRpc(devnet("https://api.devnet.solana.com"));

const wallet = "YOUR_PUBLIC_KEY";

const signatures = await rpc
  .getSignaturesForAddress(wallet, { limit: 1 })
  .send();

const signature = signatures[0].signature;

const tx = await rpc
  .getTransaction(signature, {
    encoding: "jsonParsed",
    maxSupportedTransactionVersion: 0,
  })
  .send();

for (const ix of tx.transaction.message.instructions) {
  if (ix.program === "system" && ix.parsed?.type === "transfer") {
    const sender = ix.parsed.info.source;
    const receiver = ix.parsed.info.destination;
    const amount =
      Number(ix.parsed.info.lamports) / LAMPORTS_PER_SOL;

    console.log({ sender, receiver, amount });
  }
}

👉 Insight:
Everything boils down to:

Accounts (public keys)
Signatures (proof of ownership)

🔐 Day 4: Wallets = UX Layer Over Identity

I explored:

CLI wallet
Browser wallet
Mobile wallet

All use the same keypair—but differ in how they protect it.

🦊 Phantom Wallet Use Case (Real dApp Flow)

Here’s where it clicks.

Using a browser wallet like Phantom, you don’t create accounts—you connect your identity.

// Connect Phantom Wallet
const provider = window.solana;

if (provider?.isPhantom) {
  const response = await provider.connect();
  console.log("Public Key:", response.publicKey.toString());
}

👉 This gives you the same public key as your identity.

✍️ Signing a Transaction (User Approval)

const transaction = new Transaction().add(
  SystemProgram.transfer({
    fromPubkey: provider.publicKey,
    toPubkey: RECEIVER,
    lamports: 1000000,
  })
);

const signedTx = await provider.signTransaction(transaction);

👉 Key difference from CLI:

Phantom shows a popup
User must approve before signing

💡 Why This Matters

In Web2:

App controls your identity
You log in

In Web3:

You control your identity
Apps request permission

🌐 Public Keys vs Usernames

Example Solana address:

14grJpemFaf88c8tiVb77W7TYg2W3ir6pfkKz3YjhhZ5

Unlike usernames:

Not owned by a company
Works across all apps
Cannot be taken away

⚖️ Tradeoffs

Web2	Solana
Password reset	No recovery
Platform-controlled	Self-owned
Easy UX	Responsibility

Lose your private key → lose everything.

💻 My Repo

I’ve been documenting everything here:
👉 https://github.com/bitanb1999/100-days-of-solana

🔥 Final Take

Identity in Web3 isn’t something you sign up for.
It’s something you generate and carry everywhere.

Public key → who you are
Private key → what you control

Everything else builds on that.

From Usernames to Keypairs: Understanding Identity on Solana

Bitan Biswas — Mon, 27 Apr 2026 08:38:43 +0000

If you’ve spent your career in Web2, “identity” probably means a combination of usernames, emails, and passwords stored across different services. Your GitHub account, your company login, your banking app—each one represents a separate identity, controlled by the platform that provides it.

On Solana, identity works very differently.

Instead of accounts tied to platforms, your identity starts with a cryptographic keypair. That single concept replaces usernames, passwords, and even authentication systems as we know them.

Let’s break that down.

Identity in Web2 vs Web3

In Web2, your identity is fragmented. You might log into a server using SSH keys, sign into apps with Google OAuth, and use passwords with 2FA elsewhere. Each system is owned and managed by a company. If they lock your account, your identity in that system is gone.

On Solana, identity is unified and self-owned.

When you generate a keypair, you get:

A public key → your address (like a username)
A private key → your proof of ownership (like a password, but stronger)

But here’s the key difference:
No company stores or controls this identity. The network itself recognizes it.

The SSH Analogy (That Makes It Click)

If you’ve used SSH, this will feel familiar.

You generate a keypair locally.
You add your public key to a server.
When connecting, you prove ownership by signing with your private key.

Solana works the same way—except instead of a single server, the entire blockchain is the verifier.

Your public key is your identity everywhere on the network. Every transaction you make is signed with your private key, proving that you are the owner of that identity.

Public Keys vs Usernames

A Solana address might look like this:

14grJpemFaf88c8tiVb77W7TYg2W3ir6pfkKz3YjhhZ5

It’s a Base58-encoded public key. Unlike usernames:

It’s globally unique
It doesn’t depend on a platform
No one can “take it away” from you

In Web2, your username exists in a database controlled by a company.
On Solana, your public key exists independently of any application.

Any dApp can recognise your identity without needing to create a new account for you.

Ownership Without Permission

This is where things get powerful.

In Web2:

You “own” your account because a company lets you
Password resets exist because someone else manages your credentials
Access can be revoked

On Solana:

Only the holder of the private key can sign transactions
There is no admin panel
There is no password reset

If you control the private key, you control the identity. Full stop.

This is called self-custody, and it shifts responsibility from platforms to users.

Identity as a Foundation

On-chain identity is not just about logging in—it’s the foundation for everything else.

Your keypair is used to:

Own tokens (SOL, NFTs)
Interact with programs (smart contracts)
Vote in governance systems
Build reputation across applications

Because it’s cryptographic and portable, your identity works across all apps on Solana without needing separate sign-ups.

You don’t “create an account” for each app.
You bring your identity with you.

The Tradeoff

Of course, this model comes with tradeoffs.

In Web2:

You can reset your password
Support teams can help recover accounts

On Solana:

Lose your private key → lose access permanently
No central authority to recover it

That’s why wallets (CLI, browser, mobile, hardware) exist—they provide different balances between security and convenience, while still managing the same underlying keypair.

Final Thoughts

The biggest mindset shift is this:

On Solana, identity is not something a platform gives you—it’s something you own.

Your public key is your global identity.
Your private key is your authority.

Everything you do on-chain flows from that.

For a Web2 developer, this might feel unfamiliar at first. But once it clicks, it becomes clear: this model removes intermediaries and creates a system where identity is portable, permissionless, and entirely yours.

And that’s a fundamental change in how we think about the internet.