When I started the 100 Days of Solana challenge, I assumed tokens were simply cryptocurrencies.
I was wrong.
After spending several days working with the SPL Token Program and Token-2022, I realized something surprising:
Solana tokens are less like "coins" and more like programmable database objects that the entire network understands.
That mindset shift made everything click.
If you're a Web2 developer, here's the explanation I wish someone had given me.
Imagine Building a Rewards System in Web2
Suppose your company wants a loyalty program.
You'd probably build something like this:
Users
-----
id
name
RewardBalances
--------------
user_id
balance
Transactions
------------
id
from_user
to_user
amount
timestamp
Then you'd write APIs:
POST /mint
POST /transfer
GET /balance
Now you need to worry about:
- double spending
- race conditions
- database consistency
- authorization
- transaction history
- auditing
- scaling
You're responsible for everything.
Solana Already Solves This
Instead of building the infrastructure yourself, Solana provides a shared program called the SPL Token Program.
Think of it as an API that already exists on-chain.
Instead of writing:
POST /mint
you simply call:
spl-token mint
Instead of creating your own balance table...
Solana stores balances securely on-chain.
The blockchain becomes the shared database.
The First Concept That Confused Me
The first strange thing I encountered was this:
My wallet couldn't receive my own token.
Why?
Because Solana separates wallets from token accounts.
Coming from Web2, here's the easiest analogy.
Imagine your wallet is a filing cabinet.
Each token account is a folder inside it.
Wallet
│
├── SOL
├── USDC
├── MyToken
└── AnotherToken
Every token gets its own dedicated account.
That design keeps the runtime fast and data organized.
Mint ≠ Token
This was another "aha!" moment.
A Mint is not your balance.
A Mint is the definition of the currency itself.
It stores things like:
- total supply
- decimal precision
- mint authority
- token configuration
Think of it as the schema for a table.
Meanwhile, your Token Account stores your personal balance.
It's the equivalent of one row in a balances table.
Mint
-----
Decimals
Supply
Authority
↓
Token Account
Owner
Balance
Metadata Makes Tokens Human
Without metadata...
Your token is just a long address.
Nobody knows what it represents.
Token-2022 lets metadata live directly on the mint.
Instead of seeing:
4HwP8L....
wallets can display:
100DaysCoin
Symbol:
HUNDO
Along with:
- image
- description
- project website
It feels similar to adding display fields to a database record.
Token-2022 Is Where Things Get Interesting
The original SPL Token Program is powerful.
Token-2022 extends it with built-in capabilities that would normally require a backend service.
Some examples surprised me.
1. Transfer Fees
Imagine Stripe automatically charging platform fees...
without your backend.
That's what Token-2022 can do.
When someone transfers tokens:
Alice
100
↓
Bob
99
↓
1 token withheld as protocol fee
The token program enforces the rules.
Not your application.
2. Interest-Bearing Tokens
This one felt almost magical.
Normally, if you're building a savings application, you'd run scheduled jobs that update balances every day.
Token-2022 works differently.
The stored balance never changes.
Instead, wallets calculate the displayed balance using the configured interest rate and elapsed time.
It's similar to computing derived values when reading from a database instead of constantly updating every row.
3. Soulbound Tokens
Another extension allows tokens that cannot be transferred.
Think of:
- employee badges
- university certificates
- contributor roles
- event attendance
You own them.
But you cannot sell them.
This maps almost perfectly to Web2 identity systems.
4. Permanent Delegates
Imagine your company issues employee access cards.
Employees can't modify them.
HR can revoke them.
Permanent delegates work similarly.
The issuing authority can revoke or burn credentials without requiring the holder's permission.
That's incredibly useful for certifications, memberships, and verified credentials.
NFTs Suddenly Made Sense
I always thought NFTs were something completely different from tokens.
They're not.
An NFT is simply:
- a token with a supply of one
- zero decimals
- mint authority disabled
That's it.
Then metadata gives it:
- a name
- an image
- attributes
- a description
The mint stores the identity.
The metadata describes it.
The supply guarantees uniqueness.
Once I understood that, NFTs stopped feeling mysterious.
My Biggest Takeaway
The most important lesson wasn't learning new CLI commands.
It was realizing how much infrastructure Solana already provides.
As backend developers, we're used to building:
- balance tables
- transaction services
- permission systems
- fee processors
- interest calculations
- audit logs
On Solana, much of that logic already exists inside audited programs that every application can share.
Instead of writing another backend service, you're configuring a protocol.
That shift changes how you think about application architecture.
Final Thoughts
The more I work through the 100 Days of Solana challenge, the more I stop comparing Solana to traditional backend development and start seeing it as a globally shared application layer.
Coming from Web2, that was the biggest mental shift.
You're not replacing your backend with blockchain.
You're moving the parts that benefit from shared trust, transparent state, and built-in asset management onto the network itself.
For me, that made Solana finally click.
If you're a backend developer who's been curious about blockchain, learning the SPL Token Program and Token-2022 is one of the best places to start.
Top comments (0)