When we hear the word blockchain, the first thing that comes to mind is usually decentralization.
It’s the foundation of what made Bitcoin revolutionary and what gave birth to the broader Web3 movement. No middlemen. No single point of control. Just code, consensus, and community.
By: Min SiThu
But if we look a little closer — at the teams behind the protocols, the infrastructure hosting the nodes, the decision-making processes — we find a different reality: many so-called decentralized systems are quietly supported (or controlled) by centralized elements.
This article isn’t about dismissing decentralization. It’s about being honest with where we are, what decentralization actually looks like in practice, and why centralization — sometimes subtle, sometimes blatant — still exists in these systems.
1. Code Is Law, But Who Writes the Law?
In any blockchain project, someone has to write and maintain the code. Whether it’s Ethereum, Solana, or newer chains like Aptos, there’s usually a core development team — often a small group of people — responsible for updates, bug fixes, and protocol changes.
While anyone theoretically can contribute, in reality, decisions about what gets merged, when upgrades are pushed, and which forks gain traction are made by a handful of people. That’s centralization, even if it’s not always visible.
Think about it this way: if a small group of devs decides the rules, are we truly decentralized?
2. Nodes, Infrastructure, and the Cloud Problem
Running a blockchain node isn’t always easy or cheap. As blockchains grow, storing the full history and syncing with the network becomes more resource-intensive. This has led many people and even entire projects to rely on centralized infrastructure providers like AWS, Infura, or Alchemy.
Infura, for instance, has become a go-to API provider for Ethereum. But it’s a centralized service. If it goes down (as it has in the past), dApps across the network suddenly stop working — even though the blockchain itself is still running.
So even if the data layer is decentralized, the access layer is often very centralized.
3. Governance: Decentralized in Theory, Centralized in Voting Power
On paper, many blockchain projects are governed by DAOs (Decentralized Autonomous Organizations), where users vote with tokens. But in reality, a small number of wallets hold most of the tokens, giving them outsized influence over proposals and decisions.
This isn’t that different from corporate voting, where major shareholders hold the power. Except here, it’s just dressed in Web3 language.
Also, proposals are often drafted, discussed, and pushed by core teams or insiders — while regular users might not even know a vote is happening. That’s centralization hiding under a community logo.
4. Branding and Narratives: Controlled by Central Figures
There’s also the social layer. Even in decentralized systems, public trust and reputation are often tied to central figures — founders, influencers, or ecosystem leads.
Vitalik Buterin’s words carry massive weight in Ethereum. Charles Hoskinson’s opinions shape Cardano. CZ shapes Binance Smart Chain (which many consider fully centralized, but still operates under a “blockchain” banner).
This isn’t inherently bad — but it challenges the idea that decisions are made entirely by collective consensus.
5. Regulation and Legal Fronts: Who Takes the Hit?
When governments or regulators come knocking, decentralized projects often rely on a central legal entity to represent them. Whether it’s a foundation (like the Ethereum Foundation) or a registered company, there’s usually someone who speaks on behalf of the chain — especially when legal or compliance issues arise.
So while the network may not be shut down easily, its interface with the real world often runs through centralized gates.
6. User Experience: Centralization for Convenience
Let’s be honest — decentralized tech isn’t always user-friendly. Wallets, seed phrases, gas fees — it’s a lot to deal with. That’s why centralized exchanges (like Binance or Coinbase) still dominate in user onboarding. People want convenience, and centralized platforms deliver that.
Even within dApps, many choose centralized custody or third-party tools to simplify onboarding. It’s a trade-off between idealism and usability.
So… Is True Decentralization Even Possible?
The answer is maybe. But it comes at a cost: complexity, slowness, and high coordination overhead.
Most current blockchain systems operate in a hybrid state — with decentralized infrastructure on the backend, but centralized control over direction, tools, and access.
And maybe that’s not a bad thing. Maybe the goal isn’t perfect decentralization, but rather transparency about where the central points are, and how much influence they carry.
Conclusion: Honest Decentralization Is Better Than Idealized Illusions
We need to stop pretending everything in blockchain is decentralized just because it says so in the whitepaper.
Acknowledging the central backbones in these systems doesn’t weaken the movement — it strengthens it by making it more grounded and honest.
As the ecosystem matures, the real question becomes:
How do we reduce central points of failure while still keeping things usable and scalable?
True decentralization might be a direction, not a destination. And that’s okay — as long as we know who’s really holding the keys.
Sample Code: centralized_vs_decentralized.py
import random# Define a group of nodes
nodes = ['Node1', 'Node2', 'Node3', 'Node4', 'Node5']# Decision options
decisions = ['Accept', 'Reject']# Centralized system: leader decides for all
def centralized_decision(leader='Node1'):
decision = random.choice(decisions)
print(f'[CENTRALIZED] {leader} makes a decision: {decision}')
for node in nodes:
print(f' - {node} follows: {decision}')
return decision# Decentralized system: all nodes vote, majority wins
def decentralized_decision():
votes = {}
for node in nodes:
vote = random.choice(decisions)
votes[node] = vote
print(f' - {node} votes: {vote}') # Count votes
accept_votes = sum(1 for v in votes.values() if v == 'Accept')
reject_votes = len(nodes) - accept_votes
final_decision = 'Accept' if accept_votes > reject_votes else 'Reject'
print(f'[DECENTRALIZED] Final decision by majority: {final_decision} ({accept_votes} Accept / {reject_votes} Reject)')
return final_decision# Run both simulations
print("=== Centralized System ===")
centralized_decision()print("\n=== Decentralized System ===")
decentralized_decision()
Run It:
python3 centralized_vs_decentralized.pyResults:
=== Centralized System ===
[CENTRALIZED] Node1 makes a decision: Accept
- Node1 follows: Accept
- Node2 follows: Accept
- Node3 follows: Accept
- Node4 follows: Accept
- Node5 follows: Accept=== Decentralized System ===
- Node1 votes: Accept
- Node2 votes: Reject
- Node3 votes: Accept
- Node4 votes: Reject
- Node5 votes: Accept
[DECENTRALIZED] Final decision by majority: Accept (3 Accept / 2 Reject)Thank you!
