🔈 Big News! Agentgenesis is an Official 🔈 IBM Watsonx Partner!

Blog

Starting Solana Development: Why Everyone's Moving from Ethereum (And Why You Should Too)

Abir Dutta

Abir Dutta

Published on Saturday, Sep 13, 2025

Hey there! So you've probably heard me rambling about cryptography in my previous blog, and now you're wondering - "Okay Abir, I understand the foundation, but where do I actually start building?" Well, buckle up because today we're diving into Solana, and honestly, after spending hours, I can't imagine going back to waiting 15 minutes for an Ethereum transaction to confirm :))

I remember when I first heard about Solana, I was like "another Ethereum killer? Yeah right..." But then I deployed my first program, saw transactions confirming in 400 milliseconds for literally a fraction of a cent, and thought "okay, maybe I should pay attention to this."

This blog is for developers who understand the crypto basics but want to understand WHY Solana exists and HOW to actually start building on it. We'll go from theory to practice, and by the end, you'll have your first Solana program deployed and running.

The "Why am I learning Solana?" moment

Before we jump into the technical stuff, let's understand the evolution. It's like understanding why we went from horses to cars to planes - each solved problems the previous one couldn't.

Bitcoin (2009): Digital gold, peer-to-peer money, revolutionary but limited. You can send value, but that's about it. No programmability, no complex logic, just "Alice sends 1 BTC to Bob."

Ethereum (2015): The game changer. Smart contracts! Suddenly we could build programmable money, decentralized exchanges, NFT marketplaces. But here's the thing - success brought problems. During peak times, developers have literally paid $150 in gas fees for a simple token swap. That's not sustainable for mainstream adoption.

Solana (2020): What if we could have Ethereum's programmability but with the speed of a traditional database? That's Solana's promise, and honestly, it delivers.

Let me put this in perspective with real numbers that made me switch:

# Ethereum transaction times and costs (during peak)
Transaction confirmation: 15 seconds - 5 minutes
Gas cost for token transfer: $10 - $150
Transactions per second: ~15 TPS

# Solana transaction times and costs
Transaction confirmation: 400-600 milliseconds
Cost for token transfer: $0.00025
Transactions per second: 65,000+ TPS

The difference is mind-blowing. It's like comparing sending a letter via postal mail to instant messaging.

Setting Up Your Solana Development Environment

Before we dive deep into concepts, let's get you set up with the Solana CLI. Trust me, once you start using these commands, you'll feel like you have superpowers.

Installing Solana CLI

here is the official documentation where you can install Solana CLI - https://solana.com/docs/intro/installation

Just search for your OS and install accordingly!
To verify if it was successfully installed or not -

# Verify installation
solana --version
# Should output something like: solana-cli 1.16.0

Configuring Your Environment

Now let's configure our development environment. This is where you'll spend most of your time while learning.

# Set up configuration for devnet (our playground)
solana config set --url https://api.devnet.solana.com
solana config set --keypair ~/.config/solana/id.json

# Check your configuration
solana config get
# Output shows:
# Config File: ~/.config/solana/cli/config.yml
# RPC URL: https://api.devnet.solana.com
# WebSocket URL: wss://api.devnet.solana.com/
# Keypair Path: ~/.config/solana/id.json
# Commitment: confirmed

Creating Your First Wallet

Let's create your development wallet. This is where you'll store your test SOL and interact with the blockchain.

# Generate a new keypair (this creates your wallet)
solana-keygen new --outfile ~/.config/solana/dev-wallet.json

# This will ask for a passphrase - use something you'll remember for development
# It will also show you a seed phrase - SAVE THIS SOMEWHERE SAFE

# Set this as your default keypair
solana config set --keypair ~/.config/solana/dev-wallet.json

# Check your wallet address
solana address
# This gives you your public key/wallet address like: 7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU

Understanding what just happened here is crucial. When you ran solana-keygen new, you created a keypair file containing your private and public keys. The public key becomes your wallet address (like your bank account number that you can share), and the private key stays secret in that JSON file (like your PIN that you never share).

Networks: Your Development Playground

Solana has three main networks, each serving a different purpose. Think of them as different environments where you can test and deploy your applications.

# Switch to devnet (development network)
solana config set --url https://api.devnet.solana.com

# Switch to testnet (more stable testing)
solana config set --url https://api.testnet.solana.com

# Switch to mainnet (real money, real consequences!)
solana config set --url https://api.mainnet-beta.solana.com

# Always check which network you're on
solana config get

Devnet is your safe space. It's where you break things, experiment, and learn. The SOL here is free and worthless, perfect for development.

Testnet is like a dress rehearsal. It's more stable than devnet and closer to mainnet conditions, but still uses test SOL.

Mainnet is the real deal. Real SOL, real money, real consequences. Only deploy here when you're absolutely confident your code works perfectly.

I learned this the hard way when I accidentally deployed a buggy program to mainnet and lost some SOL to transaction fees before realizing my mistake. Always test thoroughly on devnet first!

Airdropping: Getting Free SOL for Development

Here's one of my favorite parts about Solana development - getting free test SOL is built right into the CLI. No complicated faucet websites, no waiting periods.

# Request 2 SOL airdrop to your wallet
solana airdrop 2

# Check your balance
solana balance
# Output: 2 SOL

# You can airdrop up to 5 SOL at a time on devnet
solana airdrop 5

# Check balance again
solana balance
# Output: 7 SOL

If the airdrop fails (which sometimes happens when the network is busy), just try again. You can also airdrop to specific addresses:

# Airdrop to a specific address
solana airdrop 1 7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU

This might seem simple, but it's revolutionary compared to Ethereum development where you need to manage testnet ETH from faucets that often have long delays or complex requirements.

Understanding Solana's Account Model: Everything is an Account

Here's where Solana completely blew my mind and probably will blow yours too. In Ethereum, you have contracts (code) and accounts (data) as separate things. In Solana, EVERYTHING is an account. Your wallet? Account. Smart contract code? Account. Token balances? Account. Program state? Account.

Let's explore this with actual CLI commands:

# Check details of your wallet account
solana account $(solana address)

# This shows you:
# Balance: 7 SOL
# Owner: 11111111111111111111111111111112 (System Program)
# Executable: false
# Rent Epoch: 361

Every account in Solana has five key properties, and understanding these is crucial for Solana development:

  • Lamports represent the account's balance. One SOL equals 1,000,000,000 lamports (like wei in Ethereum). When you see your balance as "7 SOL," it's actually stored as 7,000,000,000 lamports.

  • Data is where the account stores its information. For a wallet account, this is mostly empty. For a token account, this stores your token balance. For a program account, this contains the executable code.

  • Executable is a boolean flag. If true, this account contains executable code (it's a program). If false, it's a data account. Your wallet account has executable: false because it stores data (your SOL balance), not code.

  • Owner specifies which program has permission to modify this account's data. Your wallet is owned by the System Program (the program that manages SOL transfers and basic operations).

  • Rent Epoch relates to Solana's rent system, which we'll explore next.

Let's look at a program account to see the difference:

# Look at the System Program account (the program that manages basic operations)
solana account 11111111111111111111111111111112

# Notice:
# Executable: true (this account contains code that can be run)
# Owner: Native Loader (the program that loaded this program)

The Rent System: Solana's Genius Storage Solution

One of Solana's clever innovations is the rent system. Unlike Ethereum where once you store data on-chain, it stays forever (contributing to blockchain bloat), Solana requires accounts to pay rent for the storage they use.

But here's the genius part - if you deposit enough SOL to cover about 2 years of rent, your account becomes "rent-exempt" and the rent payments stop. It's like paying a security deposit that you get back when you close the account.

# Calculate rent exemption for different account sizes
solana rent 0      # Empty account
# Output: Rent-exempt minimum: 0.00089088 SOL

solana rent 165    # Token account size
# Output: Rent-exempt minimum: 0.00203928 SOL

solana rent 1000   # Custom program account
# Output: Rent-exempt minimum: 0.00731616 SOL

Understanding rent is crucial because if an account doesn't maintain rent-exempt status and runs out of lamports, it gets deleted from the blockchain.

The rent calculation follows this formula: accounts pay rent every epoch (about 2 days) based on the amount of storage they use. The rent-exempt threshold is set so that the deposit covers approximately 2 years of rent payments.

# Check rent status of your account
solana account $(solana address) | grep -E "(Balance|Rent)"
# Shows your balance and rent epoch information

Accounts in Solana: The Deep Dive

Now that you understand the basics, let's explore different types of accounts you'll encounter in Solana development. Each type serves a specific purpose in the ecosystem.

System Accounts (Your Wallet)

These are the most basic accounts - they hold SOL and are owned by the System Program.

# Create a new system account (basically a new wallet)
solana-keygen new --outfile ~/new-wallet.json

# Check its details
solana account -k ~/new-wallet.json $(solana-keygen pubkey ~/new-wallet.json)

Program Accounts (Smart Contracts)

These contain executable code. Let's look at some built-in programs:

# System Program - handles basic operations like transfers
solana account 11111111111111111111111111111112

# SPL Token Program - handles all token operations
solana account TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA

Data Accounts (Program State)

These store program state and user data. We'll create one when we deploy our first program.

Solana's Token System: The Mind-Bending Paradigm Shift

Here's where Solana completely flipped my understanding of how tokens work, and it took me weeks to fully grasp this concept. In Ethereum, every token is a separate smart contract. Want to create a new token? Deploy a new contract with functions like transfer(), balanceOf(), etc.

Solana said "what if we had ONE universal token program that handles ALL tokens?" That's exactly what the SPL Token Program does.

Understanding SPL Tokens with CLI

Let's create our first token to understand how this works:

# First, make sure you have some SOL for transaction fees
solana balance
# Should show at least 1 SOL

# Create a new token mint (this is like deploying a token contract in Ethereum)
spl-token create-token
# Output: Creating token AQoKYV7tYpTrFZN6P5oUufbQKAUr9mNYGe1TTJC9wajM
# Signature: 3yGJLzpbMxhHXZW4R5h2VtCHvGGFNhz2YnxJ8nQKXmCQZJ4K5uP3hU2fQKGfFhcXa8J

# This created a "mint account" - think of it as the master record for your token

What just happened? Solana created a special account that defines your token. This account stores metadata like:

  • How many decimal places your token has

  • Who has the authority to mint new tokens

  • The total supply

  • Whether the token can be frozen

# Check details of your new token mint
spl-token display YOUR_TOKEN_MINT_ADDRESS

# Output shows:
# Address: AQoKYV7tYpTrFZN6P5oUufbQKAUr9mNYGe1TTJC9wajM
# Decimals: 9
# Supply: 0
# Mint authority: 7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU

Creating Token Accounts and Minting

Here's where it gets interesting. To hold tokens, you need a "token account" for each token type. It's like having separate pockets in your wallet for different currencies.

# Create a token account to hold your new tokens
spl-token create-account YOUR_TOKEN_MINT_ADDRESS
# Output: Creating account 5jqKDzp7s1vqKjD6nH8R4oT1fPhXCGnJnC4o5S8xW2nG

# Now mint some tokens to your account
spl-token mint YOUR_TOKEN_MINT_ADDRESS 1000
# This creates 1000 tokens and sends them to your token account

# Check your token balance
spl-token balance YOUR_TOKEN_MINT_ADDRESS
# Output: 1000

The beauty of this system is that there's ONE program (SPL Token) handling ALL token operations. Every token on Solana - USDC, USDT, your custom tokens - they all use the same underlying program with the same commands.

Token Ownership and Authority

Understanding token authorities is crucial for token management:

# Check who can mint your token
spl-token display YOUR_TOKEN_MINT_ADDRESS | grep "Mint authority"
# Shows: Mint authority: 7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU

# Transfer mint authority to someone else
spl-token authorize YOUR_TOKEN_MINT_ADDRESS mint NEW_AUTHORITY_ADDRESS

# Disable minting forever (set mint authority to null)
spl-token authorize YOUR_TOKEN_MINT_ADDRESS mint --disable

Mint Authority controls who can create new tokens. This is like having the printing press for your currency.

Freeze Authority can freeze specific token accounts, preventing transfers. This is useful for compliance or security purposes.

# Set freeze authority
spl-token authorize YOUR_TOKEN_MINT_ADDRESS freeze FREEZE_AUTHORITY_ADDRESS

# Freeze a specific token account
spl-token freeze SPECIFIC_TOKEN_ACCOUNT_ADDRESS

Token 22: The Next Evolution

While we're talking about tokens, let me introduce you to Token 22 (also called Token Extensions Program). It's the newer, more feature-rich version of the SPL Token program.

# Create a Token 22 token with transfer fees
spl-token --program-id TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb create-token

# Token 22 supports:
# - Transfer fees
# - Metadata directly in the mint
# - Interest-bearing tokens
# - And much more!

Token 22 addresses many limitations of the original SPL Token program. For new projects, I recommend using Token 22 unless you need compatibility with existing SPL Token infrastructure.

Transfer Fees Example

One of Token 22's coolest features is built-in transfer fees:

# Create a token with transfer fees
spl-token --program-id TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb create-token \
  --transfer-fee 50 10000  # 0.5% fee (50 basis points out of 10000)

# Now every transfer of this token automatically deducts a fee

This is revolutionary for tokenomics - you can build fee mechanisms directly into your token without complex smart contracts.

Advanced CLI Operations

Once you're comfortable with the basics, these advanced commands become incredibly useful:

Transaction Management

# Send SOL to another address
solana transfer 7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU 1

# Check transaction status
solana confirm TRANSACTION_SIGNATURE

# Get transaction details
solana transaction-history $(solana address)

Account Management

# Close empty accounts to reclaim rent
spl-token close-account EMPTY_TOKEN_ACCOUNT_ADDRESS

# Transfer token account ownership
spl-token transfer YOUR_TOKEN_MINT_ADDRESS 100 RECIPIENT_ADDRESS

# Check all your token accounts
spl-token accounts

Mainnet vs Testnet vs Devnet: When to Use What

Understanding when to use each network is crucial for effective development:

Devnet is where you spend 99% of your development time. It's fast, free, and perfect for experimentation. The state resets occasionally, so don't rely on it for long-term testing.

# Switch to devnet for development
solana config set --url https://api.devnet.solana.com

Testnet is for final testing before mainnet. It's more stable than devnet and closer to mainnet conditions. Use this for beta testing with users.

# Switch to testnet for beta testing
solana config set --url https://api.testnet.solana.com

Mainnet is production. Real money, real users, real consequences. Only deploy here when you're absolutely confident.

# Switch to mainnet (be careful!)
solana config set --url https://api.mainnet-beta.solana.com

# Always double-check you're on the right network
solana config get

I have a simple rule: develop on devnet, test on testnet, deploy to mainnet. Never skip the testnet phase, even for simple programs.

Final Thoughts: The Solana Developer Journey

Understanding Solana's account model was probably the biggest mental shift I had to make coming from Ethereum development. Everything being an account seems weird at first, but it's actually elegant and powerful once you internalize it.

The CLI tools we've explored today are your gateway to the Solana ecosystem. Master these commands, and you'll be able to build, deploy, and manage Solana programs with confidence.

What excites me most about Solana isn't just the speed or low costs (though those are amazing). It's that the developer experience is just better. Fast feedback loops, comprehensive tooling, and a growing ecosystem of developers who are genuinely helpful.

My advice? Start small, experiment on devnet, break things, fix them, and gradually work your way up to more complex programs. The learning curve is steep initially, but once you get it, you'll wonder why anyone builds on slower, more expensive networks.

The decentralized internet is coming, and Solana is positioning itself to be the infrastructure that powers it. By understanding these fundamentals and mastering the CLI tools, you're preparing yourself to be part of that future.

Next time, I'll dive deeper into building more complex Solana programs and exploring advanced patterns like Program Derived Addresses (PDAs) and Cross-Program Invocations (CPIs). But for now, go play with the CLI, create some tokens, deploy a simple program, and get comfortable with the Solana way of thinking.

Remember - in Solana, everything is an account, transactions are cheap and fast, and the developer tooling is excellent. Once you embrace these principles, you'll be building the next generation of decentralized applications.

Keep building, keep learning, and welcome to the Solana ecosystem! :)

By Abir

P.S. - If you get stuck with any of these CLI commands or run into weird errors, don't panic! The Solana Discord community is incredibly helpful, and most issues are just configuration problems that are easily fixed. Happy coding!