Arc 13 of 100 Days of Solana starts today and it opens Epoch 4: Ship and Explore.
Every tutorial has the same ending. The program builds, the tests pass, it runs on devnet, and the article stops. Which is a strange place to stop, because that's exactly where a Web2 developer would say the interesting part begins: the production deploy.
Arc 13 is seven days on that part.
Mainnet is not just another cluster
On devnet, everything is free and nothing is permanent. Airdropped SOL, throwaway deploys, program addresses nobody will ever call. It's staging, and it behaves like staging.
Mainnet-beta changes four things at once. The deploy costs real SOL — program accounts are rent-exempt, and for a non-trivial Anchor program that's a real (if modest) amount of money. The program address becomes public infrastructure: anyone can find it, read it, and call it. Whoever holds the upgrade authority can replace the program's code entirely, which makes that keypair equivalent to root credentials on a production box. And there's no access control at the network level — strangers can send transactions to your program the moment it lands.
None of this is scary if you've run production systems before. It's the same discipline — deploy intentionally, control who holds the keys, publish a contract for integrators, handle failure states in front of users — wearing different names.
The Rosetta Stone
If you know the Web2 column, Arc 13 teaches you the Solana column:
| Web2 | Solana |
|---|---|
| Staging → production | Devnet → mainnet-beta |
| Release artifact | anchor build output (the .so file) |
| Production deploy rights | Upgrade authority |
| Branch protection / required reviewers | Multisig upgrade authority |
| OpenAPI / GraphQL schema | IDL |
| Generated typed SDK | Codama client |
| "Sign in with Google" | Wallet Standard |
| Public changelog / release page | Explorer link |
The one that surprises most people is the IDL. Solana programs don't self-describe the way a REST API with an OpenAPI spec does — unless you publish the IDL, at which point other developers can generate typed clients, inspect your instructions, and integrate without reading your source. Publishing it is the difference between a deployed program and a usable one.
The seven days
Day 85 — Deploy an Anchor program to mainnet-beta. The staging-to-production promotion, done deliberately rather than by accident.
Day 86 — Decide who is allowed to upgrade the program. Keep the authority, transfer it to a multisig, or burn it entirely — each is a real product decision with real trade-offs.
Day 87 — Publish the IDL and generate a typed client, so other developers can call the program without guessing at byte layouts.
Day 88 — Connect a wallet from the frontend and send a transaction. This is where a human finally meets the program.
Day 89 — Write useful messages for failed transactions. Wallet errors are production UX, not an edge case to be polished later.
Day 90 — Write a production launch checklist. The artifact future-you actually needs at 11pm before the next deploy.
Day 91 — Launch publicly, with an explorer link. A deploy isn't done until someone else can verify it.
What you'll have at the end
A program on mainnet-beta, a frontend that talks to it, and a public launch post backed by a verifiable on-chain receipt. Not "I completed a course" — "here's my program ID, go look."
That receipt matters more than it might seem. In Web2, a side project claim is just a claim unless it's deployed somewhere. On Solana, the explorer link is proof: the deploy transaction, the upgrade authority, the program's activity, all publicly inspectable. It's the strongest possible artifact for a portfolio or a launch post.
Joining
Interested but not started yet? No problem. You can learn the fundamentals at your own pace with our previous 84 challenges!
Start here: https://mlh.link/solana-100