UTXO vs Account Models: Two Ways Blockchains Track Balances

Most people think of blockchain as a ledger, but how that ledger actually keeps score determines everything from privacy to scalability to what applications can be built on top.

SAGE: Edge, thanks for joining. Let's start with something basic that most people never think about. When I send you one Bitcoin, what actually happens under the hood? Because I think most people imagine it like Venmo—my balance goes down, yours goes up. But that's not how Bitcoin works at all, is it?

EDGE: No, and that's the beautiful part. Bitcoin doesn't have balances in the traditional sense. Instead, it tracks unspent transaction outputs, or UTXOs. Think of it like physical cash. If you have a twenty dollar bill and you want to buy something for twelve dollars, you hand over the twenty, and you get eight dollars back in change. Bitcoin works the same way. When you receive Bitcoin, you're really receiving an output from a previous transaction—a discrete chunk of bitcoin that you can spend. When you want to send bitcoin, you're taking one or more of these unspent outputs, using them as inputs to a new transaction, and creating new outputs. One output goes to the recipient, and if you're sending less than the total input, one output comes back to you as change.

SAGE: So there's no running tally. No account that says "Sage has 2.5 Bitcoin." Instead, the network is tracking individual pieces—like actual coins or bills—and my wallet software just adds them up to show me what I control.

EDGE: Exactly. Your wallet is doing that calculation every time you open it. It scans the blockchain for all UTXOs that you can unlock with your private keys, and it sums them. But from the blockchain's perspective, those are distinct, separate objects. Each UTXO can only be spent once, and when you spend it, it's consumed entirely. You can't spend half a UTXO. You spend the whole thing and create new outputs.

SAGE: And that has pretty profound implications for privacy, right? Because every UTXO has a history. It came from somewhere. And when I spend multiple UTXOs in one transaction, I'm potentially revealing that all those pieces are controlled by the same person.

EDGE: That's the tradeoff. The UTXO model does give you some natural privacy boundaries. Each UTXO is separate, and you could maintain separate clusters of UTXOs that aren't obviously linked. But you're right that when you combine UTXOs as inputs to a transaction, you're creating a data point that suggests common ownership. This is why chain analysis works. People look at transaction patterns, see which UTXOs are being spent together, and build graphs of likely ownership. On the flip side, this structure makes certain privacy techniques possible. CoinJoin, for example, works by having multiple users create a single transaction with many inputs and many outputs, so it's unclear who paid whom. That works because UTXOs are discrete objects that can be mixed together.

SAGE: Now let's pivot to Ethereum, because it took a completely different approach. Ethereum uses an account model, which sounds more like that Venmo analogy. What does that actually mean architecturally?

EDGE: Ethereum maintains explicit accounts with balances, like a bank. There are two types: externally owned accounts, which are controlled by private keys like a Bitcoin address, and contract accounts, which are controlled by code. Every account has a balance, a nonce that tracks how many transactions it's sent, and if it's a contract account, it has storage and code. When you send Ether from your account to mine, the network simply subtracts from your balance and adds to mine. There's no concept of unspent outputs or change. The state of the blockchain is literally a map of all accounts and their current balances.

SAGE: That sounds simpler. Why didn't Bitcoin do it that way? Or maybe the better question is, what did Ethereum gain by choosing the account model, and what did they give up?

EDGE: The account model makes smart contracts much more natural. If you're building a complex application—say, a decentralized exchange or a lending protocol—you need persistent state. You need the contract to remember things: who deposited what, what the current interest rate is, what the exchange rate pool looks like. In the account model, every contract has storage that persists between transactions. The contract's state is right there in the blockchain state tree. In a UTXO model, you'd have to encode state into the outputs themselves, which gets complicated fast. You can do it—projects like Cardano have built smart contract systems on UTXO models—but it requires a different mental model. The tradeoff is that the account model creates a more stateful system overall. The entire Ethereum blockchain state is this ever-growing tree of accounts and their data. That has scalability implications.

SAGE: Talk about that. Because I know one criticism of the account model is that it makes certain kinds of parallelization harder. Every transaction potentially touches the global state in ways that matter to other transactions.

EDGE: Right. In Bitcoin's UTXO model, transactions are more independent. If I'm spending UTXOs that you're not spending, our transactions don't conflict. They can be validated in parallel. The validator just needs to check that each UTXO being spent exists and hasn't been spent before. In Ethereum's account model, transactions touch accounts, and the order matters. If two transactions both interact with the same account—say, they're both trying to spend from it or modify the same contract state—you need to process them sequentially to get the right result. The nonce helps enforce ordering from a single account, but it also means you can't trivially parallelize transaction processing. This is one reason Ethereum has explored sharding and now focuses on rollups for scaling. You need architectural complexity to work around the inherent serialization.

SAGE: So UTXO gives you better parallelization and arguably better privacy primitives, but it makes stateful computation awkward. Accounts make smart contracts natural but create scaling bottlenecks and less obvious privacy boundaries. Is it fair to say each model is optimized for different purposes?

EDGE: I think that's exactly right. Bitcoin's UTXO model reflects its original purpose as peer-to-peer electronic cash. You're passing around discrete units of value, and the system is optimized for validating that those units exist and haven't been double-spent. It's elegant for that use case. Ethereum's account model reflects its ambition as a world computer. You're maintaining state machines, executing code, and building applications. The account model is a more natural fit for that. Neither is universally better. They're different tools. And we're seeing this play out in the ecosystem. Projects building on Bitcoin are developing UTXO-based smart contract models like RGB that keep most computation off-chain and use UTXOs as commitments. Meanwhile, Ethereum and its layer twos are building entire infrastructures around managing account-based state at scale.

SAGE: Last question. For someone trying to understand crypto more deeply, why does this distinction matter? What does it tell us about how these systems work and where they're headed?

EDGE: It matters because the ledger model is foundational. It determines what's easy and what's hard, what's efficient and what's expensive. It shapes the developer experience and the user experience in subtle ways. Understanding UTXO versus account models helps you see why Bitcoin and Ethereum evolved such different ecosystems. It also helps you evaluate new projects. When someone says they're building a new blockchain, asking whether they use UTXO or account model immediately tells you something about their design priorities and the tradeoffs they're accepting. More broadly, it's a reminder that in this space, there are no free lunches. Every architectural choice is a tradeoff. The question is always, what are you optimizing for? And does that align with what you're trying to build?

SAGE: Perfect place to leave it. Edge, thanks for walking through this. Really appreciate your time.

EDGE: Anytime. This was fun.

See you Thursday. The ledger doesn't just record history—its structure shapes what's possible.