Here's something I didn't expect when I started building on Solana: I never wrote a signup form.

No username field. No password validation. No "confirm your email" flow. No "forgot password" page. Every piece of auth infrastructure I'd built dozens of times in Web2 — gone.

In its place: one button. "Connect Wallet."

🧠 What a Wallet Actually Does

If you're new to Solana, I wrote about the conceptual shift — from usernames to keypairs — in a previous post -

The short version: your identity is a cryptographic keypair, not a database row.

But for a developer, the practical implication matters more than the theory. Here's what changes:

You don't manage authentication. The wallet does. When a user clicks "Connect Wallet," their browser extension (Phantom, Solflare, etc.) pops up a confirmation. They approve. Your app gets their public key. You never see the private key. You never store a password hash. You never issue a session token.

You don't build onboarding flows. In Web2, every step of signup is a drop-off point. Email entry, email verification, profile setup, terms acceptance. On Solana, the user already has an identity before they visit your app. Your job is just to detect it.

"Logging in" is just signing a message. Your app sends a message, the wallet signs it, you verify the signature on your backend. No session cookie. No JWT. The signature is the proof.

⚠️ What You Lose

This isn't strictly better. There are tradeoffs:

• No password reset. If a user loses their private key, they lose access. There's no admin tool to restore their account.
• No account recovery. In Web2, you can email a reset link. On Solana, the keypair is the only identity. Lose it, and everything associated with that address — tokens, NFTs, program state — is inaccessible.
• No gradual onboarding. In Web2, you can let users browse before requiring login. On Solana, the user's address is their identity from the first interaction. There's no "anonymous session" that converts to a registered account later.

I covered the technical details of keypair generation and storage — why extractable: true matters, how PKCS8 works — in another post -

But the developer workflow shift is what I had to actually rebuild in my head.

💻 The Code Difference

In Web2, auth looks like this:

// Signup
app.post("/signup", async (req, res) => {
  const hash = await bcrypt.hash(req.body.password, 10);
  await db.users.create({ email: req.body.email, passwordHash: hash });
  req.session.userId = user.id;
});

// Login
app.post("/login", async (req, res) => {
  const user = await db.users.findByEmail(req.body.email);
  if (!user || !(await bcrypt.compare(req.body.password, user.passwordHash))) {
    return res.status(401).send("Invalid credentials");
  }
  req.session.userId = user.id;
});

On Solana, auth looks like this:

// Connect wallet (browser side)
const { accounts } = await wallet.features["standard:connect"].connect();
const userAddress = accounts[0].address;

// That's it. The user is now "authenticated."

No password hashing. No session management. No database lookups. The wallet handles the cryptographic proof. Your app just reads the public key.

🎯 Why This Matters

The "Connect Wallet" pattern isn't just a UI trend. It represents a fundamental shift in how identity works. In Web2, you build auth into your app. In Solana, auth is infrastructure — it lives in the wallet, not in your codebase.

That means as a developer, you don't need to worry about password storage, session hijacking, or email verification. But you also can't rely on support tickets or account recovery when something goes wrong.

Once I understood this tradeoff — less code, more responsibility — the "Connect Wallet" button stopped looking like a simplification and started looking like a completely different approach to identity.

Next: Transactions aren't HTTP requests. They're signed checks — and failed ones still cost you.

This is a submission for the 100 Days of Solana Writing Challenge, running from 15 May to 22 May.