Good morning.
I’m Mitsui, a web3 researcher.
Every Saturday and Sunday afternoon, we’ll deliver articles explaining basic vocabulary. We aim to keep each article concise enough for a quick read, while also making them suitable for revisiting and studying.
Today’s topic is “Block Time”
Please watch until the very end!
Introduction
One of the first things people learn about blockchain is that “Bitcoin’s block time is approximately 10 minutes, Ethereum’s is approximately 12 seconds.” Newcomers naturally wonder: “Why not simply make it faster?” and “Why these specific numbers?”
However, block time is far more than just numbers. It embodies fundamental tradeoffs that distributed networks face—a profoundly strategic design decision. Block time represents the line drawn between transaction speed and network robustness. It is the value chosen between decentralization and security.
Many think naively that “faster is better,” but this very thinking demonstrates a failure to grasp blockchain’s design philosophy. This article delves deeply into block time’s true meaning, examining why protocol designers have chosen such “slow” values. Through this understanding, the essence of blockchain becomes visible.
The Precise Definition of Block Time and Common Misconceptions
Block time is defined as “the average interval at which new blocks are generated.” Bitcoin: approximately 10 minutes. Ethereum: approximately 12 seconds. While the definition is straightforward, many people misunderstand it.
Here, caution is necessary. Block time does not mean “transaction processing time.” Many beginners mistakenly believe “Ethereum completes transactions in 12 seconds.” This is a serious error. For a transaction to be truly considered complete, the block containing it must become finalized, which requires multiple blocks to accumulate.
Block time is simply a metric indicating how frequently blocks are generated—the physical timing of “how far apart blocks appear on average.”
For example, suppose you sent a transaction to Ethereum one minute ago. That transaction might be “included in mempool” after approximately 12 seconds (the next block). But this only means the transaction is “visible”—not yet “complete.” Reaching a stage truly considered “complete” requires additional blocks to accumulate.
Comparing “Time” in Everyday Systems
To understand this distinction, consider everyday financial systems. When you swipe a credit card at a department store and the machine displays “approved,” the customer feels the payment is “complete.” However, the card company has not fully confirmed the transaction at this point. Confirmation may occur in batch processing days later. The possibility exists that one week later, the transaction could be disputed as fraudulent.
Similarly, when a bank transfer displays “transfer complete,” funds do not immediately reflect in the recipient’s account. Even domestic transfers typically require the next business day. International transfers take days as standard. Critically, “seeing it happen immediately” and “having it truly finalized” are temporally and procedurally distinct.
In blockchain, similarly, transactions being “visible” and transactions “finalizing” have temporal distance between them. A transaction entering mempool and being included in the next block represents the “visible” stage. Actually reaching a “finalized” stage requires many more blocks to accumulate. This time gap is crucial to understanding block time’s significance.
Why Blocks Must Be Generated at Regular Intervals ― Physical Constraints and Consensus
Why must blocks be generated at regular intervals? The answer lies in fundamental physical constraints of distributed networks.
If multiple nodes simultaneously created blocks, conflict would arise over which block is legitimate. One network node might claim “this block is legitimate,” while another insists “no, this different block is legitimate.” Resolving such contradiction is extraordinarily difficult.
Additionally, propagating blocks across the entire network requires physical time. If a node in Tokyo generates a block, this block information must propagate via network to all worldwide nodes. A node in New York might take several hundred milliseconds to receive this information. A node in Singapore receives it somewhat faster, while an Australian node might take longer.
If blocks were generated at extremely short intervals—say, one second—nodes could not keep pace with information propagation across the network. New blocks would continuously appear while not all nodes know about them. Multiple “legitimate blocks” would coexist, dramatically increasing blockchain fork probability. This situation, called “forking,” destroys the blockchain’s unity.
Establishing regular intervals mitigates such problems. Ethereum’s 12 seconds, for instance, provides nodes a 12-second window between block generation intervals. This timeframe allows information to propagate worldwide.
