DEV Community: Siddhant Chavan

Building My First Solana Transfer CLI Tool | #100DaysOfSolana

Siddhant Chavan — Tue, 26 May 2026 17:35:33 +0000

Built a CLI tool that transfers SOL on Solana devnet and tracks the transaction through processed, confirmed, and finalised states.

This project helped me understand that Solana transactions are much more than just “sending crypto.” I learned how recent blockhashes work, why transactions need signatures, how confirmation levels actually matter, and what really happens after a transaction gets submitted to the network.

The most interesting part was watching the transaction lifecycle in real time and seeing how Solana moves from processed → confirmed → finalised.

Also spent time debugging failed transactions and honestly learned more from the failures than the successful transfers 😅

Built using Solana Kit + System Program on devnet.

📸 Terminal demo + Explorer screenshot attached
🔗 Explorer Link: https://explorer.solana.com/tx/2tQJ8YEwtTC7UdS5nYsHtRWV73LsiSR37vHEVTpJeiGGGEoXTotfX4SVGHnEvrhak8DvhFEy8G4eJLCsayrFNQGR?cluster=devnet

Solana #Web3 #Blockchain #BuildInPublic #100DaysOfSolana

What Learning Solana Transactions Actually Felt Like | #100DaysOfSolana

Siddhant Chavan — Tue, 26 May 2026 15:44:59 +0000

A few days ago, Solana transactions looked completely overwhelming to me.

I kept seeing terms like signatures, instructions, blockhashes, compute budgets, and account ownership everywhere, but none of it felt intuitive at first. Coming from a more traditional backend mindset, I was expecting transactions to work like a normal API request — send something, get a response, done.

Solana quickly showed me that it doesn’t work that way.

Over the past few days in my #100DaysOfSolana challenge, I spent most of my time experimenting with transactions on devnet. Some worked instantly, some failed for confusing reasons, and honestly, the failures taught me the most.

One thing that really changed my understanding was realising that a Solana transaction is more like an atomic state change than a simple request. Everything either succeeds together or fails together. There’s no “half success.” That mental shift took me time to understand.

I also started paying attention to details I normally would have ignored:

why transactions need signatures
why blockhashes expire
how instructions are bundled together
why compute limits matter
and how even transaction size affects development decisions

The most interesting part was exploring failed transactions on Solana Explorer and trying to understand why they failed instead of just retrying them. Sometimes it was balance issues, sometimes account problems, and sometimes timing-related issues because of expired blockhashes. Reading logs and debugging those mistakes made the concepts feel real instead of theoretical.

Another thing I noticed while learning Solana is how different the developer experience feels compared to Web2. In Web2, most complexity is hidden behind servers and APIs. On Solana, you’re much closer to the system itself. You actually see how accounts, programs, and transaction execution interact.

That was frustrating at times, but also what made it interesting.

Looking back, transactions were probably the first Solana topic that genuinely challenged the way I think about software systems. But after spending several days building, testing, breaking, and debugging them, I finally feel like I’m starting to understand what’s happening under the hood instead of just copying code blindly.

Still learning every day, but this part of the journey definitely made Solana feel “real” to me.

100DaysOfSolana #Solana #Blockchain #Web3

On day-10 I built something and it genuinely surprised me. 😲#100DaysOfSolana

Siddhant Chavan — Wed, 20 May 2026 18:42:22 +0000

I didn't expect this to work the way it did.
On Day 10 I built a Solana Dashboard — paste any wallet address and it pulls:
💰 Live SOL balance
📋 Complete transaction history
🔍 Full account data
But here's what actually blew my mind —
I never asked anyone for permission.
No API key. No login. No "request access" form. No terms of service to agree to. I just pointed my code at a public address and the blockchain handed me everything. Every transaction. Every balance. Every interaction. Out in the open.
Coming from Web2, this broke my brain a little. We're so used to data being locked behind auth layers, rate limits, and paywalls. But on Solana? The ledger is just… there. Public. Permanent. Readable by anyone.
That's not just a technical difference. That's a completely different relationship between code and data.
I built a dashboard expecting a fun project. I got a perspective shift instead. 🤯
🔗 GitHub link in the comments — try it with your own wallet address.
What surprised YOU most when you first touched blockchain data? I want to know. 👇

100DaysOfSolana #Solana #Web3 #BuildInPublic #SolanaDevs #Blockchain #LearnInPublic #DevCommunity #OpenSource

Week 2 of #100DaysOfSolana — Breaking down what I built and learned, day by day. 🔥

Siddhant Chavan — Wed, 20 May 2026 16:36:58 +0000

This week was packed. Here's exactly what went down:

📅 Day 8 — Reading Solana Data

Learned how to fetch and read on-chain data using a public address. The blockchain is fully transparent — you just need the right tools to query it. First time pulling live data felt like unlocking a superpower. 📖⚡

📅 Day 9 — Transactions in Solana

Went deep into how Solana transactions are structured, signed, and processed. Understanding the anatomy of a transaction — instructions, signers, recent blockhash — changed how I see every on-chain interaction. ✍️🔗

📅 Day 10 — Building a Solana Dashboard

Put Days 8 & 9 together and built a full dashboard that reads account data and transaction history from any public address. First real project of the challenge — turning raw blockchain data into something visual and usable. 📊🛠️

📅 Day 11 — Solana Accounts vs Traditional Databases

This one flipped my thinking. Solana accounts aren't database rows — they're more like files that store state, owned by programs. The shift from a Web2 database mindset to an on-chain storage model is real and essential. 🧠🗃️

📅 Day 12 — Devnet vs Mainnet

Understood the critical difference between Devnet and Mainnet — same code, completely different consequences. Knowing when and why to use each environment is foundational before you ship anything serious. 🚨🌐
5 days. 5 solid concepts. Each one building on the last.
The foundation is getting stronger — Week 3 is where it gets even more interesting. 🚀
Drop a 🔥 if you're also building on Solana!

100DaysOfSolana #Solana #Web3 #BuildInPublic #SolanaDevs #Blockchain #LearnInPublic #SolanaDeveloper

[Boost]

Siddhant Chavan — Mon, 18 May 2026 08:19:25 +0000

Intresting thing I thought in this 5 days

Siddhant Chavan — Mon, 18 May 2026 08:16:59 +0000

generated my first solana keypair from scratch and stared at the terminal for a solid 10 seconds 😅
no username. no email. no password. just a public key staring back at me — and that IS my identity on-chain. that's the shift. in web2 you log in. In web3 you prove you exist with cryptography.
went from zero setup to sending actual SOL between two wallets on devnet in 5 days. the moment sendAndConfirmTransaction resolved and both balances updated — that's when it stopped being theory.
what surprised me most: a wallet isn't a container for your tokens. the tokens don't "live" in your wallet. your wallet is just a keypair that proves you have authority over them.
next up — going deeper on on-chain identity and program interactions. day 6 and beyond 👀
screenshot of the terminal drop incoming 👇

100DaysOfSolana @solana_devs

I Started the #100DaysOfSolana Challenge — Here's My Honest Week 1 Recap (Days 1–5)

Siddhant Chavan — Wed, 06 May 2026 20:00:42 +0000

week 1 of my 100 days of solana challenge is officially done and honestly i didn't expect to learn this much in just 5 days.
i'm documenting everything publicly on github as i go — every script, every mistake, every "oh that's how it works" moment. here's what the first week actually looked like 👇

Day 1 — Just getting connected
before anything cool can happen you need to be able to talk to the network. day 1 was setting up the environment, installing @solana/web3.js, and making my first connection to devnet. ran getVersion(), got a response back from the cluster, and felt unreasonably happy about it. small win but it made everything feel real.

Day 2 — Keypairs and the account model
this is where solana's mental model starts to diverge from what you might know. generated my first keypair — public key is your on-chain address, private key is the secret you protect with your life. the bigger thing i had to sit with was solana's account model. everything on solana is an account. your wallet, a token, program state — all accounts. took a second read to really internalize it but once it clicked it clicked.

Day 3 — Free money (devnet airdrops)
requested my first airdrop on devnet and watched the balance update. 1 SOL dropped into a wallet i generated from scratch with a few lines of js. hit the rate limit a couple times which was honestly a useful lesson — you learn to confirmTransaction() properly when you're impatient and it keeps failing. also got comfortable converting between lamports and SOL (1 SOL = 1,000,000,000 lamports — yes, nine zeros).

Day 4 — Built an actual wallet UI
this was the best day of the week. stopped writing plain node scripts and built a small HTML interface for the wallet — connect button, displays your address, shows your live balance. wired the js logic directly to the DOM. the folder is literally called day-4-wallet. the moment it rendered in a browser and showed a real devnet balance it stopped feeling like exercises and started feeling like building something. that shift in feeling matters a lot when you're learning.

Day 5 — Sent my first real transaction
the milestone. built a SystemProgram.transfer instruction, wrapped it in a Transaction, signed it with the sender's keypair, and broadcast it to devnet. waited for the confirm. checked both balances. they changed. i don't know how else to describe it except that it hits different when you realize you just moved value on a live blockchain with code you wrote yourself, even if it's devnet SOL worth exactly nothing.
also learned about transaction fees the hard way — got an insufficient balance error because i forgot to account for the fee on top of the transfer amount. good teacher.

week 1 summary
→ connected to solana devnet
→ generated keypairs and understood the account model
→ airdropped SOL and read balances
→ built a wallet UI in HTML + JS
→ sent my first on-chain SOL transfer
the honest take: @solana/web3.js is surprisingly approachable if you already know javascript. the api isn't the hard part — it's building the right mental models around accounts, lamports, and how transactions are structured. once those click, things move fast.
95 days to go. see you at day 10 👀
all the code is open on github 👇
github.com/Siddhant0122/100-days-of-solana
I know i'm little late but I will make the backlogs turnover.

100DaysOfSolana #Solana #Web3 #BuildInPublic #Blockchain #LearnInPublic