For the past two weeks I’ve been diving deeper into Solana development as part of the #100DaysOfSolana challenge.

Even though I already had experience in software engineering and blockchain development, I realized very quickly that understanding Solana is not only about learning new tools or SDKs — it’s about changing the way you think about applications, state, and ownership.

What surprised me the most

Coming from a traditional Web2 background, I expected blockchain data to feel similar to working with a distributed database.

But Solana’s account model feels very different once you start interacting with it directly.

At first, hearing “everything is an account” sounded simple.

Then I started inspecting accounts through the CLI:

> solana account $(solana address)

That was one of the first moments where things started to click.

A wallet is not just an address. It is actual on-chain state:

• balance
• ownership
• permissions
• executable flags
• raw data storage

And unlike traditional databases, every validator in the network maintains that state collectively.

That changes your perspective completely.

The “public database” idea finally became real

One of the biggest mindset shifts for me was understanding that Solana is not trying to replace databases.

Instead, it solves a different problem:
how to coordinate state in a trustless environment where no single company owns the infrastructure.

In Web2:

• your backend owns the database
• your server controls access
• users trust your application

In Solana:

• users own accounts
• programs define rules
• validators enforce execution

That distinction became much clearer after comparing traditional databases with Solana accounts side by side.

RPC calls felt very different from APIs

Another interesting realization was how different reading blockchain data feels compared to traditional APIs.

Normally in Web2:

• you call an API endpoint
• the backend queries a database
• the server returns processed data

In Solana:

• you read raw account state through RPC
• there are no SQL joins
• no relational queries
• no backend magically assembling your data

You start understanding very quickly why indexing layers and infrastructure providers are so important in Web3.

The first time I used methods like:

> connection.getAccountInfo(publicKey)

I realized:
this is much closer to reading low-level state than consuming a normal REST API.

What still feels confusing

One thing I’m still trying to better understand is how large-scale Solana applications organize and index massive amounts of account data efficiently.

The account model makes sense conceptually, but designing scalable architectures around:

• PDAs
• indexing
• account relationships
• pagination
• caching
• transaction limits

feels very different from designing traditional backend systems.

I’m also interested in learning more about:

• Sealevel parallel execution
• account compression
• advanced Anchor patterns
• Solana runtime internals
• validator architecture

These two weeks reinforced something important for me:

Web2 knowledge still matters a lot in Web3.

Concepts like:

• data modeling
• architecture
• security
• scalability
• developer experience

all still apply.

But Solana forces you to rethink where state lives, who owns it, and how applications interact with it.

And honestly, that’s what makes learning it so interesting.