Modern devs of all kinds are regularly faced with the same dilemma: trying to determine which new language/stack/framework etc is worth the time and effort to learn and add to our tool belt, especially when that time and effort could instead be spent refining the skills we already have.
I’ve been a Solidity dev for just over 7 years. In that time I’ve launched a few successful projects of my own, done a lot of contracting, and even had the title of Senior Blockchain Dev at a couple of companies. All of this is to say I think I can confidently call myself a “Seasoned Ethereum Developer”.
In that time, the Ethereum ecosystem has evolved and matured quite significantly. The tools we have to work with and the capabilities of Solidity itself have both been improved a lot by the hard work of the Ethereum community.
Trying to debug a smart contract in a time before custom revert messages (ie. before require(condition, message) ) was a much more laborious process, and my dev environment before Hardhat existed included a lot more home-made tools. There are many more examples, but all of them are testament to the fact that a lot of the best dev talent in web3 has channeled their energy into making the Ethereum environment a pleasure to work with.
And so, it is with these quality tools at my fingertips, and with this level of experience, that I decided a few months ago to learn Solana dev. In this first article we’ll start off with a more high level discussion, and I’ll cover more specific aspects of Solana as an Eth developer in subsequent articles.
I suspect that people asking “why?” will fit into one of two camps. Those with a genuine curiosity about Solana dev who want to know if it’s worth their time, and those Ethereum devs who are more skeptical wondering why I would spend the energy on something they consider inferior to Eth.
I do have some reasons, but before I give them I want to push back against this impulse in general. There are a lot of loud voices that will tell you everything you do has to be maximally productive or be a step towards some sort of pre-defined financial or lifestyle goal which is then a measure of your value as a person. To be blunt, this is dumb as shit, and is corrosive to your own humanity. There is great value in doing stuff for no reason other than because you find it interesting or enjoyable.
In fact, despite it being nearly a decade of my career, when I started learning Ethereum I didn’t do it because I expected to make money off it. I did it because the tech seemed cool af, and “this seems cool” is a much stronger motivator for me to learn about something than “this might make some money”. You may not feel the same, but I think this perspective needs to be spread more. Sometimes it’s valid to just do things because you want to.
Philosophical discussions aside, there were some practical considerations that I made when deciding to learn Solana. The space we operate in as web3 devs is heavily influenced by network effects, where any chain or dapp’s practical value exponentially increases with the number of people using it. This means that regardless of any considerations of tech, we need to also consider the user base of the chain/platform we pick.
Unlike web devs, whose choice of framework won’t actually influence how many people can theoretically use their websites, we are constrained by the popularity of the chains we use. It doesn’t matter if NewFancyBlockchain™ has the fastest blocktime, most advanced smart contracts, and cheapest transactions. If that network only has 1000 users, then that is the upper limit to how many users your Dapp will have if you deploy it there.
For this reason alone, it was very easy to be a bit of an Eth maxi for quite a long time. Mainnet had all the real activity and all the attention on it too. Launching a dapp on Eth meant you were in the place where most web3 users already were. Otherwise the conversation would go something like:
“Check out this thing I made!”
“Is it on Ethereum?”
“No, it’s on [some other network or L2]”
“Oh… I don’t even know how to get coins there.”
But, as tx costs grew with increasing gas and ETH prices, more and more regular users became a little dissuaded. Various EVM L2s and other networks popped up to try to offer a solution to this problem, but none of them emerged as the new de facto EVM chain. Instead, the attention of the space became quite fractured, and the network effects of a unified community were somewhat lost.
Indeed, even though it seems like a new chain launches every month, quickly seeing billions of dollars in TVL, they can sometimes feel like a bit of a ghost town.
(Author’s note: I’m not mentioning chain-abstraction which is pretty new. This may improve things in the Eth space, we shall see. )
All of this is to say that when the Solana meme-coin bubble started kicking off last year, it didn’t just bring an influx of users to that chain, but a community that were all focused on and talking about it. The sophistication of your average Solana user in 2025 may not be the same as the sophistication of your average Ethereum user in 2018, but this brought the promise of a new landscape to build in.
It seemed with this level of activity that at the very least I wasn’t going to spend all this time upskilling only to find an ecosystem with no real activity.
So, to answer the question of “why?” simply: it seemed to me like Solana had matured to a point where I could build stuff there and have a reasonable expectation of it succeeding. You may think I’m wrong about this, or that I’m way too late to the party, but this was my primary reasoning.
First impressions can make a big difference as to whether we dig into a new tech. Coming from the well polished and refined Ethereum ecosystem into Solana can feel like turning off a freshly sealed freeway onto a gravel back-road. But before I cover that, I want to mention a couple of aspects of Solana that are a little nicer than what’s available with Eth.
Multiple transactions as one transaction
The terminology of this subtitle is technically inaccurate, but as a comparison to Etheruem it is apt. In Eth if we have two public functions on our smart contract, doSomething() and doSomethingElse() our EOA will need to do two transactions in order to execute both of them.
We are all very familiar with the design pattern of having to approve a token in one tx, and then spend it in the next. But Solana allows us to bundle multiple instructions into a single tx. Something like:
//Warning: psuedocodeconst tx = Transaction();
tx.add(doSomething());
tx.add(doSomethingElse());
tx.nowDoTheTransaction();
The user will be given a single prompt to sign the tx, and either both will execute or the tx will fail.
(Note: The introduction of AA wallets to Eth and user-ops promises something similar, let’s hope that gets wide adoption).
No GAS fees
I have spent days, possibly weeks of my life refining smart contracts to shave off a few hundred or thousand GAS from transactions. During the Gas Wars of yore, especially before some of the storage cost improvements to the EVM, a single use of the sstore opcode could add $10+ to a user’s tx. In practice this meant the right design pattern choices or even just shaving off a single write could hugely effect the number of users that your dapp would see.
There are countless ideas I had to shelve because the tx economics of what was needed just meant they would never be practical.
Solana does away with this, and just has a flat tx fee. There are still computational limits for what can be included in a tx, but the user isn’t paying by the opcode, so your design patterns don’t need to be dictated by this.
It’s quite liberating and exciting to be able to design things free of these constraints.
Storage on Solana is quite different to Eth, and there are some additional costs related to storage, but I’m going to save that for a later, more technical article. For now, the takeaway is that we can build stuff without a GAS-first approach.
On a first-impression basis, it’s hard to judge the deep capabilities of a platform since by definition you are just getting started. However, one of the biggest negatives of getting started with Solana actually has nothing to do with the tech itself.
Documentation needs some love
The very first thing I noticed with Solana was the lack of quality of documentation throughout the ecosystem. Coming from a world with things like Solidity’s well maintained and thorough documentation, Solana was a bit of a shock to the system.
There are many small errors, omissions, or entire pages with the equivalent of just “TODO” all over the place. To a new dev in the space trying to orient themself, this is extremely unhelpful. It’s much easier to navigate these sorts of problems once you have a little experience with the tech, but trying to bridge that gap from 0 knowledge to some knowledge is always the most daunting and demoralising when something goes wrong.
One of the earliest mistakes I encountered was the equivalent of a “Hello World” tutorial omitting a specific import statement, causing the whole thing to fail. This is a pretty easy fix once you know what you’re looking for, but when you’re just following a tutorial to the letter and it’s still not working, it gives a very strong “wtf?!?” sensation.
I think moments like these could lead to higher new-dev attrition, and an overhaul of the Solana docs would be a very low-cost, high-value improvement to the space, as it would pave the way for more new-dev talent to join.
The Solana stack exchange is also sadly nowhere near as active or reliable as the Ethereum one.
Tools and Infrastructure (Wallets)
Again, I will save the more detailed discussion of tech for a future article, but another thing I noticed very early on was the relative quality of available Solana wallets. I enjoy using Metamask for dev because it’s very easy to hook it up to my local Ganache chain and it all works as seamlessly as if it were on a public network.
Most Solana wallets don’t even allow you to connect to a local network, and it seems the only which can (Phantom) has very limited functionality when it does. I like my dev environment to be a well oiled machine, and this just feels sloppy.
There are a lot of things like this which, given SOL has a $64 Billion market cap, and is over 5 years old now, you’d kind of expect a little more attention to be given. They’ve certainly got the resources and they’ve certainly had the time.
So with these considerations and first impressions, was it worth digging deeper? Well, I made it past the initial hump so I clearly thought so. I’ve had plenty of moments where I yearned for the refined and well-paved world of Ethereum, but it’s cool to add a new tool to my belt, and I also enjoy a challenge.
I’m going to wrap this up here so that it’s not too long, but future articles will be more focused (we haven’t even mentioned Rust yet!)
If you have any questions or disagreements with what I’ve written, please feel free to reach out. This is all just one dev’s opinion, and that opinion is open to change.
