DEV Community: Srashti

# Why I Chose Blockchain Over Normal Web Dev (And What I Gave Up)

Srashti — Sun, 14 Jun 2026 05:16:40 +0000

Let me be honest with you about something.

Choosing blockchain over regular web dev as a third-year CSE student is not the "safe" move. Nobody's recruiter is sliding into your DMs because you know Solidity. The placement cell doesn't have a checkbox for "deployed smart contracts on Ethereum."

I chose it anyway. Here's the actual story.

The moment I looked at web dev and felt nothing

First year. Everyone around me was learning React. HTML, CSS, JavaScript, then React, then Next.js, then whatever framework dropped last Tuesday.

I tried. I built things. A portfolio site. A to-do app. The classic beginner projects that every tutorial sends you to build and every recruiter has already seen ten thousand times.

And I kept thinking — who else is doing exactly this right now?

The answer was: a lot of people. A genuinely uncomfortable amount of people. All learning the same stack, building the same projects, competing for the same internships at the same companies.

I didn't want to be in that queue. Not because I'm too good for it — I'm not. But because the queue was already so long, and I wasn't even sure I wanted to be at the front of it.

Then I found the question that changed everything

What if you could write code that nobody could tamper with?

I've written about this before. But it's worth saying again because it's genuinely the reason I switched.

Not the money. Not the hype. Not because "Web3 is the future" — I don't know if it is. Nobody does.

It was that question. The idea that logic could sit on a chain, execute automatically, and be readable by anyone. No company behind it. No server you have to trust. No terms of service that can change overnight.

Code as law. Not metaphorically. Literally.

That idea grabbed me in a way that "build a full-stack CRUD app" never did.

What I actually gave up

I'm not going to pretend this was a cost-free decision. It wasn't.

The internship path is harder.

Web dev has a pipeline. Learn React → build projects → apply to startups → land a frontend internship. It's competitive but it's mapped. The roadmap exists. Companies know what to look for. Candidates know what to build.

Blockchain doesn't have that yet. Not in India. Not at the second-year level. There are companies building in Web3, but they're fewer, they're pickier, and they often want experience that takes longer to build.

I knew this going in. I chose it anyway.

The community is smaller.

Stuck on a React bug? Stack Overflow has fourteen answers, three YouTube walkthroughs, and a Reddit thread from 2019 that somehow still applies.

Stuck on a Solidity error? You're reading the docs, the GitHub issues, and occasionally a Discord server where someone might reply in four hours.

I got used to figuring things out alone. Honestly? That's made me better at it.

The tutorials run out faster.

Web dev content is infinite. You could watch tutorials for a year and still have a queue.

Solidity tutorials are good — Patrick Collins is genuinely excellent — but you hit the edge faster. At some point, you're reading Ethereum Improvement Proposals and audit reports to understand something. That's a different kind of learning.

What I got instead

Here's the thing nobody tells you about picking the less crowded path.

When the field is smaller, you stand out faster.

I'm a second-year student. I've deployed contracts on testnet, I'm building a crowdfunding DApp, and I write about it publicly. In web dev, that's table stakes. In blockchain, at my year, in my city? It's genuinely rare.

I'm not saying I'm exceptional. I'm saying the bar to be visible is lower because fewer people are showing up consistently.

And the problems are genuinely unsolved. In web dev, the wheel has been invented. You're optimizing it. In blockchain, people are still figuring out what the wheel should even be. Smart contract security, gas optimization, decentralized identity, cross-chain bridges — these aren't finished problems. They're open questions.

I want to work on open questions.

The honest version of "follow your passion"

Everyone says follow your passion. Nobody says what happens when your passion is inconvenient.

Blockchain is inconvenient. It's harder to learn, harder to get hired in, and harder to explain to relatives who want to know when you're getting a "real job."

But every time I deploy a contract and watch it execute — no server, no company, no middleman — I feel something that I never felt building a to-do app.

That feeling is worth the inconvenience.

If you're deciding right now

If you're a CS student weighing this choice — I'm not telling you to pick blockchain. I'm telling you what I picked and why.

Web dev is not lesser. It pays well, it has a clear path, and there's real craft in building great products. If React excites you the way Solidity excites me, do React. The passion matters more than the stack.

But if you're in that queue and feeling nothing — maybe look at what's outside it.

The crowded path is crowded for a reason. But it's not the only one.

I'm Srashti Gupta, building in the Web3 space. I write about blockchain, real experiences, and things I'm figuring out in public. Let's connect on LinkedIn.

# What is a Smart Contract? I'll Explain It Like You're 15.

Srashti — Fri, 12 Jun 2026 14:34:12 +0000

Okay real talk.

When I first heard the term "smart contract" — I genuinely thought it was some kind of AI thing. Like a contract that reads itself and highlights the suspicious clauses your lawyer missed.

It is not that.

It's actually way cooler. And also kind of simpler. Let me explain it the way nobody explained it to me.

First, forget everything you know about contracts

A normal contract — the kind lawyers write — is a piece of paper (or a PDF nobody reads) that says:

"If X happens, then Y must do Z."

If you buy a house, the contract says — seller hands over keys, buyer hands over money. Simple enough. But here's the thing: someone has to enforce it. A bank. A lawyer. A court. Some middleman who takes a cut and also goes on holiday at the worst possible time.

A smart contract does the same thing. If X happens, then Y must do Z.

Except nobody enforces it. The code does.

No middleman. No fees to a third party. No "we're processing your request, please allow 5-7 business days."

Just: condition met → action executed. Automatically. On a blockchain. Forever.

The vending machine analogy (because it actually works)

Think of a vending machine.

You put in ₹20. You press B3. The chips drop. Done.

The vending machine doesn't care who you are. It doesn't ask for your ID. It doesn't have a manager who needs to approve your chip request. You gave it the right input, it gave you the right output.

Now imagine that vending machine is:

Publicly visible — anyone can see exactly how it works
Tamper-proof — nobody can secretly reprogram it to steal your money
Running forever — it can't be "shut down" by any one person

That's a smart contract.

Okay but what does the code actually look like

Here. I'll show you the simplest one that actually does something:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract SimpleStorage {
    uint256 public myNumber;

    function store(uint256 _number) public {
        myNumber = _number;
    }

    function retrieve() public view returns (uint256) {
        return myNumber;
    }
}

This contract does two things:

Store a number on the blockchain
Let anyone retrieve that number

That's it. No database. No backend server. No hosting bill. The number lives on Ethereum — accessible to anyone, changeable only through the store function, and permanent.

"But Srashti, that's just a variable. My first Python script did that."

Yes. But your Python script lived on your laptop. This lives on a global decentralized network that nobody controls. That's the difference.

Why does this matter? (The part that actually hit me)

Let me give you a real example.

Imagine you and a friend make a bet. India wins the World Cup — you owe them ₹500. They win — they owe you ₹500.

Normal situation: one of you is going to "forget." Or dispute the terms. Or just Venmo the wrong amount and pretend it's fine.

Smart contract situation: you both lock ₹500 into a contract. The match result gets submitted (via something called an oracle — different topic). The contract automatically sends ₹1000 to the winner. No arguments. No awkward reminders. No "I'll pay you back next week."

The code is the agreement. The code is the enforcement. They are the same thing.

The part that sounds too good to be true

"But what if the code has a bug?"

Great question. This is actually the terrifying part.

Once a smart contract is deployed on Ethereum, it's immutable — meaning it can't be changed. If there's a bug, the bug is there forever. In 2016, a vulnerability in a smart contract called The DAO got exploited, and $60 million was drained.

The code was the law. The code had a flaw. The law had a flaw.

This is why security in Solidity is treated like a religion. You don't ship and hotfix. You audit, test, audit again, and then maybe think about deploying.

It's also why I find it more interesting than regular web dev — the stakes are real. A badly written if-statement doesn't just break a feature. It can empty a wallet.

So where do smart contracts actually live

On the Ethereum blockchain. Specifically, they live at an address — just like your wallet has an address, contracts do too.

Anyone can interact with a contract if they have its address and ABI (basically the contract's instruction manual — what functions exist and what they take as input).

You don't need to trust the developer. You don't need to trust the platform. You just read the code and decide for yourself. Because the code is open, on-chain, and exactly what's running.

That's the part that got me. Not the tech. The philosophy.

What if the rules of a system were visible to everyone? What if "trust me" could be replaced by "read this"?

That's what smart contracts are building toward.

The quick version if you zoned out

A smart contract is code that runs on a blockchain
It executes automatically when conditions are met — no human needed
It's immutable once deployed — which makes security critical
Anyone can read it — no black boxes, no "trust us"
It's not AI. It's not magic. It's just logic that nobody can tamper with

What's next

From here, smart contracts get more interesting — events, mappings, modifiers, inheritance. The SimpleStorage above is barely scratching the surface.

But the mental model? You now have it.

Code is the contract. The blockchain is the judge. And nobody can bribe either of them.

still learning still documenting

I Learned Solidity From YouTube. Here's Exactly What Happened.

Srashti — Wed, 10 Jun 2026 10:42:26 +0000

Hey, I'm Srashti 👋 I'm a CSE student who is genuinely obsessed with blockchain and decentralized technology.

While the standard path for many computer science students starts with building classic CRUD apps, I found myself pulled down a different rabbit hole entirely: deploying smart contracts on Remix and trying to understand the inner workings of Ethereum. I learned Solidity through YouTube, broke countless contracts, and slowly started to stitch the pieces together.

Here is the honest breakdown of how I went from struggling with basic syntax to deploying decentralized applications—and how you can do it too.

Why Web3 Captured My Attention

I wasn't chasing the crypto hype or looking at NFTs. What actually pulled me into the ecosystem was a foundational software engineering question:

What if you could write code that nobody could tamper with?

No middlemen. No centralized servers controlled by a single entity. Just pure, immutable logic sitting on a blockchain, executing exactly as written forever. That concept shifted how I thought about programming. Eager to understand it, I went looking for high-quality educational resources and stumbled onto Patrick Collins' content on YouTube.

Finding the Right Mentor

If you are a beginner trying to learn Solidity, Patrick Collins is highly recommended for a reason. His teaching style is clear, honest, and structurally sound. He explains the why behind architectural patterns, not just the how. For someone curious but completely new to web3 development, his deep dives made all the difference.

What Is Remix? (And Why It’s the Perfect Launchpad)

Remix IDE is a browser-based development environment for writing, compiling, and deploying Solidity smart contracts.

No Setup Required: You don't have to fight your local environment, install dependencies, or configure path variables. You just open the tab and write code.
Heavy Lifting Included: Remix handles the compiler, local deployment runtimes, and test networks out of the box, allowing you to focus purely on learning the language semantics.

The Gap Between Theory and Code

Understanding the high-level theory of a smart contract is straightforward. It functions essentially like a digital vending machine: you provide the correct input, and it guarantees a specific output without human intervention.

But writing actual Solidity for the first time? That is where the friction starts. Take a look at this basic SimpleStorage contract:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract SimpleStorage {
    uint256 public myNumber;

    function store(uint256 _number) public {
        myNumber = _number;
    }

    function retrieve() public view returns (uint256) {
        return myNumber;
    }
}

It looks simple on paper, but as a beginner, every line introduces a new mental hurdle:

Why does every file require an SPDX-License-Identifier?
What is the specific role of the pragma solidity compiler flag?
Why favor uint256 explicitly over standard integers?
How do visibility modifiers like public alter the state behavior and gas metrics?

Bridging the gap between conceptual understanding and functional syntax is where most developers stall. My approach was iterative: I consistently rewatched technical breakdowns, analyzed compiler errors, and rewrote the same logic line-by-line until the underlying architecture made sense.

The Moment It Clicked

Everything changed when I deployed this contract to a local simulated network inside Remix. I executed the store function, passed a parameter, signed the transaction, and called retrieve. Seeing the state update seamlessly on a simulated blockchain layout made the theory real. There was no traditional database or centralized server backend—just the autonomous execution of the code.

Key Takeaways Beyond the Syntax

Moving past the basics taught me a few fundamental realities of blockchain development:

Solidity requires a completely different mental model. While the syntax mirrors JavaScript, the execution environment does not. You are writing code for a decentralized state machine where every operations carries a gas cost and state modifications are permanent. Optimization is a necessity, not an afterthought.
Remix is a testing ground, not a production suite. Remix is incredible for rapid prototyping. However, scaling up means transitioning to professional frameworks like Hardhat or Foundry, and managing state interactions via developer tools like MetaMask.
Debugging is the best teacher. Deploys will fail, transactions will revert, and logic will break. Analyzing transaction logs and EVM execution errors teaches you more about the runtime environment than any passive tutorial ever could.

My Current Stack and Next Steps

Since writing that first SimpleStorage contract, I've expanded my technical toolkit to include:

Advanced smart contract development with Solidity
Testing, scripting, and local deployment pipelines using Hardhat
Integrating decentralized backends with frontend applications using MetaMask and Web3.js

The learning curve in Web3 is continuous, and the best way to master it is to build actively. If you're looking to start, don't wait until you feel like you know everything. Open up an IDE, write a basic contract, analyze the edge cases, and start deploying.

Are you currently learning Solidity or building in Web3? Let's connect in the comments below—I'd love to hear about the projects you're working on or the resources that helped you clear the hurdle!