Two ways to count money
Imagine two friends, each tracking their money differently. Cash Carla keeps physical bills in her pocket; to pay, she hands over whole notes and waits for change. Bank-app Ben just watches a single number on his phone that goes up and down. Both always know exactly how much they have — they just *represent* it differently.
Every blockchain faces the same choice. A transaction has to update who owns what, and there are two famous designs for the underlying bookkeeping. Bitcoin thinks like Cash Carla: the UTXO model. Ethereum thinks like Bank-app Ben: the account model. Neither is "more correct" — each trades simplicity against flexibility.
The UTXO model: spending bills and getting change
UTXO stands for Unspent Transaction Output — a fancy name for "a bill you haven't spent yet." In the UTXO model, your wallet doesn't hold a balance at all. It holds a pile of these bills, each one a discrete chunk of coin locked to your key. Your "balance" is just the sum of all your unspent bills, the way Carla's wealth is the sum of the notes in her pocket.
When you pay, you can't break a bill in half. You must consume whole UTXOs as inputs, then create new UTXOs as outputs — one to the person you're paying, and one paying change back to yourself, just as Carla hands over a $20 note for a $14 coffee and pockets the $6 in change. The consumed bills are now "spent" forever; the new ones become the only valid bills going forward. If you don't have a single bill big enough, you simply gather several smaller ones together as inputs in the same transaction.
Alice wants to pay Bob 0.7 BTC.
Her wallet holds two bills:
INPUTS OUTPUTS
[ 0.5 BTC ] ---+----> [ 0.7 BTC ] -> Bob
[ 0.4 BTC ] ---+ [ 0.2 BTC ] -> Alice (change)
(0.5 + 0.4) - 0.7 = 0.2 left over
The two old bills are now spent.
Bob and Alice each hold one fresh bill.The account model: one running balance
The account model throws away the pile of bills and keeps a simple ledger: a giant table mapping each address to a single number. Paying someone is just subtract here, add there — exactly like a bank moving a figure between two accounts. There is no change to compute and no bills to gather, because nothing is ever broken into pieces. The whole world's balances live in one shared table that every full node keeps a copy of.
Ledger before: Alice: 0.9 Bob: 0.0 Alice pays Bob 0.7: Alice -> 0.9 - 0.7 = 0.2 Bob -> 0.0 + 0.7 = 0.7 Ledger after: Alice: 0.2 Bob: 0.7 Just two numbers changed. No bills, no change.
To stop someone replaying the same payment twice, each account also carries a nonce — a counter that ticks up by one with every transaction it sends. A digital signature locks the whole instruction to your key, and the nonce guarantees the network processes your payments in order, exactly once each.
Why pick one over the other?
Each style shines in different ways. The UTXO model is wonderfully parallel and private: because every bill is independent, many transactions can be checked at once, and you can spread coins across fresh addresses so onlookers struggle to link them. It also makes a transaction's validity easy to verify in isolation — just confirm the input bills exist and haven't been spent.
The account model is wonderfully simple and expressive. One address, one balance, easy for humans to reason about. More importantly, a single persistent number is the perfect home for a smart contract: programs that hold funds and remember state need a stable place to store it, which is exactly why Ethereum chose accounts. That choice is what makes rich on-chain apps natural to build.
The takeaway
Both models answer the same question — *who owns how much?* — and both are tamper-proof once recorded. They differ only in how they represent value: a wallet full of discrete, single-use bills, or one ever-updating number. Knowing which model a chain uses tells you a lot about how it thinks: Carla's cash favors privacy and parallel checking, Ben's bank app favors simplicity and smart contracts.
Next, we'll see how the network *agrees* on these transactions in the first place — how thousands of strangers settle on one shared history without a referee. That is the job of a consensus mechanism.