From Web2 Dev to Solana: My First 5 Days

Day 1 was Understanding Keypairs (The Web3 Identity Shift)

The first thing that clicked for me on day one was how identity works differently in Web3.
In Web2, your identity lives in someone else's database. You create a password, a server stores it, and you prove who you are by matching that password. The platform controls your access.

In Web3, you generate your own keypair two halves that work together. The public key is your identity, like a username anyone can see. The private key is your proof, it signs transactions to confirm you're really you. Nobody generates it for you, nobody stores it for you. That shift from "the platform holds your identity" to "you generate and own it "is the real bridge from Web2 to Web3.

Day 2: Creating a Wallet and Checking Balance

I set up my first Solana wallet programmatically. I used Solana Kit and the generateKeypair function to create a wallet, then checked its address on Solana.

const wallet = await generateKeyPairSigner();

Seeing an actual wallet address generated from code that made it real.

Day 3: SOL and Lamports

Quick but important one. SOL isn't the smallest unit you work with on-chain, Lamports are.

1 SOL = 1,000,000,000 Lamports (10^9)

Think of it like how $1 = 100 cents. When you're reading balances or sending transactions in code, you're almost always working in Lamports. Keep that in mind so you don't accidentally send 1 SOL when you meant 1 Lamport.

Day 4: Connecting a Browser Wallet

This one had a setup detour. I'm on Windows, so before I could install the Solana CLI, I had to set up WSL (Windows Subsystem for Linux) and install Ubuntu. The Solana docs pointed me there once I figured that out it was straightforward.
For the browser wallet connection, I already had Phantom installed as an extension. The key thing I learned: detecting a wallet in the browser isn't enough, you also have to verify it actually supports Solana, since some multi-chain wallets don't.

function isSolanaWallet(wallet) {
  return wallet.chains?.some((chain) => chain.startsWith("solana:"));
} // this function checks if the available wallet are solana compatible

I also learned the difference between Devnet (your development/test environment, free SOL via airdrop) and
Mainnet (production, real money). Always build on devnet first.

Day 5 Wallets: A Real Comparison + The Different Types

Before diving into wallet categories, I compared the three wallets I'd actually used so far and the security differences were eye-opening.

1. CLI Wallet: the private key is stored in a plain file on your machine. Anyone with access to your file system can find it. Least secure for real use, but fine for dev work.
2. Browser Extension (e.g. Phantom): the app manages your private key and locks it behind a password. More convenient, but you're limited to password protection.
3. Mobile Wallet: this one surprised me. Mobile wallets can leverage your phone's hardware fingerprint, Face ID, biometrics. The OS-level security adds a layer that browser extensions simply can't match. For everyday use, mobile is arguably the most secure of the three.

The pattern is obvious: the more the app controls key management and hardware integration, the more secure it gets. CLI gives you raw access but also raw exposure.

Not all wallets are the same. Here's what I mapped out:

• Hot Wallet: private key lives on a device connected to the internet. Convenient but more exposed.
• Cold Wallet: private key is kept completely offline. More secure, less convenient.
• Custodial: someone else (usually an exchange) holds your private key. You trust them with your access.
• Non-Custodial: you hold your own keys. True ownership, but full responsibility.
• Hardware Wallet: a physical device (like a Ledger) that stores your private key separately from your computer. Best of both worlds for security.
• Multi-Signature Wallet: requires multiple signatures to approve a transaction. Great for t eam funds or added security.