When I first started learning about Ethereum, I kept hearing the word “transaction” thrown around. Whether it was someone swapping tokens, minting an NFT, or bridging to a Layer 2. It seemed simple on the surface, but I quickly realized, there's a whole lot happening under the hood.

This post is a breakdown of exactly what happens when you send a transaction on Ethereum. From your wallet, all the way to the blockchain. Whether you're new to the space or just want to understand it more clearly, here's how I see it.

Step 1: You Create and Sign the Transaction

Everything starts locally, right in your wallet. MetaMask, Coinbase Wallet, or something built into a dApp. You're basically saying:

“I want to send X ETH (or tokens)”
“To this wallet or contract”
“And I’ll pay this much gas to get it processed”

Behind the scenes, your wallet fills in a few more details:

To address (recipient or smart contract)
Value (how much ETH you’re sending)
Data (for contract interactions like swaps or mints)
Gas limit + priority fees
Nonce (your wallet’s unique transaction count)

Then you sign it with your private key. That signature says, “I’m the one sending this, and I’ve got the authority.”

Step 2: The Transaction Gets Broadcast

Once it’s signed, the transaction gets fired off to the Ethereum network. This is a peer-to-peer network, so it spreads out to thousands of nodes.

Each node has something called a mempool (short for Memory Pool), which is like a public waiting room for pending transactions. Your transaction hangs out there until a validator (formerly known as a miner) picks it up.

Step 3: It Spreads Across the Network (Propagation)

At this point, your transaction is basically getting passed around the network. Other nodes see it, verify it’s valid (you signed it, you have the funds, etc.), and add it to their own mempool lists.

This whole process takes seconds—but it’s one of the reasons Ethereum is so resilient. There’s no single server in charge; it’s just code running on thousands of independent nodes.

Step 4: A Validator Adds It to a Block

Now the magic happens.

Ethereum runs on Proof of Stake. A validator is selected to create the next block. They scan the mempool and usually grab the transactions with the highest fees first (because that’s how they get paid).

If your gas fee is reasonable and the block isn’t too full, your transaction gets included. It’s now officially part of a new block on Ethereum.

Step 5: The EVM Executes the Transaction

Once your transaction is inside a block, the Ethereum Virtual Machine (EVM) takes over.

The EVM is like Ethereum’s brain—it runs the logic and checks the math on every transaction:

Deducts gas up front (Gas price depends how much the transaction is worth, and/or fee’s differ on how much traffic is going through the network is at that moment)
Runs any smart contract code
Moves ETH or tokens
Updates balances, contract storage, etc.

If everything checks out, the transaction goes through. If it runs out of gas or hits an error (like trying to swap a token that doesn’t exist), it fails. But you still pay the gas.

Step 6: Ethereum’s State Updates

Assuming the transaction succeeds:

ETH or tokens move
Smart contracts update storage (maybe your NFT gets minted)
Events are logged (this is how explorers like Etherscan show what happened)
Gas is split between the validator and burned

This is when it becomes “real.” You can check your wallet and see the updated balance or NFT. It’s now part of Ethereum’s global state.

Step 7: Finality (It’s Locked In)

Even after it hits a block, Ethereum waits a few more blocks to consider the transaction finalized. Meaning it’s basically irreversible.

On Ethereum mainnet, that usually means:

1 confirmation: it’s confirmed
12+ confirmations: it’s final

Finality gives everyone (users, apps, bridges, etc.) confidence that your transaction won’t get rolled back due to a reorg.

Why It Matters,

Understanding this flow helped me move from just using Ethereum to thinking like a builder. Every transaction is more than a button click. It’s a handshake with the network, powered by cryptography, math, and thousands of independent nodes working together.

And in a world moving toward modular chains, rollups, and new Layer 2s, this flow stays foundational. The difference? Sometimes parts of it get outsourced or compressed (like calldata off-chain or finality via proofs), but the core logic stays the same. Let me know if you want me to break down how this changes on a rollup or Layer 2 next. The way they compress and batch these steps is super interesting. And totally reshaping Ethereum’s future.

Breaking It Down: What Happens in a Single Ethereum Transaction