Who is in the blockchain network?

There's more to a blockchain network than miners. Users submit transactions. Nodes run the network software. Depending on the platform, miners, validators or authorised services help build blocks and establish the order of records. Developers, wallet providers, external data services and participating organisations handle other parts of the job. Not every network has all of these participants, and being a participant doesn't give everyone the same powers. [1] [2] [4] [10]
To make sense of blockchain technology, start with three practical questions: Who requests a transaction? Who checks it against the rules? Who establishes the shared transaction order? These are roles, not necessarily separate groups of people. One organisation might take on several of them, while running different software for each task. The important thing is to know which responsibility belongs where. [2] [9] [10]
About the illustration: The round table represents participants working with a shared record. It doesn't mean that everyone has equal authority, that every participant is independent, or that the ledger sits in one physical control centre.
Nodes: being connected isn't the same as checking the chain
A node is an instance of the network's client software communicating with other nodes. It may run on a server, a personal computer or other suitable hardware. Having an internet connection, opening a wallet or sitting on the same Ethernet network isn't enough. When looking at how blockchain works, ask which software the device runs and which checks it actually performs. [2]
A full node independently checks transactions and blocks against the protocol rules it enforces. In Bitcoin, that includes checking signatures and the conditions for spending funds. It doesn't have to mine. Nor does full validation mean keeping every old block file forever: Bitcoin Core can prune previously validated block data to reduce disk use. Checking the history and retaining all of it on disk are different requirements. [1] [3]
Light clients use the headers and proofs available in their protocol instead of processing the entire transaction history like a full node. Archive nodes retain additional historical data for queries; on Ethereum, that includes access to past account states. These choices matter for storage requirements and scalability. Be careful with the labels, though: “full”, “light” and “archive” don't mean exactly the same thing on every platform. [2]
Miners: producing blocks with proof of work
Mining is the block-production role used by proof-of-work (PoW) networks such as Bitcoin. A miner works on a candidate block, searching for a block-header hash below the required target. It isn't encrypting the transactions or solving a new scientific problem. Producing the required proof of work and checking whether the resulting block follows the rules are separate jobs. Other nodes still perform their own checks. [3]
For a Bitcoin block that remains in the accepted chain, the protocol allows the miner to collect the block subsidy and the fees from its included transactions. Miners may work independently or through pools. Finding a block doesn't make an invalid transaction acceptable; among competing valid chains, Bitcoin follows the one with the greatest accumulated proof of work. This computational competition is also why discussions of blockchain energy use need to identify the network involved, rather than treating mining as something every blockchain requires. [3] [10]
Validators: staking is more than holding coins
Holding coins in a wallet doesn't make you a validator. In a proof-of-stake (PoS) system, the role comes with protocol-specific requirements. On Ethereum, a validator stakes ETH and operates the required clients. Depending on its assigned duties, it proposes blocks or signs attestations—messages expressing its view of the chain. How duties are assigned, votes are weighted and penalties are applied depends on the particular PoS protocol. [4]
There's also a difference between missing rewards, participation penalties and slashing. On Ethereum, failing to carry out a duty can mean losing rewards or incurring penalties. Specific violations, such as signing conflicting proposals or attestations, can trigger slashing, which removes part of the stake. Going offline is not automatically a slashing offence, and Ethereum's penalty rules shouldn't be presented as universal rules for every PoS network. [4]
Keep the wording straight: a validator is a particular consensus role; validation is a task that other nodes can perform too. You can run an Ethereum full node without running a validator. Bitcoin, meanwhile, does not use PoS validators. Understanding the difference between Bitcoin and blockchain means recognising that participant names describe different responsibilities on different networks. [2] [3] [4]
Developers: network rules and application code are different jobs
Protocol developers work on network clients, security fixes and proposed changes to the protocol. Application developers build wallets, interfaces, integration software and smart-contract workflows. The team writing a rule for accepting a maintenance job doesn't also have to develop the blockchain underneath it. Application logic and network software sit at different levels. [5]
Writing the code doesn't give a team a master switch for the whole network. Ethereum protocol changes, for example, involve technical work and coordination across a wider group of participants. Protocol governance is separate from the administrator permissions inside an application. And a contract running successfully on the network is not proof that its business logic is correct. Access controls, testing and security review still matter. [5]
Users and wallets: who is asking, and who is signing?
A user might be a person, a business or an authorised application. It can request a payment, create an asset record or report that a job is complete. A wallet is the tool used to interact with accounts and arrange transaction signing—not a separate class of person. You don't necessarily need to operate a full node yourself to use a blockchain application. [6] [8] [9]
The next question is who actually controls the signing keys. With self-custody, the user controls signing directly, perhaps through a hardware signing device. With a custodial service, the provider may hold the keys and sign transactions on the user's behalf. Logging into an app with a password is not the same as signing an on-chain transaction with your own key. The wallet interface, account, address and private key are related, but they aren't interchangeable. [6]
Oracles: where does outside information come from?
An oracle supplies information from outside the blockchain to an on-chain application. An Ethereum smart contract, for example, cannot simply read a physical sensor by itself. Something has to obtain the external data and deliver it in a form the contract can use. In an Industrial IoT (IIoT) application, an oracle mechanism may be part of that connection between field equipment and the shared record. [7]
An oracle may rely on one operator or combine information from several sources. Either way, getting data onto the chain doesn't prove that the data is correct. Adding more services won't help if they all repeat the same faulty source. Where did the reading come from? How was it obtained? Is it still current? Those questions remain part of the design. [7]
Take an instrument that's out of calibration. Recording its output without changing a single bit still leaves you with a bad measurement. That's why measurement accuracy and calibration must be kept separate from protecting the integrity of a record. A sensor can supply data without being a full node or a block validator. In this example, measuring the process and checking the ledger are deliberately different responsibilities.
Exchanges and infrastructure providers: access is not consensus
Exchanges provide trading services and may also hold assets for customers. Operating a wallet service doesn't automatically make an exchange a block producer. An exchange operator might separately run nodes or validators, but those are additional technical roles. A permissioned network built to share documents, meanwhile, can operate without cryptocurrency trading or an exchange at all. [6] [10]
RPC and API providers give applications a way to query nodes or submit signed transactions. Using a remote node service doesn't, by itself, mean handing over your signing keys. It does create an infrastructure dependency: if an application relies on one provider and that provider goes offline, the application may lose access even while the blockchain continues running. An application's access path and the network's consensus system are not the same thing. [8]
Block explorers and indexing services make blocks, transactions and account activity easier to search. Seeing a transaction on a website isn't the same as checking it independently with your own full node. These tools help people read the records; they don't get to set the network's transaction-validity rules. [1] [8]
Auditors and regulators: reviewing records is a separate role
A record auditor may inspect the records, signatures and processes it has access to. A smart-contract security auditor looks for weaknesses in the software. Those are different kinds of review, and neither makes the whole system infallible. A useful assessment of blockchain security considers the contract code, operating infrastructure and permissions together, rather than treating an audit as a guarantee. [5] [9]
A regulator is not another name for a validator or a consortium administrator. From a system-design perspective, reading records, submitting transactions, endorsing them and changing network settings are separate permissions. Giving an organisation observer access doesn't automatically grant the other powers. This distinction concerns technical access; it doesn't define a regulator's legal duties in any particular country. [9]
Consortium networks: how organisations divide the work
A consortium brings organisations together to operate a shared system. Its members agree on membership, access and approval rules. In this kind of cross-company data-sharing network, an end user, an administrator, an endorsing peer and an ordering component may all have different permissions. “Permissioned” doesn't mean that every member can see or approve everything. [9] [10]
In Hyperledger Fabric, peers maintain ledgers and perform execution, endorsement and validation tasks according to their configuration. During endorsement, the required organisations' peers simulate a transaction proposal and sign the result. Those signatures alone don't mean the change has been committed. Nor do they prove that anyone has inspected the physical equipment: a peer's software endorsement and an engineer's inspection are different forms of approval. [10]
Fabric's ordering service establishes a common transaction order and distributes transactions in blocks. Peers then check the required endorsements and transaction conflicts before applying valid changes to the current state. Here's a detail that's easy to miss: a transaction marked invalid can still appear in a Fabric block, but it does not update the current state. “Included in a block” and “accepted as a valid update” are not interchangeable descriptions on this platform. [10]
Certificate authorities (CAs) issue digital identity certificates. A Membership Service Provider (MSP) defines which identities are recognised as valid members of an organisation. Policies determine what those identities may do. That separates three very different tasks: issuing an identity, approving a business transaction and ordering blocks. [9]
Fabric doesn't require a native cryptocurrency. It can also use private data collections, where authorised organisations hold the actual data while its hash appears on the shared ledger for the relevant channel. This distinction matters when designing industrial data privacy. These component names and responsibilities describe Fabric; don't assume every permissioned platform uses the same architecture. [10] [11]
Putting the roles to work: a pressure-sensor calibration record
Imagine a pressure-sensor supplier, an independent calibration laboratory and a factory's quality team sharing the delivery and calibration history of one instrument. They need to connect the serial number, the right report and each party's acceptance decision. That's a supply-chain traceability problem, not a request to create digital money. This is a hypothetical example to show the division of responsibilities, not a description of an installed system.
The supplier submits the instrument's identity and delivery information. The laboratory performs the tests and issues the calibration report. The factory's quality representative reviews the report and records an acceptance decision. The application could require both an authorised laboratory report and the factory's acceptance before changing the record to “accepted”. That business rule is not the same thing as a peer's software endorsement.
In this example, a data logger could retain the readings, while measurements received over an industrial communication link feed an edge-computing application that prepares the report. An integration service submits the relevant report information. The original measurement files stay in access-controlled storage; the report hash, revision and approvals are associated with the shared record. Comparing a later copy against that hash contributes to an industrial data-integrity check. It cannot restore a lost report: a hash isn't a backup. [11]
Notice the hand-off: the sensor measures, the logger stores, the integration service submits, authorised people make acceptance decisions, and the blockchain components enforce the recording rules. A faulty calibration reference would still produce a problem the ledger cannot fix. The factory's control loop also shouldn't wait for the record-approval process; real-time monitoring and ledger verification have different jobs here. Industrial cybersecurity, access control and key protection remain separate engineering responsibilities. [7] [12]
Does a larger network mean more independent control?
Counting servers doesn't tell you who is in control. Ten nodes whose administrator keys and infrastructure accounts all belong to one company are not equivalent to ten independent organisations checking one another. The same applies when one operator controls the data source, contract-administration permissions and every approving node. Giving the roles different names doesn't make them independent. This is a design judgement: examine the distribution of authority, not just the distribution of computers. [8] [9]
Before choosing the architecture, ask who admits new members, who approves a record, who can change the contract rules, and what happens when a required approver is unavailable. If everyone already accepts one company's record-keeping authority, a database with signed documents and audit logs may be simpler. The extra architecture needs a reason to exist, weighed against blockchain's limitations and operating overhead.
A useful participant list tells you who can do what—not just who is connected. Separate the parties that produce data, request transactions, sign, validate, order, read and administer the system. Treating every user as a node, every node as a miner or every data source as trustwor