You tap Send, watch a little spinner, and… nothing happens for a few minutes. Then the app says confirmed. What just went on in that gap? A surprising amount. Your payment didn’t teleport — it got packaged into a signed message, shouted across a global network, dropped into a crowded waiting room, and then bid against thousands of other payments for a seat on the next block. This lesson follows one transaction on that whole journey, and explains the thing everyone complains about and almost nobody understands: the fee.
What a Transaction Actually Is
In the previous lesson you learned that your private key is the secret that proves you control an address, and that signing with it produces a signature — a stamp only you could have made. A transaction is simply a short, signed message that says: “move this much value from this address to that address.” That’s it. It names a sender, a receiver, an amount, and it carries your signature as proof you’re allowed to move those funds.
The signature is the whole security model. Anyone on the network can read your transaction, but nobody can forge it, because only your private key produces a valid signature for your address. A transaction without a valid signature is just noise — every honest node throws it straight in the bin.
Before you read — take a guess
Guess before reading: after you tap “send” on a crypto payment, the transaction is…
The Journey: Send → Broadcast → Mempool → Block → Confirmed
A transaction goes through the same five stages every time. Here’s the whole trip in one table, and then we’ll walk it:
| Stage | What happens |
|---|---|
| 1. Create & sign | Your wallet builds the transaction and signs it with your private key |
| 2. Broadcast | The signed transaction is sent to the network’s nodes |
| 3. Mempool | It waits, unconfirmed, in the pool of pending transactions |
| 4. Block inclusion | A block producer selects it and packs it into a block |
| 5. Confirmation | The block is added to the chain — and each later block adds a confirmation |
Step 3 introduces the star of this lesson. The mempool (short for memory pool) is the waiting room of unconfirmed transactions. Every node on the network keeps its own copy: a big bag of broadcast-but-not-yet-included transactions, all jostling to get picked. Your transaction sits here, fully valid and fully visible, doing nothing, until a block producer reaches in and grabs it.
A block producer — a miner on a proof-of-work chain like Bitcoin, a validator on a proof-of-stake chain like Ethereum — is whoever gets to assemble the next block. They scoop transactions out of the mempool, bundle them into a block, and add that block to the chain. The moment your transaction lands in a block, it has one confirmation.
A confirmation is just a block stacked on top of the block that contains your transaction. One confirmation means your transaction is in the latest block. Six confirmations means five more blocks have been built on top of it. Why does that matter? Because to reverse your transaction, an attacker would have to rebuild your block and every block stacked on top of it faster than the rest of the network builds new ones. The deeper your transaction is buried, the more work that takes — so more confirmations = harder to reverse = safer.
“Transactions are instant” — nope
Broadcasting is near-instant, but confirmation isn’t. Your wallet showing the payment just means it sent the transaction into the mempool — it hasn’t been included yet, let alone buried under enough blocks to be safe. Treating an unconfirmed transaction as “done” is exactly how people get burned. Fast to send ≠ fast to finalize.
Sort each event into the stage of a transaction's life where it belongs.
Place each item in the right group.
- The transaction is fully built but not yet sent to any node
- More blocks stack on top, adding confirmations
- The transaction sits unconfirmed, waiting to be picked
- It competes against other pending transactions for inclusion
- Your wallet signs the transaction with your private key
- A block producer selects it and packs it into a block
Block Space Is Scarce
Here’s the constraint that makes everything else click: a block holds a limited amount of transactions. It’s not an infinite bucket. Each block has a hard cap on how much it can carry, and blocks only arrive every so often (roughly every ten minutes on Bitcoin, every twelve seconds on Ethereum). So in any given stretch of time, only so many transactions can possibly confirm.
If more people want to transact than there are seats on the next few blocks, those transactions have to compete. Block space is a scarce resource, and — as with any scarce resource — there has to be some way to decide who gets it. That mechanism is the fee.
Bigger blocks mean every node has to store and verify more data, which makes running a node more expensive — and fewer, beefier nodes means a more centralized, less censorship- resistant network. So chains deliberately keep block space tight. The scarcity isn’t a bug; it’s a design choice that protects decentralization. The cost of that choice is that transactions have to bid for the limited room.
Fees: An Auction for the Seats
Every transaction can attach a fee — a little extra value, on top of the amount you’re sending, that goes to whoever produces the block. And here’s the key behavior: block producers are economically rational, so they fill their scarce slots with the highest-fee transactions first. A bigger fee makes your transaction more attractive, so it gets picked sooner. A small fee means you wait. A fee that’s too low can leave you waiting a very long time — sometimes forever.
That’s all the mempool really is: a continuous auction for block space. You’re not paying a fixed price; you’re bidding against everyone else who wants into the next block. Bid high and you jump the queue; bid low and higher bidders fill the block ahead of you.
Try it yourself below. Drag your fee up and down, then hit produce next block and watch whether your transaction grabs one of the limited slots or gets left behind in the mempool. Notice that there’s no magic “correct” fee — it depends entirely on what everyone else is bidding for the same seats.
Next block (limited space)
Mempool (waiting to confirm)
A block has limited space, so producers grab the highest-fee transactions first. Bid a higher fee and you confirm sooner; bid too low and higher bidders fill the block ahead of you.
Your transaction has been stuck in the mempool for an hour. The most likely reason is:
Why Fees Exist at All
Fees aren’t a cash grab — they do two essential jobs.
They pay the block producers. Assembling blocks, verifying signatures, and securing the chain costs real resources: electricity for miners, staked capital for validators. Fees compensate them for that work and for handing over a slice of their scarce block space. Without a reward, nobody would bother producing blocks, and the network would grind to a halt.
They prevent spam. If transactions were free, a troll could flood the network with millions of junk transactions and clog the mempool for everyone, essentially for free. Attaching a real cost to every transaction makes that attack expensive instead of free — the fee is the network’s spam filter as much as it is its paycheck.
Where the fee goes — and where it doesn't
The fee does not go to the receiver, and it does not vanish into “the blockchain” as some abstract toll. It goes to the block producer who includes your transaction — the miner or validator who did the work. You’re tipping the person who packs your transaction into a block, not the person you’re paying. (A “zero fee” transaction, by the way, gives producers no reason to pick you — it may sit in the mempool forever.)
Connect every term on the left to its correct meaning.
Pick a term, then click its definition.
Gas: When the Fee Depends on the Work
On simple payment chains, a transaction is a transaction — one transfer, one rough size. But on chains like Ethereum that run smart contracts (small programs that live on the chain), transactions can do wildly different amounts of work. Sending coins to a friend is trivial. Swapping tokens on a decentralized exchange might trigger dozens of computational steps. It would be unfair — and easy to abuse — to charge both the same.
So these chains meter the computation a transaction requires, and call that unit gas. Think of gas like fuel: a short errand burns a little, a cross-country haul burns a lot. Your total fee is roughly how much gas the transaction needs multiplied by a per-unit price you’re willing to bid for that gas. A plain transfer needs little gas and stays cheap; a heavy smart-contract call needs a lot and costs more. Same auction idea as before — you’re just bidding per unit of work instead of per transaction.
Pick the right word for each blank.
Pick the right option for each blank, then check.
A transaction waits in the until a block includes it. The fee is paid to that , and a higher fee usually means a confirmation. On smart-contract chains, the work a transaction needs is metered as .
Fee Volatility: Why the Price Keeps Moving
Because fees are set by an auction, they swing with demand. When the network is congested — a hot token launch, a market crash, everyone trying to transact at once — the mempool overflows with pending transactions all bidding for the same handful of slots. The going rate to get included spikes, sometimes dramatically. When things are quiet and the mempool is nearly empty, there’s barely anyone to outbid, so fees fall to a trickle.
This is why the exact same transfer can cost cents at 3am on a calm Tuesday and a small fortune during a frenzy. Nothing about your transaction changed — the competition did. Wallets estimate a fee for you by peeking at the current mempool, which is why they suggest a higher number when things are busy and a lower one when they’re not.
The network suddenly gets very congested (the mempool fills with pending transactions). To get included in the next block, you'll generally need to:
Putting It Together
One transaction, five stages, one auction. Chunk the whole journey into a single picture:
Big picture
From send to confirmed
- A crypto transaction
- The journey
- Create & sign with your private key
- Broadcast to the network
- Wait in the mempool (unconfirmed)
- Block producer includes it
- Confirmations stack up
- The fee auction
- Block space is scarce
- Higher fee → picked sooner
- Too low → may never confirm
- Why fees exist
- Pay the block producer
- Prevent spam
- Gas = price of computation
- Volatile: rises with congestion
- The journey
A mixed recap — it pulls from everything above:
What is the mempool?
Check your answer to continue.
Key Takeaways
What to remember
- A transaction is a signed message that moves value from one address to another, authorized by your private-key signature. No valid signature, no transaction.
- The journey is five stages: create & sign → broadcast → wait in the mempool (the pool of unconfirmed transactions) → a block producer includes it → confirmations stack as later blocks pile on. More confirmations = harder to reverse = safer.
- Block space is scarce, so transactions compete. The fee is your bid in that auction: higher fee = picked sooner, too-low fee = you wait, maybe forever.
- Fees pay the block producer (not the receiver, not “the blockchain”) and deter spam. On smart-contract chains, gas meters computation, so complex transactions cost more than simple transfers.
- Fees are volatile: congestion drives the going rate up, quiet periods drive it down. Same transfer, different day, very different price — because the competition changed.
Next up, the last piece of crypto’s structural foundation: UTXO vs. account — the two ways chains keep score. Bitcoin and Ethereum literally track balances using completely different bookkeeping models, and understanding both is what finally makes “where do my coins actually live?” click.