Authority over state, not ideology
The Web2-versus-Web3 conversation is usually framed as a values argument: platforms against protocols, corporations against communities. That framing is close to useless if your job is to decide what to build with a defined budget. One distinction sits underneath all the others and is worth building the decision on: who holds the authority to change the state of the system, and what they must present to prove it.
In a conventional Web2 application, your server is the final authority. An account is a row in your database. A password is a way of recognising who owns that row. And you can change any row at any moment — reverse a transaction, restore a deleted record, recover an account for a customer who lost access. That capability is not a design flaw. It is the thing that makes a support function possible at all.
In a Web3 application, that authority moves to whoever holds the private key. A smart contract executes what a valid signature instructs. It has no view on intent, no memory of the phone call that preceded the request, and no mechanism for regret. That is what gives a user genuine independence over what they own, and it is the same property that makes a mistake permanent. Nearly everything downstream — interface decisions, support policy, legal exposure — follows from that single sentence.
Three constraints you meet in week one
Reads and writes stop being symmetrical. In your own database, writing a row and reading it back cost roughly the same. On-chain, every write is a transaction with a fee, a confirmation delay and a real probability of failure, while reads from a node are cheap but slow and offer nothing resembling a query language. The moment a sortable table or a filtered list appears in your designs, you have committed to an off-chain indexing layer. That is architecture, not optimisation, and it belongs in the first sprint.
There is no undo. A confirmed transaction is final by design. No administrative reversal, no quietly correcting the record once somebody notices. This reshapes product work more than most teams expect: validation has to happen before the signature rather than after the fact, and confirmation screens have to describe consequences in the user's language rather than the contract's.
Deployed code is public and, by default, immutable. Anyone can read your contract and call its functions directly without ever touching your interface. Everything you would have treated as a front-end check in Web2 becomes security theatre — every constraint has to live inside the contract itself. And a defect discovered after deployment cannot be patched by shipping a new build unless you designed an upgrade path before launch, which carries its own cost and its own centralisation trade-off.
What does not change: most of the product is still Web2
It is worth saying plainly to a board: in any serious Web3 product, the majority of engineering effort goes into entirely conventional components. The front end uses the same frameworks. The indexing layer is an ordinary database. Notifications, email, analytics, admin tooling and support dashboards are pure Web2. File storage usually stays off-chain, because putting it on-chain costs more than it returns.
This is not a compromise on principle. It is the correct shape of the system. A chain is a settlement and shared-record layer, not an application database. Teams that internalise this build products that work at volume. Teams that try to put everything on-chain build slow, expensive demos that stall at the first realistic load test.
The practical consequence for a company evaluating the space is that you are not replacing your engineering team. You are adding one narrow specialism to it. Anyone telling you otherwise is selling a rebuild you do not need.
A four-question test before you commit budget
Does more than one independent party need to trust the same record without trusting each other? If the record is internal and you are the only party writing to it, a database with a signed audit trail solves the problem for a fraction of the cost and none of the new operational overhead.
What does a counterparty lose if you can quietly edit that record? If the honest answer is nothing of consequence, then immutability is a marketing requirement rather than an engineering one, and it will not survive the first serious cost review.
Will your users accept responsibility for a key? This is a question about your audience, not about technology. An institutional counterparty with its own technical staff may well accept it. A retail customer typically will not. The answer determines whether you build a self-custody experience or work with a regulated custody provider — two materially different products with different obligations.
Who carries the liability when something goes wrong? This one is not technical, and it decides whether the project is viable in your regulatory context at all. Any work touching financial assets or fundraising is subject to legal and regulatory review by a qualified adviser before you commit to an architecture.
Three clear answers in favour out of four justify a tightly scoped proof of concept. One or two mean a conventional system is probably the better answer — and establishing that early is a result worth paying for.
Five mistakes that show up in almost every first build
Asking for a wallet connection on the first screen. This is the largest single drop-off point in most Web3 products, and the fix costs nothing: explain the value first, then request the wallet at the first action that genuinely requires one.
Reading directly from a node on every screen. It performs beautifully in a demo with a handful of records and falls over at the first realistic production volume. Indexing is not an optimisation you defer until after launch.
Ignoring chain reorganisations. An event you already processed can be rolled back. Teams that do not handle this explicitly end up with duplicated or missing records that finance discovers weeks later during reconciliation.
Opaque signature prompts. When a wallet displays an unreadable payload, the user either refuses — and you lose them — or approves without understanding, and you inherit the outcome. Translating what is being authorised into one clear sentence is your product's responsibility, not the wallet's.
Treating the security audit as a formality in the final week. An audit takes time, surfaces things nobody considered, and produces findings that need fixing and then re-reviewing. Scheduling it as a checkbox on the launch list means either delaying the launch or shipping without it.
Where the two models actually meet
Most credible products today do not pick a side. They are built on the boundary, and three patterns are worth understanding before you decide anything.
Accounts as smart contracts. EIP-4337 defines a way to run accounts as smart contracts on Ethereum without changing the protocol itself. That enables behaviour any Web2 user takes for granted and conventional wallets cannot offer: recovery through trusted parties, spending limits, and delegated permissions scoped to specific operations. It addresses the largest adoption barrier directly — that losing a recovery phrase means losing everything, permanently.
Verifiable identity. The W3C has published a recommendation for Decentralized Identifiers, which lets a person or organisation control an identifier that third parties can verify without depending on a single central registry. The nearest-term application is not login. It is verification of credentials and documents issued by a known authority.
The integration layer. Whatever happens on-chain has to surface inside the systems your business actually runs on: order management, accounting, the support console. Otherwise it becomes an island that developers maintain by hand. Build that layer assuming failure — duplicate messages, retries, and a scheduled reconciliation that exposes any divergence between the two records before it turns into an audit finding.
How to test the idea in weeks, not quarters
The most useful move for a company evaluating this space is to change the question from whether to adopt Web3 into what the smallest thing is that would prove or disprove the premise. The first question generates meetings. The second generates an answer.
Pick one use case with at least two genuine parties, and write the acceptance criteria before you start rather than after you see the result. Deploy to a test network and measure three things: how long a non-technical user takes to complete the whole flow, what a single operation costs at realistic volume rather than demo volume, and how many cases needed a human to intervene. Those three numbers say more about viability than any market report.
If the proof of concept holds, you have real foundations and a costed path forward. If it fails, you bought the answer in weeks instead of quarters — which is a return, not a loss.
Key takeaways
- Start by establishing who holds authority to change state in your system; that question alone settles most of the Web2 versus Web3 choice.
- Run the four-question test before any code is written: multiple independent parties, the cost of a silent edit, key custody, and where liability sits.
- Budget for an off-chain indexing layer and a contract upgrade path at design time, not after launch.
- Request a wallet connection at the first action that genuinely needs one, never on the first screen a visitor sees.
- Validate on a test network against written acceptance criteria, and measure three numbers: user completion time, cost per operation, and manual interventions.
Frequently asked questions
Is Web3 a replacement for Web2?
No, and this is the most common misreading. A decentralised network is a settlement and shared-record layer added to your existing stack. It does not replace interfaces, databases, reporting or support tooling. Every product running in production today is hybrid by nature, and the larger part of it is entirely conventional.
Do we need a blockchain for a loyalty programme or product traceability?
Usually not, if you are the only party writing to and reading from the record. The genuine need appears when independent parties who do not fully trust each other share the record — suppliers, carriers and inspection bodies, for example — and your ability to edit it unilaterally has a real effect on them. Without both conditions, a database with a signed audit trail is cheaper and easier to operate.
Does a Web3 project require issuing a token?
No. Many enterprise use cases — document verification, supply chain traceability, shared records between known partners — require no token at all. We make no financial or investment promises, and any work touching financial assets or fundraising is subject to legal and regulatory review by a qualified adviser before implementation.
How long does a realistic proof of concept take?
It depends on the number of parties and how deep the integration with your existing systems goes, but the usual estimate is measured in weeks rather than months when scope is limited to one use case with acceptance criteria agreed up front. Scope expansion mid-build is the main reason proofs of concept turn into open-ended projects.
Sources
- Introduction to dapps — ethereum.org · https://ethereum.org/en/developers/docs/dapps/
- EIP-4337: Account Abstraction Using Alt Mempool — Ethereum Improvement Proposals · https://eips.ethereum.org/EIPS/eip-4337
- Decentralized Identifiers (DIDs) v1.0 — W3C · https://www.w3.org/TR/did-core/