Srashti

Posted on Jun 12

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

#web3 #blockchain #tutorial

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.

DEV Community