February 22, 2026 24 min read

Your Money Is Just a Number in Someone Else's Spreadsheet

When you send money to a friend, nothing actually moves. Your bank changes two numbers in a spreadsheet: yours goes down, theirs goes up. Your salary, your savings, your entire financial life is just a row in someone else’s database.

This guide is about what happens when you ask: does it have to be? We start from the most basic problems with digital money and build up, piece by piece, until the answer becomes obvious. Every concept earns its place by solving a real problem.

Part 1: The Fundamental Problems

1.1 The Problem of Digital Ownership

Pick up your phone. You “own” it physically. If you hand it to someone, you no longer have it. This is intuitive.

Now open a photo on your phone. Send it to a friend. You both have it now. You can send it to 1,000 people. Everyone has it.

This is the core tension of the digital world: digital things can be copied infinitely at zero cost.

So here’s the question that breaks everything:

If I want to send you digital money, how do we make sure I can’t just “copy” that money and spend it again?

This is called the double-spend problem, and it is the single most important problem in all of Web3. Every innovation in this space traces back to solving this one issue.

1.2 The Traditional Solution: Trust a Middleman

For decades, we solved this with a simple approach: put someone in the middle.

You --> [Bank] --> Your Friend

When you transfer $100 to your friend:

You tell the bank “move $100 from my account to theirs”
The bank checks: does this person actually have $100?
The bank subtracts from your balance, adds to theirs
The bank keeps the record

That’s it. No money “moved.” The bank just edited its own spreadsheet.

This works. But it requires one critical ingredient: you must trust the bank.

You trust that:

The bank won’t change the numbers arbitrarily
The bank won’t disappear with your money
The bank won’t deny your transaction happened
The bank will be available when you need it

1.3 The Problem With Middlemen

Middlemen create real problems:

Problem	Example
Single point of failure	Bank servers go down, you can’t access your money
Censorship	A government tells the bank to freeze your account
Exclusion	1.3 billion adults worldwide have no bank account
Rent-seeking	The middleman charges fees for updating numbers in a database
Opacity	You can’t verify what the bank is actually doing with your money

These aren’t hypothetical. They happen every day, everywhere.

1.4 The Real Question

So the fundamental question becomes:

Can two people who don’t know or trust each other agree on the truth, without needing a trusted third party in the middle?

For most of human history, the answer was no.

Then in 2008, someone (or some group) called Satoshi Nakamoto published a paper that said: yes.

But to understand how, we need to learn the building blocks first.

Part 2: The Building Blocks (Cryptography You Actually Need)

You don’t need a math degree. You need to understand three tools.

Satoshi’s answer to the middleman problem required each of them. And each one exists because removing the middleman creates a new vulnerability that needs solving. One leads to the next.

2.1 Hash Functions: How Do You Know Nobody Changed the Records?

Let’s go back to the bank scenario.

You just fired the bank. Great, no more middleman. Now you and your friend each keep your own copy of the ledger. You write down every transaction between you two in a notebook.

But here’s the problem. You go to sleep. You wake up. You open the notebook and see: “Alice sent Bob 500 coins.”

Did that entry exist yesterday? Or did someone sneak in and write it last night?

Without the bank, there’s nobody to call and ask “hey, is this legit?” You need a way to know, with certainty, whether anyone has tampered with your records.

Here’s the trick. Imagine you could run your entire notebook through a machine that spits out a single, unique fingerprint. If your notebook says exactly the same thing today as it did yesterday, the fingerprint is identical. But if someone changed even a single comma, the fingerprint looks completely different.

That machine is called a hash function.

Input: "Alice sent Bob 5 coins"
Hash:  b31be51abf50a797c05d746a8bdc77f16446a3bcba2eda5fcf369dd24fc3fec6

Input: "Alice sent Bob 50 coins"   (changed 5 to 50)
Hash:  a2ceb7fec86a26403ae00eb45afc261e95077e1ed6c770ac522b8efa95f6378f

The inputs differ by one character. The outputs are completely unrecognizable from each other. That’s the key: the same input always produces the same fingerprint, any change produces a completely different one, and there’s no way to work backwards from a fingerprint to the original data. Nobody can make a sneaky edit. Any change screams.

So now you have your first tool. You can detect if anyone has tampered with the ledger. But there’s a new problem waiting.

2.2 Public-Key Cryptography: How Does Anyone Know It Was Actually You?

You can detect tampering now. But think about this.

Someone writes in the shared ledger: “Alice sends 100 coins to Bob.” How does everyone know that Alice actually wrote that? What if Bob wrote it himself and just signed Alice’s name?

In the old system, the bank handled this. You logged in with your username and password. The bank verified your identity. The bank authorized the transfer.

No bank means no login system. No identity authority. So how do you prove you are who you say you are?

Here’s the idea. Imagine you have a special pair of keys.

The first key is your private key. You keep this one secret. You never show it to anyone, ever. Think of it as a pen that writes in handwriting so unique that it can never be forged.

The second key is your public key. You give this one to everyone. Think of it as a magnifying glass that can examine that handwriting and confirm: “yes, this was written by Alice’s pen.”

Private Key  -->  [math]  -->  Public Key
(your secret pen)              (everyone's magnifying glass)

The critical property: you can create the magnifying glass from the pen, but you can never recreate the pen from the magnifying glass. The math only works in one direction.

So when you want to send coins, here’s what happens:

You write the transaction: “Alice sends 10 coins to Bob”
You sign it with your private key, producing a digital signature
Anyone in the network can take your public key and verify: “This signature could only have come from Alice’s private key”

Nobody sees your private key. They don’t need to. They just need your public key to verify the signature.

This is your identity in Web3. No email. No password. No “Forgot password?” link. Your private key is you. Your public key (which becomes your “wallet address”) is how the world recognizes you.

So now you have two tools. You can detect tampering, and you can prove identity. But there’s still one vulnerability left.

2.3 Peer-to-Peer Networks: What If the Computer Goes Down?

You have tamper detection. You have identity. But where does the ledger actually live?

If it lives on one computer, you have a problem. That computer’s hard drive crashes, and all records are gone. Or worse, the person who runs that computer starts calling the shots about which transactions get recorded.

You’ve just rebuilt the middleman with extra steps.

Think about how rumors spread in a small town. You tell your neighbor something. They tell three others. By the end of the day, the entire town knows. Nobody controls the flow of information. There’s no “rumor server” that can go down. The information exists everywhere, in everyone’s memory, simultaneously.

That’s the structure you need for a ledger without a middleman. Not one copy on one computer. Many copies on many computers, all talking to each other directly.

This is called a peer-to-peer (P2P) network.

Traditional (one computer in the middle):

    You         Alice   -- [Central Server] -- The Ledger
    Bob     /

Peer-to-peer (everyone has a copy):

    You --- Alice
     |     /   |
     |    /    |
     |    /    |
     |   /     |
    Bob --- Charlie

In a P2P network:

Every participant (called a node) keeps a full copy of the ledger
Nodes talk directly to each other, no central authority routing messages
If one node goes offline, nothing happens. The rest carry on.
No single node can censor or alter the ledger, because thousands of other copies exist

Now you have all three tools. Hash functions catch tampering. Public-key cryptography proves identity. Peer-to-peer networks remove the single point of failure.

The question becomes: how do you combine them into one system?

Part 3: Blockchain, From the Ground Up

3.1 Let’s Build It

You have the notebook (the ledger). You have fingerprints (hash functions) that catch tampering. You have the special pen and magnifying glass (public-key cryptography) that prove identity. And you have thousands of people keeping their own copies (peer-to-peer network).

Now, how do you actually run this thing?

Let’s walk through it. Picture a town of 10,000 people. No bank. Everyone has a notebook. Transactions are happening constantly: Alice pays Bob, Bob pays Charlie, Charlie pays Dave.

3.2 The Problem With Writing One Transaction at a Time

If everyone tries to record transactions one by one, it’s chaos.

Alice shouts “I’m sending 10 coins to Bob!” You write it down. But at the same exact moment, someone on the other side of town shouts a different transaction. Some people hear Alice first. Some hear the other person first. Now everyone’s notebooks are in a different order.

And it gets worse. What if Alice tries to spend the same 10 coins twice, shouting to two different parts of town at once, hoping each side only hears one?

Writing transactions one at a time doesn’t scale. You need structure.

3.3 Pages in the Notebook: What a “Block” Actually Is

Here’s the solution. Instead of writing transactions one at a time, you collect a batch of transactions and write them together as a single page.

Every few minutes, one person gathers up all the recent transactions, checks that they’re valid (does Alice actually have 10 coins to send?), and writes them onto a new page. (Who that person is and how they earn that right is the hardest part of the entire system. We’ll get there in section 3.5. For now, just understand the structure.)

That page is a block.

Page 1
├── Alice --> Bob (5 coins)
├── Carol --> Dave (3 coins)
├── Timestamp: 2024-01-01 10:00:00
├── Fingerprint of this page: a1b2c3...
└── Fingerprint of previous page: 000000... (first page, nothing before it)

Page 2
├── Bob --> Charlie (2 coins)
├── Dave --> Alice (1 coin)
├── Timestamp: 2024-01-01 10:10:00
├── Fingerprint of this page: d4e5f6...
└── Fingerprint of previous page: a1b2c3... (points back to Page 1)

See that last line on each page? Every new page includes the fingerprint of the page before it. Page 2 references Page 1. Page 3 will reference Page 2. Page 4 will reference Page 3.

This is the “chain” in blockchain. Every page is linked to the one before it, all the way back to the very first page ever written (called the genesis block).

3.4 Why You Can’t Rewrite the Past

Now here’s where it gets clever. Imagine someone wants to cheat. They want to go back to Page 3 and change “Alice sent Bob 5 coins” to “Alice sent Bob 500 coins.”

They change the transaction. But remember what you learned about fingerprints in Part 2. Change even one character, and the fingerprint is completely different.

So Page 3’s fingerprint changes. But Page 4 has the old fingerprint of Page 3 baked into it. Now Page 4 doesn’t match. It’s broken.

To fix Page 4, you’d need to rewrite it with the new fingerprint. But that changes Page 4’s fingerprint. Which breaks Page 5. Which breaks Page 6. Like a row of dominos falling.

To change one transaction, you’d have to rewrite every single page that comes after it. And you’d have to do this across thousands of computers that all have their own copies. And you’d have to do it faster than new pages are being added by everyone else.

This is practically impossible. Once something is written into the blockchain and a few pages have been added after it, the past is locked. That’s powerful for security. But it also means mistakes are permanent. Send coins to the wrong address, and there’s no undo button, no customer support, no reversal.

3.5 The Loudest Problem: Who Gets to Write the Next Page?

Everything so far makes sense. But there’s a question we’ve been dodging.

You have 10,000 people in the town with notebooks. Transactions are piling up. It’s time to write a new page. But who writes it?

If anyone can just write a page whenever they want, you’re back to chaos. Two people write conflicting pages at the same time. Someone writes a page full of fake transactions. Someone writes pages faster than everyone else and fills the notebook with garbage.

You need a rule for who earns the right to write the next page. And the rule has to work without a leader, without a vote, and without trusting anyone.

This is called the consensus problem. It’s the hardest part of the whole system. And there are two major approaches.

Here’s what’s happening in the town right now. People are shouting transactions: “I’m sending 5 coins to Alice!” “Bob is paying Carol 3 coins!” These transactions don’t get written into a page immediately. They land in a pile on everyone’s desk, a waiting room called the mempool. Every node in the network keeps its own copy of this pile. Nobody owns it. It’s just the queue of “things that need to be recorded but haven’t been yet.”

The question is: how do those transactions get from the pile into the next page?

Proof of Work (PoW): Earn the Right Through Effort

This is the original approach, used by Bitcoin.

The town makes a rule: before you can write the next page, you have to solve an extremely hard puzzle. The puzzle has no shortcut. You just have to guess and check, millions and millions of times, until you stumble on the right answer.

hash(page_data + guess) = 0000000000...abc123
                          ^^^^^^^^^^ must start with many zeros

You try guess #1... nope.
You try guess #2... nope.
...
You try guess #4,827,193... it works!

Solving the puzzle is brutally hard, but checking the answer is instant. Anyone can plug in the answer and verify in milliseconds. So when someone shouts “I solved it! Here’s my page!”, the whole town can confirm it immediately.

The people competing to solve this puzzle are called miners. Let’s watch the entire cycle play out with a real example.

Say you want to send 1 BTC to Alice. Here’s what happens, step by step:

You broadcast your transaction. Your wallet signs a message (“send 1 BTC from my address to Alice’s address”) and attaches a small transaction fee, your bid for how quickly this gets processed. It sends this to the network. At this moment, nothing has moved. Your coin hasn’t gone anywhere. It’s just an announcement floating in the mempool on thousands of computers: “this person wants to send 1 BTC to Alice.”
Miners start racing. Miners around the world grab your transaction along with hundreds of others from the mempool. They check each one: does this person actually have the coins they’re trying to send? If you have 1 BTC, your transaction is valid. They bundle the valid transactions together and start guessing at the puzzle.
A miner wins. Somewhere in the world, a miner’s computer stumbles on the right answer after millions of guesses. They package everything up: the transactions, the puzzle solution as proof, and the fingerprint of the previous page. They broadcast this new page to the network.
Everyone verifies. Every other node checks: is the puzzle answer correct? Are all the transactions legitimate? This takes milliseconds. If everything checks out, all 10,000 notebooks add the page. Your transaction is now confirmed and leaves the mempool.
The miner gets paid. The winning miner receives your transaction fee plus a block reward, newly created coins that the protocol generates for them. This is where new Bitcoin actually comes from. It’s not printed by anyone. It’s earned by doing the work of securing the network.
The race starts over. New transactions have been piling up in the mempool while all this was happening. The next round begins immediately.

On Bitcoin, this entire cycle takes roughly 10 minutes. It never stops.

But your transaction might not be fully “safe” yet. Alice might wait a little longer. She wants to see a few more pages stacked on top of the one containing your transaction. Each new page makes it exponentially harder to reverse. One page deep is pretty safe. Six pages deep is considered practically irreversible. This is what people mean by “waiting for confirmations.”

So no, sending Bitcoin is not instant. It could take 10 minutes if the network is quiet and your fee is reasonable. It could take an hour if the network is congested. It could take even longer if you set your fee too low and miners keep picking better-paying transactions first. The speed depends on network demand and how much you’re willing to pay.

Why this prevents cheating: If you wanted to write a fake page, you’d need to solve the puzzle faster than all the honest miners combined. You’d need more computing power than the rest of the entire network. This is called a 51% attack, and it’s absurdly expensive, often billions of dollars worth of hardware and electricity.

The tradeoff: All that guessing consumes enormous amounts of energy. Bitcoin’s network uses as much electricity as medium-sized countries like Poland or Argentina. This is a real and valid criticism.

Proof of Stake (PoS): Earn the Right Through Skin in the Game

This is the newer approach, used by Ethereum (which switched from PoW to PoS in September 2022, reducing its energy consumption by over 99.9%).

Same town. Same problem. But a different rule. Instead of burning energy on puzzles, you put up your own money.

“I’ll stake a significant amount of my coins as a guarantee. Let me write the next page. If I include anything fraudulent, burn my coins.” (On Ethereum specifically, the minimum is 32 ETH.)

The network picks validators based on how much they’ve staked. If you’re chosen and you do honest work, you earn a small reward. If you try to cheat, your staked coins get slashed, destroyed permanently.

Why this prevents cheating: You’d be destroying your own wealth. The more coins you stake, the more influence you have, but also the more you have to lose. Cheating becomes financially self-destructive.

The tradeoff: Critics point out that this favors the wealthy. More coins means more influence. The rich get richer. It’s a legitimate concern.

Both approaches, puzzle or collateral, achieve the same goal: a way for strangers to agree on the next page without needing a leader. They differ in cost. But they both work. And now, with consensus solved, every piece of the system is in place.

3.6 Step Back: Look at What You’ve Built

Let’s pause and take stock. Remember the problems with the bank from Part 1?

The Bank’s Problem	What Replaced It
Single point of failure (servers go down)	10,000 copies of the notebook across the world. No single computer matters.
Censorship (government freezes your account)	No single party can stop you from writing a transaction, though in practice some validators may choose to filter certain transactions.
Exclusion (1.3 billion people have no bank account)	Anyone with an internet connection and a device can participate. No application, no paperwork, no permission needed, though access to internet and devices remains a barrier for many.
Rent-seeking (fees for updating a database)	The network charges small fees, but no corporation is skimming profit.
Opacity (you can’t see what the bank does)	Every transaction, every page, every fingerprint is public and verifiable.

You don’t need to trust any single participant. You don’t need to trust the person who wrote the last page. You don’t need to trust the miner or the validator.

You trust the math. The fingerprints. The signatures. The consensus rules. The system works because cheating is harder than cooperating.

That’s a blockchain. Not a buzzword. A shared notebook, maintained by thousands, chained together with math, where nobody can rewrite the past and nobody is in charge.

And in 2009, Satoshi Nakamoto launched Bitcoin, proving that this system actually works in the real world. People could send value to each other across the planet, without a bank, without permission, without ever meeting. In practice, people routinely send six- or seven-figure sums across borders in minutes for fees under $5. Try doing that through a bank on a Sunday afternoon.

But it could only do one thing: track who sent coins to whom. What if you wanted the notebook to do more?

Part 4: Smart Contracts

4.1 The Notebook Can Track Coins. But What About Deals?

Your notebook works beautifully for sending coins. Alice sends 10 to Bob. Bob sends 5 to Charlie. Every transaction is signed, verified, and locked into the chain.

But now Alice and Bob want to do something more complicated.

Alice wants to buy Bob’s car for 100 coins. The problem is, they don’t trust each other. Alice doesn’t want to send the coins first, because what if Bob never hands over the title? Bob doesn’t want to hand over the title first, because what if Alice never pays?

In the old world, you’d solve this by hiring a middleman. An escrow agent. A lawyer. Someone both sides trust to hold the money until the deal is done.

But we built this entire system to get rid of middlemen. Are we really going to bring one back every time a deal gets complicated?

4.2 What If the Notebook Could Enforce Deals By Itself?

Here’s the idea. What if you could write a set of rules directly into the notebook, and the notebook would execute them automatically?

Not a person. Not a judge. Not a lawyer. The notebook itself.

Rule written into the notebook:

When Alice deposits 100 coins AND Bob deposits the car title:
    → swap them. Alice gets the title. Bob gets the coins.

If 30 days pass and either side hasn't deposited:
    → return everything to its original owner.

Nobody needs to “run” this. Nobody needs to approve it. The moment both conditions are met, the notebook executes the swap. If the deadline passes, the notebook executes the refund. Automatically. Every copy of the notebook, on every computer in the network, reaches the same result.

This is called a smart contract. The name is misleading. It’s not “smart” (it just follows instructions). And it’s not a “contract” in the legal sense (no court enforces it). It’s just code that lives on the blockchain and runs itself when conditions are met.

Why is this powerful? Think about what just happened:

Nobody can interfere. Once the rules are written and deployed, no person can change them. Not Alice, not Bob, not a government, not even the person who wrote the code. (In practice, some contracts are designed with admin keys or upgrade mechanisms, so always read the code or audit report before trusting a contract with your money.)
Everyone can verify. The code is public. Alice can read it before depositing her coins. Bob can read it before depositing his title. No fine print. No hidden clauses.
Every notebook agrees. Because the code is deterministic (same input always produces the same output), all 10,000 notebooks execute it identically. There’s no dispute about what happened.
No human bottleneck. It runs at 3 AM on a Sunday. It doesn’t take holidays. It doesn’t have “processing times.”

4.3 From Calculator to Computer

There’s a catch. Bitcoin’s notebook wasn’t designed for this.

Bitcoin’s notebook was designed for one job: moving coins. It has a very limited scripting language, but nothing close to general-purpose programming. It’s a calculator. Brilliant at one thing, but only that one thing.

In 2015, Ethereum launched, co-founded by Vitalik Buterin, who had proposed it two years earlier. What if the notebook wasn’t just a ledger, but a full computer? What if anyone could write a program, deploy it to the notebook, and have it run on every machine in the network?

Bitcoin = a notebook with one column (who sent coins to whom). Ethereum = a notebook with a programming language built into it.

Ethereum introduced the Ethereum Virtual Machine (EVM), the engine that runs smart contract code on every node simultaneously. And it introduced Solidity, a programming language designed specifically for writing these contracts.

Suddenly, the notebook could do anything. Escrow. Voting. Lending. Insurance. Games. Anything you could express as a set of rules, you could deploy to the blockchain.

4.4 But Running Code on 10,000 Computers Isn’t Free

There’s a problem you might have already spotted.

If anyone can deploy code to the notebook, and every computer in the network has to run it, what stops someone from writing a program that says “repeat this forever”?

One bad program and 10,000 computers freeze. The whole network grinds to a halt.

The solution: every instruction costs money. In Ethereum, this cost is called gas, and you pay it in ETH (Ethereum’s native currency).

Sending coins to someone:     ~21,000 gas
Deploying a smart contract:   ~500,000+ gas
Complex contract interaction:  varies widely

Think of gas like postage. The more complex your letter (your code), the more stamps (gas) you need. An infinite loop? It just keeps burning gas until the sender runs out of money, and then it stops. Problem solved.

But gas has a downside. The price fluctuates with demand. When the network is busy, everyone is bidding for space in the next page, and gas prices spike. During peak times, a simple transaction can cost $50 or more. This is one of the biggest usability problems in Web3, and a major reason why Layer 2 solutions exist.

Part 5: Stepping Back

5.1 Here’s What You’ve Built

Let’s take stock. You started with a simple question: can two strangers agree on the truth without a middleman?

To answer it, you built three tools. Hash functions to catch tampering. Public-key cryptography to prove identity. Peer-to-peer networks to remove the single point of failure. You combined them into a blockchain, a shared notebook chained together with fingerprints, where nobody can rewrite the past. Then you made it programmable with smart contracts, code that executes itself when conditions are met.

That’s Web3. Not a marketing term. A system where you can read, write, and own things on the internet without trusting a middleman to hold the keys.

From this foundation, an entire ecosystem has grown. Wallets, tokens, decentralized apps, lending protocols, community-governed organizations. It’s not fast (every transaction gets verified by every notebook in the network), and Layer 2 solutions exist to help with speed, but the tradeoff between decentralization, security, and scalability is still unsolved. The building blocks, though, are real.

5.2 Does Everyone Need a Blockchain?

No. Most things don’t.

If Alice runs one coffee shop and wants a loyalty program, a database on her laptop works fine. It’s faster, cheaper, and simpler. But if 50 independent shops want to share a loyalty program and none of them trust each other to keep the records? Now you have a problem a blockchain actually solves.

The question isn’t “should I use Web3?” It’s “is trust the bottleneck?” If it is, this technology matters. If it isn’t, a regular database is almost always better. Web3 will coexist with Web2, not replace it.

A few things worth getting straight while we’re here.

Blockchain isn’t anonymous. Every transaction is public and permanent. Your wallet doesn’t have your name on it, but if anyone links your address to your identity, they can trace your entire history. It’s pseudonymous, not anonymous.

And crypto isn’t just speculation. There’s plenty of that. But underneath the noise, the technology enables real things: remittances without 10% fees, artists selling directly to collectors, publishing on platforms that can’t be shut down. Separate the technology from the hype.

5.3 Every Superpower Has a Price

No middleman means no customer support. Full transparency means your transactions are public. Immutable history means smart contract bugs can’t be patched. Permissionless access means scammers get in too. Self-custody means lose your key, lose everything.

What You Gain	What It Costs You
No middleman	No customer support
Censorship resistance	Harmful content is also hard to remove
Full transparency	All your transactions are public
Immutable history	Bugs in smart contracts can’t be easily patched
Permissionless access	Scams and rug pulls are easier to pull off
Self-custody of assets	Lose your key, lose everything

Part 6: Glossary

If you need to look up a term, here’s every concept from this document in one place. The definitions use the language from the story where possible.

Term	Plain English Definition
Blockchain	The shared notebook, maintained by thousands of computers, where nobody can rewrite the past
Block	A single page in the notebook, containing a batch of transactions
Node	One of the computers keeping a copy of the notebook
Miner/Validator	A node that earns the right to write the next page (through puzzles or staking)
Wallet	Your key pair (private + public) that acts as your identity and bank account in Web3
Private Key	Your secret pen. Proves ownership. Never share it.
Public Key	Your magnifying glass. Anyone can use it to verify your signatures.
Mempool	The waiting room on every node where transactions sit until a miner/validator includes them in a page
Gas	Postage for the notebook. The fee you pay to run code on the blockchain.
Smart Contract	Rules written into the notebook that execute automatically when conditions are met
dApp	An application built on top of smart contracts instead of a company’s server
Token	A unit of value created by a smart contract (like Alice’s coffee loyalty points)
Layer 2	A side notebook that bundles transactions and settles them on Layer 1, for speed and lower cost
Consensus	The process by which all notebooks agree on which page to add next
Staking	Locking up your own coins as collateral to earn the right to validate pages
Slashing	The penalty for cheating as a validator: your staked coins get destroyed
EVM	Ethereum Virtual Machine, the engine that runs smart contract code on every node
Solidity	The programming language used to write smart contracts on Ethereum

A Quick Safety Note

Before you start experimenting: your wallet is backed by a seed phrase (12 or 24 words). Write it on paper, store it safely, and never type it into a website or store it digitally. If someone gets your seed phrase, they own your wallet. There is no recovery. For larger amounts, use a hardware wallet like Ledger or Trezor.

Most crypto losses come from phishing (fake sites, fake support emails) and token approval scams (malicious dApps that drain your wallet after you grant access). Bookmark real sites, never click links from messages, and regularly revoke old approvals at revoke.cash. Also know that crypto regulations and tax rules vary by country, and in many places every swap or sale is a taxable event. Check the rules where you live before using real money.

Part 7: Where to Go From Here

You don’t need to understand everything perfectly. What matters is the mental framework. When someone says “blockchain,” you think of a shared notebook, chained with fingerprints, maintained by thousands of computers, where nobody can rewrite the past. That’s the foundation.

If you want to keep going:

Install MetaMask and create a wallet. Don’t put real money in. Just see what a wallet address looks like and what it feels like to hold your own keys. (A note: MetaMask routes transactions through Infura by default, which can link your IP to your wallet activity. If privacy matters, consider changing the default RPC endpoint.)
Play on a testnet. Ethereum’s Sepolia testnet gives you free test ETH. Deploy a contract, send tokens, break things. Nothing is at risk.
Read a real smart contract. Browse etherscan.io, find a verified contract, and try reading the Solidity code. You won’t understand all of it, and that’s fine. Notice how the logic maps to what you’ve learned.
Learn to build. CryptoZombies teaches Solidity through a game. It’s free and surprisingly fun.
Read the original Bitcoin whitepaper. It’s only 9 pages. Search for “Bitcoin: A Peer-to-Peer Electronic Cash System” by Satoshi Nakamoto. After this guide, you’ll understand most of it.
Watch 3Blue1Brown’s “But how does Bitcoin actually work?” on YouTube. It covers similar ground with excellent visual explanations.

“The first principle is that you must not fool yourself, and you are the easiest person to fool.” - Richard Feynman

Web3 is neither a utopia nor a scam. It’s a set of tools, built on cryptography and distributed systems, that solve specific problems in specific contexts. There’s real innovation here. There’s also real hype, real risk, and real scams.

Now you have the foundation to tell the difference. Don’t trust the hype. Don’t trust the fear. Understand the tools, understand the tradeoffs, and judge for yourself.

AI was involved in writing this blog. If anything seems off, feel free to let me know.