How can blockchain technology be scaled?

Scaling a blockchain is not simply a matter of adding faster servers or making blocks larger. The real challenge is allowing a network to handle more transactions, more users and more data without quietly giving up the properties that made the blockchain useful in the first place.
That immediately creates trade-offs. A network may process more transactions if only a small number of powerful machines can operate its nodes. Another design may reduce transaction costs by moving work away from the base chain, but introduce a different security model. A third may remain extremely robust while accepting lower throughput.
So there is no single button marked “scale”. Some techniques improve the base blockchain itself, some move execution to another layer, some combine thousands of transactions into batches, and some simply avoid putting unnecessary data on the blockchain at all.
The sensible starting point is not a particular technology. It is a much simpler question: where is the bottleneck?
What exactly are we trying to scale?
Transactions per second is useful, but it tells only part of the story. A practical blockchain system also has to deal with transaction latency, finality, data volume, storage growth, node requirements and the number of participants that must communicate with one another.
A network, for example, might accept a large number of transaction requests but take much longer to finalise them. From an application point of view, those are two very different performance figures.
The hardware requirement matters as well. If throughput increases but running a node now requires expensive servers and unusually high network bandwidth, smaller participants may gradually disappear. Capacity has increased, but participation has become more difficult.
This is why it helps to understand how blockchain works before comparing headline speed figures. Transaction execution, consensus, data propagation and storage can each become the limiting factor.
Layer 1: changing the blockchain itself
Layer 1 is the base blockchain protocol. Bitcoin and Ethereum Mainnet are familiar examples. Layer-1 scaling means changing that base protocol so that it can handle its workload more efficiently.
One obvious idea is to fit more transactions into every block. That can increase capacity, but larger blocks also require more bandwidth, processing and storage. If the requirements become too demanding, fewer people may be able to operate fully validating nodes.
Producing blocks more frequently creates another trade-off. Shorter intervals may increase the rate at which transactions are included, but they also leave less time for information to propagate throughout the network. Depending on the blockchain design, that can increase competing blocks or place more pressure on networking and consensus.
Increasing one number does not necessarily scale the whole system. Sometimes it simply moves the bottleneck somewhere else.
Proof of Stake is not a magic throughput upgrade
Older explanations of blockchain scaling often make a shortcut that causes confusion: replace Proof of Work with Proof of Stake and the blockchain becomes scalable.
That mixes two related but different subjects.
Consensus determines how participants agree on the accepted state of the network and how that agreement is protected. Moving from Proof of Work to Proof of Stake can completely change energy use, validator economics and parts of the security model. It does not, by itself, determine how much transaction execution or data the network can support.
Ethereum illustrates the difference well. Its move to Proof of Stake drastically reduced the energy required by its consensus system, but Ethereum's present scaling strategy depends heavily on Layer-2 rollups and improvements that make rollup data cheaper and more abundant.
So when discussing blockchain's environmental impact, it is useful to keep energy efficiency and transaction scalability as separate questions.
Layer 2: stop asking the base chain to do everything
The idea behind many Layer-2 systems is surprisingly straightforward: the base blockchain does not need to execute every individual user action itself.
A large amount of activity can take place in another layer while the base chain is used for settlement, verification or dispute resolution. This reduces the amount of work that Layer 1 must perform for every user.
There is an important qualification, though. Moving activity “off-chain” does not automatically make two systems equivalent. What matters is how the result is connected back to the base chain and where the security guarantee comes from.
For Ethereum, the most important scaling family today is the rollup.
Rollups: thousands of transactions, one much smaller burden on Layer 1
A rollup executes transactions away from Ethereum Layer 1 and then submits information about those transactions back to Ethereum in batches.
Instead of asking the base chain to perform every calculation separately for every user, the rollup performs much of that work elsewhere. Layer 1 then receives the information or proof required by the rollup's security model.
This is where transaction batching becomes powerful. If thousands of individual transactions share some of the same overhead, grouping them allows that cost to be spread across many users.
The gain is not that the transactions somehow cease to exist. The architecture has changed where they are executed and how their correctness can be checked.
Optimistic rollups
An optimistic rollup initially treats submitted state changes as valid. A challenge mechanism allows incorrect results to be disputed during a defined period.
This design can provide substantial scaling, but the dispute model affects how withdrawals and final settlement are handled. In other words, high throughput does not eliminate timing considerations; it changes where they appear.
Zero-knowledge rollups
A ZK-rollup takes another route. Transactions are executed away from Layer 1 and a cryptographic validity proof is produced for the resulting state change.
The base chain does not need to reproduce every individual off-chain computation in order to determine that the submitted state transition satisfies the required rules. It can verify the proof instead.
This is a very different mechanism from an optimistic rollup, even though both are called rollups. The verification model matters at least as much as the throughput figure.
Why data availability became such a big issue
Moving computation elsewhere solves only part of the scaling problem.
Suppose a rollup tells Ethereum that thousands of transactions resulted in a new state. How can independent participants verify or reconstruct what happened if the underlying transaction information is unavailable?
This is the data availability problem.
For verification to remain meaningful, enough information must be available to independently check the state transition according to the system's rules. A summary alone is not useful if nobody can obtain the data needed to challenge or reconstruct it.
That is why modern Ethereum scaling is not only about performing calculations somewhere else. It is also about making rollup data available in a way that does not force every node to permanently carry an ever-growing amount of information.
Blobs changed the economics of rollup data
Ethereum now provides specialised temporary data space commonly referred to as blobs. They are designed primarily to give rollups a cheaper place to publish the data needed by their scaling model.
This matters because rollup costs are strongly influenced by the cost of making data available on Layer 1. If that data can be published more efficiently, a large part of the saving can flow through to Layer-2 users.
A blob is not simply “more storage added to Ethereum”. Its role is much more specific. The data has a limited availability period at the protocol level rather than becoming permanent execution-layer storage.
This also gives us an important distinction: data availability is not the same thing as permanent data retrievability. Information may have been available when required for verification without the base protocol promising to archive it forever.
The old Ethereum sharding explanation is now outdated
This is one of the places where blockchain articles age very quickly.
A few years ago Ethereum scaling was commonly described like this: the network will be split into many shards, and each shard will execute a different portion of the transactions.
That was an important part of the earlier roadmap. It is no longer the clearest description of where Ethereum is heading.
The rise of rollups changed the strategy. Instead of making separate execution shards the centre of scaling, Ethereum has moved toward a rollup-centric model in which the base layer increasingly provides security, consensus and large amounts of data capacity for Layer 2.
That is where Danksharding enters the picture. Its purpose is not simply to divide Ethereum applications among conventional execution shards. It is designed to dramatically expand the data capacity available to rollups.
So the word “sharding” still appears, but the modern architecture is not the old “many little Ethereum chains each processing their own transactions” picture.
Payment channels: use the blockchain when it is actually needed
Not every scaling system is a rollup.
Another idea is to let participants perform many interactions between themselves and involve the base blockchain mainly when opening, closing or settling the relationship.
Payment channels are a well-known example. Bitcoin's Lightning Network uses channels anchored to Bitcoin so that many payments can take place without each individual payment becoming a separate base-layer transaction.
Two participants can establish a channel, update the balance between them many times and later settle the appropriate state using Bitcoin. Networks of these channels also allow payments to be routed through other participants.
The advantage is obvious: the base blockchain does not have to record every small payment independently.
But channels introduce their own engineering concerns, including liquidity, routing, channel management and online availability. Taking activity away from Layer 1 does not make system design disappear. It gives us a different system to operate.
Sidechains are not the same thing as Layer 2
This distinction is often blurred in older explanations.
A sidechain is a separate blockchain running alongside another blockchain. It can use different block times, validator arrangements and consensus rules. Bridges can connect it to the main chain so that assets or information can move between them.
That may provide additional capacity, but there is an important price attached to the word “separate”.
A sidechain connected to Ethereum does not automatically inherit Ethereum's security. Its validators and consensus system are responsible for the security of that sidechain. If the sidechain's consensus fails, Ethereum's validators do not simply step in and correct it.
This is why “it runs outside Ethereum” does not automatically mean “it is Ethereum Layer 2”. Rollups derive important security properties from Layer 1; sidechains operate with their own security model.
A bridge connects networks; it does not create free capacity
Blockchain bridges allow different networks to exchange assets or information. They are important for interoperability, but describing a bridge itself as a scaling solution can be misleading.
A bridge may make it possible to move activity to another network, but the second network must still process that activity. Meanwhile, the bridge has to maintain a trustworthy relationship between two separate states.
If one chain says an asset has been locked while another says a corresponding asset can now be released or created, the mechanism carrying that message becomes security-critical.
Bridging can help distribute activity, but interoperability and scalability are not identical problems.
Sometimes the biggest saving comes from not writing the data on-chain
This becomes especially important when blockchain meets industrial automation.
A PLC scan is not a blockchain transaction. Neither is every vibration sample, encoder count, current reading or temperature value coming from an industrial machine.
If an application tries to turn every process measurement into an on-chain transaction, it may create its own scalability problem before production has even started.
Imagine a production line generating thousands of process values every second. Those values can remain in a historian, time-series database or data logging system. An edge computing layer can prepare selected records or data groups.
The blockchain can then record what genuinely needs shared verification: a production-batch identity, an approval, an important event, a custody change or the cryptographic hash of a larger data set.
In other words, one of the most effective ways to scale an industrial blockchain is not to send unnecessary industrial data to the blockchain in the first place.
Keep machine control and blockchain settlement in different time worlds
An inverter protecting a motor cannot wait for a public blockchain to settle a transaction. A safety PLC cannot postpone an emergency response until several network participants agree on a block.
Industrial control and shared record verification serve different timing requirements.
The PLC, drive, motion controller or safety system should carry out the immediate control function using the architecture designed for that response time. A relevant event can then be transferred to the record layer afterwards.
This distinction also matters when assessing blockchain's impact on industrial automation performance. A blockchain may be appropriate for recording the event without belonging inside the control loop that generated it.
Permissioned industrial networks have a different scaling problem
A public network with thousands of unrelated participants and a permissioned network shared by five manufacturers are not trying to solve exactly the same problem.
In a permissioned blockchain, participants may have known identities and the network may use a consensus arrangement designed for that environment. This can remove some of the overhead associated with an open network.
Even then, adding more nodes does not automatically add more throughput.
More organisations can mean more ledger copies, more network communication and more complicated approval policies. If a transaction requires signatures from several organisations, the slowest required approval may matter more than CPU performance.
Suppose five companies participate and three approvals are required for a particular record. Expanding the consortium to twenty companies does not automatically make that workflow faster. The policy, communication path and roles of those organisations become part of the scaling problem.
This is why scalability and flexibility in industrial automation cannot be reduced to a single transactions-per-second figure.
What should actually be measured?
Throughput is still important: how many valid transactions can the complete system process over a given period?
But measure latency and finality as well. How long does the normal transaction take, and how long do the slowest transactions take? When does an application consider the result sufficiently final to act on it?
Then look at the amount of data per transaction. Ten thousand tiny transfers and ten thousand transactions carrying substantial application data create very different workloads.
Also monitor the cost of operating a node. A network that becomes faster only by requiring increasingly specialised infrastructure may be moving toward a different participation model.
And do not test only on a quiet network.
Measure what happens when transactions arrive in bursts, a validator goes offline, network latency increases or a disconnected site reconnects and releases a backlog of records. Real scalability is often revealed by the way a system degrades and recovers, not by the highest number reached during a clean benchmark.
“Faster” and “better” are not synonyms
A blockchain can often be made faster by changing assumptions: larger blocks, fewer validators, stronger hardware, shorter confirmation rules or a separate execution network.
None of those decisions is automatically wrong. But each one has consequences.
This is the background to the familiar tension between scalability, security and decentralisation. It is better understood as a set of engineering trade-offs than as a law saying every blockchain receives a fixed score in three boxes.
Different applications will reasonably make different choices. A global permissionless financial network and a traceability network shared by a small industrial consortium do not require identical architectures.
When considering the limitations of blockchain, therefore, throughput should always be read together with the assumptions under which that throughput was obtained.
So what does blockchain scaling look like today?
Layer-1 improvements make the base protocol more efficient. Rollups execute large volumes of transactions elsewhere while using Layer 1 for important security and settlement functions. Payment and state channels allow repeated interactions to happen away from the base chain. Sidechains offer additional execution capacity under a separate consensus model. Batching and compression reduce duplicated overhead. Data-availability improvements make it possible for rollups to grow without requiring every Layer-1 node to permanently store and execute everything.
These approaches solve different parts of the problem. They are not interchangeable items on a checklist.
And in industrial applications there is one more layer of judgement: does this information need blockchain consensus at all?
A raw process waveform may belong in a historian. A machine alarm may belong in the plant event system. A safety action belongs in the safety architecture. A batch approval shared between independent companies may be a much better candidate for blockchain verification.
That separation often matters more than selecting the fashionable scaling technology of the year.
Scaling blockchain ultimately means dividing responsibility intelligently. Sometimes we improve the base chain. Sometimes thousands of transactions are represented by a much smaller proof or batch. Sometimes repeated interactions stay inside a channel. Sometimes heavy data remains off-chain and only its verification record is shared.
And sometimes the best scalability improvement is simply recognising that a piece of data never needed to be on a blockchain at all.
Technical sources used for this article
[1] Ethereum.org — Scaling: current Layer-1, Layer-2, rollup, state-channel, sidechain and rollup-centric scaling architecture.
[2] Ethereum.org — Data Availability: why rollups require access to transaction data and how data availability differs from permanent historical retrieval.
[3] Ethereum.org — Danksharding: blob data, Proto-Danksharding and Ethereum's rollup-oriented data-capacity roadmap.
[4] Ethereum.org — Sidechains: independent consensus, two-way bridges and the distinction between sidechains and Layer-2 security.
[5] Lightning Network technical documentation — Bitcoin payment channels and off-chain payment routing.
[6] NIST IR 8202 — Blockchain Technology Overview: distributed ledgers, consensus models and fundamental blockchain architecture.
Continue from here
Start with the mechanics: Blockchain questions and answers · How does blockchain work?
Understand the trade-offs: Blockchain limitations · Environmental impact
Take it into industrial systems: Impact on automation performance · Industrial scalability and flexibility · Edge computing