Web3 interviews should reveal whether candidates can explain who has authority, what a transaction changes and how the application knows that change is settled. Ask an engineer to trace a wallet request through contract execution and indexing, diagnose an uncertain submission, or identify the assumptions behind a bridge. These exercises expose practical judgment more clearly than asking for definitions of decentralization alone.
This guide to 100+ Web3 Interview Questions and Answers contains 120 questions across beginner, intermediate and experienced levels. It focuses on application engineering: accounts, transactions, contracts, signing, token interfaces, oracles, scaling, content addressing and operations. Ethereum and EVM examples provide a concrete reference, while answers distinguish implementation-specific behavior from broader architectural principles.
How can recruiters assess genuine Web3 engineering ability when interviews may involve AI cheating, deepfakes, impersonation or unauthorized assistance?
Ask candidates to explain a small contract’s authorization, predict a rejected call and revise a signing design when the chain or nonce changes. State permitted tools consistently and use follow-ups about evidence, failure handling and trust assumptions. A candidate’s explanation of why a test is insufficient can be as revealing as a polished code sample.
Sherlock AI helps recruiters detect potential AI-assisted cheating, deepfakes, candidate impersonation and unauthorized real-time assistance during Web3 interviews. Review those signals with the candidate’s reasoning and work, using context and human judgment rather than treating a signal as proof of misconduct.
Web3 Interview Questions
The questions progress from accounts and execution fundamentals to authorization, integration and architectural judgment. Solidity examples identify compiler 0.8.38, and JavaScript library examples use ethers 6.17.0. Apply the relevant chain’s rules and deployed configuration; Web3 does not imply one universal account, fee or finality model.
Web3 Interview Questions for Beginners
Start with the components and guarantees of a decentralized application. Candidates should distinguish signing, submission, execution and settlement, and understand what public-chain data does and does not establish.
What does Web3 mean in an engineering discussion?
When does an application benefit from a blockchain?
Which components make up a typical decentralized application?
How does a wallet differ from an account?
How do externally owned accounts and contract accounts differ?
What does a public address reveal about identity?
What does a digital signature establish?
How is connecting a wallet different from signing a request?
What is an Ethereum transaction?
What does an account nonce do?
What is gas?
How do base fee, priority fee and maximum fee relate?
Does a failed transaction cost gas?
How is a read call different from a transaction?
What does a transaction receipt tell an application?
How do inclusion, confirmations and finality differ?
What is a chain reorganization?
What does a smart contract do?
What is the Ethereum Virtual Machine?
What is an ABI?
How do contract storage, memory and calldata differ?
Does private contract state remain secret?
How do events differ from contract state?
What is access control in a smart contract?
Why should authorization usually examine msg.sender rather than tx.origin?
What is reentrancy?
What is the checks-effects-interactions pattern?
What does ERC-20 standardize?
How do approve and transferFrom relate?
What does ERC-721 standardize?
Why do token decimals matter?
What is an oracle?
Why can a contract not simply fetch an arbitrary website during execution?
What is a blockchain bridge?
How does a rollup differ from a sidechain?
How do optimistic and validity rollups differ?
What is data availability?
What does an IPFS content identifier establish?
What does an RPC provider do?
Why do decentralized applications use indexers?
Web3 Interview Questions for Intermediate
Explore transaction handling, typed permissions, contract integration, upgrades and exact data representation. These questions assess whether a candidate can preserve user intent across asynchronous and adversarial boundaries.
How should a frontend handle account and network changes?
How should contract addresses be managed across environments?
How should a service coordinate transaction nonces?
How should a stuck transaction be replaced or canceled?
What are the limits of gas estimation?
How should an application decode a contract failure?
Why can abi.encodePacked be dangerous for signed or hashed messages?
What problem does EIP-712 solve?
Which fields help separate a typed-data signing domain?
How should an application prevent replay of a signed permission?
How does contract-account signature verification differ from key recovery?
What should Sign-In with Ethereum verification check?
How do a permit signature and an onchain approval differ?
How should token transfers handle unusual token behavior?
Why do safe NFT transfers involve receiver callbacks?
How should a contract distinguish ownership from operational roles?
What risks arise from an upgradeable proxy?
Why is storage layout important during upgrades?
What is the difference between a constructor and an initializer in a proxy design?
How should pause mechanisms be designed?
What should a multisignature policy consider beyond its threshold?
How do timelocks change governance risk?
How should oracle freshness be validated?
How can price manipulation affect contract logic?
What is slippage protection?
What is maximal extractable value?
How should a commit-reveal scheme be evaluated?
Why is block data usually unsuitable as secure randomness?
How should event processing handle duplicates?
How should an indexer recover from a reorganization?
How should several contract reads use a consistent state snapshot?
How should large integers cross a JavaScript API boundary?
How should an application choose what data to store onchain?
How should content-addressed data remain available?
How should mutable names pointing to immutable content be handled?
What should smart-contract unit tests cover?
How do fuzz tests complement example-based contract tests?
What makes a useful contract invariant?
What does source-code verification on an explorer establish?
How should deployment configuration be made reproducible?
Web3 Interview Questions for Experienced
Use these scenarios to assess architecture, economic assumptions, incident response and evidence quality. Strong candidates should explain the limitations of each control and justify the system’s operational trade-offs.
How would you map the trust assumptions of a Web3 application?
How would you decide whether to keep a critical operation offchain?
How would you investigate a transaction reported as failed by the frontend?
How would you design a transaction state machine for the user interface?
How would you prevent duplicate business operations after a submission timeout?
How would you assess a proposed contract upgrade?
How would you respond to a suspected compromised administrator key?
How would you evaluate whether a multisignature is meaningfully decentralized?
How would you review a cross-chain application’s failure model?
How would you handle an L2 sequencer outage?
How would you compare two scaling networks for an application?
How would you design around data withholding risk?
How would you assess an oracle fallback policy?
How would you analyze an economic attack that passes all access-control checks?
How would you evaluate a zero-knowledge claim in a product design?
How would you handle confidential or regulated data requirements?
How would you review a wallet-signing experience for misleading consent?
How would you secure the frontend supply chain of a decentralized application?
How would you distinguish verified source from an audited system?
How would you use formal verification responsibly?
How would you make a contract test suite detect false confidence?
How would you test reentrancy defenses beyond one withdrawal function?
How would you review a contract with unbounded iteration?
How would you design a pull-payment workflow?
How would you handle token accounting with fees or rebasing?
How would you assess rounding in a financial smart contract?
How would you make an indexer rebuild trustworthy?
How would you monitor a Web3 application beyond node uptime?
How would you plan recovery when onchain actions cannot simply be rolled back?
How would you evaluate a key-recovery design?
How would you prevent replay across chains and deployments?
How would you evaluate account abstraction or delegation for a product?
How would you analyze a sponsored-transaction service?
How would you choose between public and private transaction submission?
How would you review governance voting beyond token balances?
How would you handle an externally discovered contract vulnerability?
How would you review AI-generated Solidity or signing code?
What should a practical Web3 interview exercise assess?
How should an engineer communicate the limits of a Web3 prototype?
What would a strong Web3 architecture proposal demonstrate?
Web3 Interview Questions and Answers
The answers follow the question bank exactly. Look for precise trust boundaries, concrete examples and an explanation of which evidence supports a claim. The scope is engineering rather than token valuation or investment selection.
Web3 Interview Questions and Answers for Beginners
These answers establish the execution and trust foundations. Ask candidates to apply each concept to an ordinary user action and identify a plausible failure state.
1. What does Web3 mean in an engineering discussion?
Web3 is a broad label for applications that use blockchain-based state, cryptographic accounts and related decentralized infrastructure. It is not one protocol or a guarantee that every component is decentralized. A useful engineering discussion identifies which decisions are enforced by contracts and which still depend on operators.
For a membership application, the token may be onchain while the website, search index and media remain centrally hosted. Explain those boundaries rather than calling the whole system trustless. The architecture should justify the added coordination, cost and recovery complexity against the actual product requirement.
2. When does an application benefit from a blockchain?
A blockchain can be useful when independent parties need a shared, verifiable state transition system without giving one application operator unilateral control over the record. Composability and user-controlled authorization may also matter.
A conventional database is often simpler when one organization already controls the rules and participants accept that authority. Compare latency, privacy, cost, governance and recovery needs. Storing a checksum onchain does not solve an unreliable source-data process, and adding a token does not by itself establish a useful decentralized application.
3. Which components make up a typical decentralized application?
A typical application combines a user interface, wallet or account interface, RPC access, smart contracts, indexing and offchain services. Storage, oracles and cross-chain components may add further dependencies.
Trace one action through all of them: the UI constructs a request, the user authorizes it, a provider submits it, the chain executes it and an indexer updates the display. Each component can fail or misrepresent state. A candidate should distinguish the authoritative contract state from a cached interface and explain how the user learns whether an action actually completed.
4. How does a wallet differ from an account?
An account is a protocol-level identity and state object; a wallet is software or hardware that helps manage authorization and interaction with accounts. One wallet can manage several accounts, and an account’s authorization may involve more than one person or device.
Do not describe a wallet as a container that literally stores coins. Balances and contract state exist on the network, while the wallet manages the means to authorize actions and inspect that state. Recovery and compromise analysis should focus on those authorization mechanisms and any associated custodial service.
5. How do externally owned accounts and contract accounts differ?
Traditional externally owned accounts authorize transactions using keys, while contract accounts execute code and can implement more elaborate authorization policies. Modern Ethereum delegation mechanisms complicate the simplistic rule that an externally owned account can never have executable behavior.
Identify the chain and supported account model before making assumptions. A contract wallet may require multiple approvals or recovery logic, and EIP-7702 permits delegated code for an externally owned account. Applications should use appropriate signature-validation and account interfaces rather than equating every address with a single human-held key.
6. What does a public address reveal about identity?
An address identifies an account or contract within a particular network context. It does not inherently establish a person’s legal identity, exclusive ownership or authorization to act for an organization.
One person may control many addresses, while a multisignature account may represent several people. Public transaction history can also create privacy risks through correlation. In an interview, distinguish proving control of an account from proving a real-world identity or granting application-specific permissions.
7. What does a digital signature establish?
A valid signature establishes that the relevant signing authority authorized a particular encoded message under the verification scheme. It does not establish that the user understood the message, that the application is safe or that the message may be replayed indefinitely.
Verification must bind the message to its intended context and check the application’s authorization rules. For a contract account, signature validity may depend on current contract state. A cryptographically valid signature for a different chain, contract or action should not authorize the current operation.
8. How is connecting a wallet different from signing a request?
Connecting normally grants an application access to selected account information through a wallet interface. Signing authorizes or attests to a particular message or transaction. Neither action should be treated as a blanket permission for all future operations.
The UI should explain the requested action, account, network and consequences before prompting. A connection is not authentication by itself, and a message signature may carry consequential permissions even without an immediate onchain transaction. Review each permission boundary separately rather than relying on the familiar appearance of a wallet popup.
Action | Typical purpose | What it does not establish |
|---|---|---|
Connect account | Expose selected account context | A completed authenticated session |
Sign login message | Prove account control for a scoped challenge | Permission to transfer arbitrary assets |
Sign structured permission | Authorize the specified protocol action | Safe unlimited reuse |
Submit transaction | Request an onchain state transition | Successful or final execution |
9. What is an Ethereum transaction?
A transaction is a signed protocol instruction submitted for inclusion and execution, potentially transferring value, calling code or creating a contract. Its fields specify matters such as destination, data, nonce and fee constraints.
Submission does not mean successful execution. The transaction can remain pending, be replaced, fail during execution or be included in a block that later leaves the canonical chain. An application should represent those states explicitly and verify the relevant receipt and business outcome before displaying completion.
10. What does an account nonce do?
For ordinary Ethereum transactions, the sender’s nonce orders transactions and helps prevent replay of the same transaction on that account’s sequence. Transactions with future nonces may wait for earlier ones, and a competing transaction with the same nonce may replace a pending one under client policies.
This is distinct from an application-level nonce inside a signed permission. A service submitting transactions concurrently needs coordinated nonce allocation and reconciliation with chain and pending state. Simply incrementing an in-memory counter can fail after a restart or when another process uses the same account.
11. What is gas?
Gas measures protocol-defined execution and resource usage. A transaction’s gas limit bounds the execution gas it can consume, while gas prices determine the monetary fee for that usage.
Gas is not a fixed currency amount and should not be confused with the value transferred to a recipient. A function’s cost depends on its execution path and state. Estimate with the intended inputs and account, leave appropriate room for variation, and still handle failure because an estimate cannot freeze future chain state.
12. How do base fee, priority fee and maximum fee relate?
For an EIP-1559 execution transaction, the effective gas price combines the block’s base fee with a tip bounded by the priority-fee cap and total fee cap. If the maximum fee is below the required base fee, the transaction cannot be included under that condition.
The example uses illustrative integer gwei values to make the arithmetic clear. It does not quote current network fees or include separate blob fees and network-specific L2 data charges. The UI should show estimates and caps accurately without presenting the maximum authorized fee as the inevitable final charge.
JavaScript (Node.js) — illustrative execution-fee arithmetic
13. Does a failed transaction cost gas?
An included transaction that reverts generally still pays for gas consumed, even though its reverted execution changes do not persist. The sender’s transaction nonce is consumed, and protocol-level handling is not equivalent to pretending the transaction never existed.
Distinguish a rejected submission from an included execution failure. A user may see no token transfer yet still have paid a fee. Applications should explain the failure, avoid blindly resubmitting and inspect whether an earlier transaction already achieved the intended action before proposing another attempt.
14. How is a read call different from a transaction?
A read-style RPC call can simulate execution against a chosen block state without submitting a state-changing transaction. It may execute substantial code, but its simulated changes are not committed to the chain.
A Solidity view function is not universally free: calling it within an onchain transaction consumes execution resources, and RPC providers may impose service limits. Specify the block context for consistent reads. A successful simulation is useful evidence, but the actual transaction may execute against different state and produce a different result.
15. What does a transaction receipt tell an application?
A receipt records execution-related information after inclusion, including status and logs under the relevant chain’s format. It helps establish whether the transaction’s execution succeeded and where it was included.
Receipt success does not automatically prove the application’s intended business result. A called contract may return an unsuccessful value without reverting, or the request may target the wrong address. Check the contract, decoded events and relevant state, and apply the application’s confirmation or finality policy before treating the result as settled.
16. How do inclusion, confirmations and finality differ?
Inclusion means a transaction appears in a block. Confirmations describe subsequent chain progress under a chosen counting convention. Finality is a protocol-specific assurance that reversing the accepted history would require violating defined consensus assumptions or exceptional intervention.
Do not use one universal confirmation count for every chain and risk level. A low-value UI update and an irreversible external fulfillment can warrant different policies. L2 sequencer acceptance, L1 publication and settlement can also be distinct milestones that the application should communicate separately.
Milestone | Meaning | Application implication |
|---|---|---|
Submitted | A request was accepted by an access path | Outcome may still be unknown |
Included | Appears in a block | Check execution status and canonicality |
Confirmed by policy | Meets the application’s observation threshold | Policy must match the risk and chain |
Finalized / settled | Meets relevant protocol settlement conditions | State assumptions and exceptional limits remain explicit |
17. What is a chain reorganization?
A reorganization changes which competing blocks are considered part of the canonical chain. Transactions and logs observed in displaced blocks may disappear from the canonical history or be included again elsewhere.
Indexers should track block hashes and parent relationships rather than treating block numbers alone as permanent identities. Keep reversible processing for provisional data and reconcile external effects carefully. A notification can be corrected; shipping a physical item cannot be undone merely by rolling back an index row.
18. What does a smart contract do?
A smart contract executes code under the blockchain’s rules and maintains or interacts with onchain state. It can enforce specified conditions, but it does not independently understand intent or verify every external fact.
A contract recording a document digest proves only the behavior its code implements, such as who could write that value and when it appeared in accepted history. It does not prove that the document is truthful or legally owned by that account. Those claims require additional processes and evidence.
19. What is the Ethereum Virtual Machine?
The EVM is the execution environment for Ethereum-compatible bytecode, with defined instructions, state access and resource accounting. Solidity is one language that can compile to that bytecode.
EVM compatibility does not imply every chain has identical operational properties. Fork support, gas schedules, precompiles, finality and surrounding infrastructure may differ. Pin a compiler target appropriate to the intended network and test against that environment rather than assuming a contract compiled for one fork will behave identically everywhere.
20. What is an ABI?
An application binary interface describes how to encode calls and decode outputs, errors and events for a contract interface. Client libraries use it to translate named functions and typed arguments into the bytes the EVM receives.
An ABI is not proof of the code deployed at an address. A stale or incorrect ABI can decode misleadingly or produce calls to the wrong function. Bind the interface to the intended network, contract address and deployment version, and verify those relationships during release and incident diagnosis.
21. How do contract storage, memory and calldata differ?
Storage persists as contract state, memory is temporary working space during execution, and calldata is the read-only input region used for external calls. Solidity’s data-location rules determine copying, references and permitted mutation.
Choose locations deliberately for arrays and structs. Accidentally copying a storage object can mean changes affect only a temporary value, while a storage reference can mutate persistent state. The cost and correctness implications matter more than memorizing a rule that one location is always preferable.
Location | Lifetime | Typical concern |
|---|---|---|
Storage | Persistent contract state | Mutation, layout and gas |
Memory | Temporary execution workspace | Copies, references and allocation |
Calldata | Read-only call input | Input decoding and validation |
22. Does private contract state remain secret?
No. Solidity visibility controls how code accesses members through the language interface; it does not encrypt public-chain storage or transaction data. Observers can inspect underlying state and execution inputs.
Do not store passwords, private keys or confidential customer records in a private variable. Even storing an unsalted hash of a predictable secret can enable guessing. If confidentiality is required, design an appropriate offchain or cryptographic protocol and analyze metadata and key-management risks rather than relying on a visibility keyword.
23. How do events differ from contract state?
Events produce logs useful for offchain observation and indexing, while contract storage holds state available to subsequent execution. Contracts generally cannot read historical logs as though they were ordinary storage.
An event can communicate that a record changed, but the current value should be read from the appropriate state when needed. Reverted execution does not retain its reverted logs, and reorgs can invalidate previously observed logs. Design event consumers for replay and deduplication rather than assuming delivery is exactly once.
24. What is access control in a smart contract?
Access control determines which callers may perform sensitive actions such as updating records, minting tokens or changing configuration. It must be enforced by the contract or relevant authorization layer, not merely by hiding a button in the frontend.
The teaching contract below allows only its deployment-time owner to write nonzero digests. It deliberately omits ownership rotation, recovery and production governance. Compilation checks syntax and interface generation; separate execution tests are needed to prove authorized and unauthorized calls behave as intended.
Solidity 0.8.38 — minimal record registry for compilation and review
25. Why should authorization usually examine msg.sender rather than tx.origin?
The immediate caller is normally the relevant principal for a contract’s authorization decision. Using tx.origin can confuse the original transaction initiator with the account actually invoking the protected function through a chain of calls.
That confusion can allow an intermediary contract to exploit a user’s interaction. Modern account delegation and smart-account designs also make simplistic human-versus-contract assumptions unreliable. Define the intended caller policy explicitly and use well-reviewed authorization patterns, including appropriate signature validation when a relayer acts on another account’s behalf.
26. What is reentrancy?
Reentrancy occurs when execution transfers control externally and the called code reenters a function or related system before the original operation has established a safe state. It is not limited to an Ether withdrawal function.
Consider cross-function and cross-contract invariants, token callbacks and observations of temporarily inconsistent state. Updating state before interactions and using appropriate guards can reduce risk, but neither is a universal proof. Review every external boundary and test adversarial callbacks against the properties the system must preserve.
27. What is the checks-effects-interactions pattern?
The pattern performs validation first, updates internal state next and makes external calls afterward. It reduces the opportunity for a callback to observe or reuse stale state within the protected operation.
For a withdrawal, reduce the recorded entitlement before transferring value and handle transfer failure consistently. Still analyze interactions with other functions and contracts; a locally ordered function can participate in a wider inconsistent system. The pattern is a design aid, not a substitute for invariant reasoning and adversarial testing.
28. What does ERC-20 standardize?
ERC-20 defines a common interface for fungible-token balances, transfers and allowances, along with associated events. This interoperability lets clients and contracts interact with many token implementations through a familiar interface.
It does not guarantee economic value, honest administration or identical transfer behavior. Integrations must account for nonstandard return behavior and token-specific mechanics such as transfer fees or rebasing. Verify assumptions about received amounts instead of assuming the requested transfer amount always equals the balance increase.
29. How do approve and transferFrom relate?
An approval grants a spender an allowance, and transferFrom lets that spender move tokens within the applicable allowance and token rules. Approving does not itself necessarily move the tokens, but it creates a consequential permission.
Show the spender and amount clearly, and avoid treating unlimited approval as harmless convenience. Changing an existing allowance can have transaction-ordering risks, so follow the token and library’s appropriate patterns. Revoking an allowance affects future use; it cannot undo a transfer already completed.
30. What does ERC-721 standardize?
ERC-721 defines interfaces for tracking and transferring individually identified tokens, including ownership and approvals. A token’s identifier distinguishes it within its contract; the contract address and chain are also necessary to identify the asset context.
Owning a token does not automatically grant copyright, access to a physical object or immutable metadata. Those relationships depend on additional terms and implementation. Evaluate receiver compatibility, metadata availability and administrator powers rather than assuming the NFT label establishes every property users care about.
31. Why do token decimals matter?
Decimals describe how integer base units are displayed as human-readable quantities. They do not change the underlying integer accounting, and different tokens can use different precision conventions.
Use exact integer or arbitrary-precision representations when converting amounts. JavaScript floating-point arithmetic can silently lose precision for large values or decimal fractions. Reject excess precision rather than rounding an authorization unexpectedly, and obtain the intended token’s metadata from a trustworthy context instead of assuming every token uses eighteen decimals.
JavaScript (ethers 6.17.0) — exact base-unit conversion
Run this standalone CommonJS file in a local project with ethers@6.17.0 installed. It performs only local parsing and assertions, with no provider or wallet.
32. What is an oracle?
An oracle supplies information that a contract cannot directly obtain from its deterministic execution environment, such as an external price or event outcome. It introduces a data and operational trust boundary.
Assess source quality, update frequency, aggregation, manipulation resistance and failure handling. Several reporters using the same compromised source may not provide meaningful independence. A contract should define what happens when data is stale or unavailable rather than treating every stored value as a current and accurate fact.
33. Why can a contract not simply fetch an arbitrary website during execution?
Consensus execution needs participating nodes to derive the same result from agreed inputs. An arbitrary web request could return different data to different nodes or change between executions, so ordinary EVM code does not perform such requests directly.
Use an oracle or another explicit mechanism to bring agreed data onchain, and evaluate its trust model. The blockchain can enforce a rule using a supplied value, but it cannot make an unreliable external source truthful merely by recording its response.
34. What is a blockchain bridge?
A bridge transfers messages or representations of assets between networks through a particular verification and custody design. It may lock and mint, burn and mint, or use liquidity-based mechanisms rather than literally moving one object between ledgers.
Analyze who validates source-chain events, how finality is handled and what happens if a validator set or contract is compromised. The destination representation inherits bridge assumptions in addition to the destination chain’s security. A familiar token symbol does not establish equivalence to the original asset.
35. How does a rollup differ from a sidechain?
A rollup executes transactions outside the base layer while using a defined settlement and data-publication design to derive security from it. A sidechain generally has its own consensus and security assumptions, even when it is EVM-compatible and connected by a bridge.
Evaluate the actual deployed system rather than the category name alone. Upgrade keys, sequencer control, proof systems, data availability and exit mechanisms affect risk. Lower fees do not by themselves establish that two networks provide equivalent guarantees.
Design aspect | Rollup | Sidechain |
|---|---|---|
Execution | Outside the base layer | On its own chain |
Security relationship | Defined settlement/proof/data design tied to base layer | Own consensus assumptions |
Questions to inspect | Proofs, data, sequencer, upgrades and exits | Validators, bridge, upgrades and exits |
36. How do optimistic and validity rollups differ?
Optimistic designs accept proposed state transitions subject to a challenge mechanism, while validity designs use proofs to establish the correctness of transitions under the proof system. Their verification and withdrawal paths therefore differ.
Neither label removes every operational assumption. Data availability, upgrade authority, sequencer behavior and proof-system implementation still matter. A validity proof also does not imply transaction privacy; many systems use proofs for correctness while publishing transaction data. Ask what exactly is proved and what information remains public.
37. What is data availability?
Data availability concerns whether the data needed to verify or reconstruct a system’s state can be obtained. A commitment to data is not the same as access to the data itself.
In a scaling system, valid state-transition proofs may coexist with separate assumptions about obtaining the underlying transaction data. Evaluate who publishes and retains it and what users can do when it is withheld. Availability, correctness and long-term archival access are related but distinct engineering questions.
38. What does an IPFS content identifier establish?
A CID identifies content using a structured identifier that includes information such as codec and hash details. For chunked files it can identify a DAG root, so it is not simply the raw file’s SHA-256 string.
Matching content and import settings produce stable identifiers, but a CID does not guarantee that anyone continues serving the content. Nor does it prove the content’s author, truthfulness or safety. Plan retention and verification separately, and distinguish content integrity from availability and provenance.
39. What does an RPC provider do?
An RPC provider exposes methods for reading chain data, simulating calls and submitting transactions. It is an access path to the network, not necessarily an independent source of truth for every response.
Providers can lag, rate-limit, omit historical capabilities or disagree temporarily about pending state. Pin block context for related reads and monitor freshness. Using multiple endpoints can improve resilience, but only if the application understands consistency and trust rather than combining incompatible observations indiscriminately.
40. Why do decentralized applications use indexers?
Indexers transform chain data into queryable views suited to application needs, such as ownership histories or searchable activity. They improve usability and performance because raw contract storage and logs are not a general-purpose application database API.
An index is derived state that can lag or be wrong. Track its processed block and canonicality, support replay, and verify critical actions against the authoritative contract when appropriate. A frontend should distinguish “not indexed yet” from “does not exist” rather than making a stale query look like a definitive result.
Web3 Interview Questions and Answers for Intermediate
These answers connect protocol concepts to implementation decisions. Pay attention to version assumptions, replay protection, resource ownership and the difference between a simulated result and an executed state change.
41. How should a frontend handle account and network changes?
Treat a changed account or chain as a change in the authorization and data context. Invalidate affected cached balances, contract instances and prepared requests, then recheck the intended network and account before prompting an action.
A transaction prepared for one chain should not silently be submitted after the user switches networks. Handle events and also validate at the action boundary because events and asynchronous reads can race. Make the current context visible so users can recognize a request that no longer matches their intent.
42. How should contract addresses be managed across environments?
Maintain an explicit mapping from chain identity and deployment version to contract address, ABI and relevant configuration. Validate that the address contains the expected deployment and avoid relying on a token name or copied explorer label.
Separate development, test and production configurations and make accidental cross-environment use fail clearly. Proxy deployments require tracking implementation and administrator details as well as the proxy address. A stable address does not mean stable behavior when an authorized upgrade can change the code it executes.
43. How should a service coordinate transaction nonces?
Use a single coordinated allocation strategy for each sending account and reconcile local records with chain and pending transaction state. Persist the relationship between business operation, nonce, transaction hashes and replacement attempts.
A provider timeout does not establish that submission failed, so inspect known hashes and account state before allocating a fresh operation. Multiple writers using the same account can create gaps or replacements. Consider separate operational accounts or a serialized submission component when concurrency is difficult to coordinate safely.
44. How should a stuck transaction be replaced or canceled?
A replacement competes using the same sender nonce under the network’s transaction-pool policies, usually with sufficient fee changes. A cancellation commonly means submitting another transaction with that nonce; it is a race, not a guaranteed reversal.
The original transaction may already be included or may win before the replacement. Track both hashes and reconcile the canonical result before declaring cancellation. Never promise that a UI cancel button can undo a confirmed action, and distinguish canceling local waiting from canceling the network-level operation.
45. What are the limits of gas estimation?
Gas estimation simulates a request against a particular state and can identify likely execution costs or reverts. It cannot guarantee inclusion, unchanged state or success when the actual transaction executes later.
Use the correct sender, value and calldata, and interpret failures rather than applying an arbitrary large gas limit. State-dependent loops and concurrent changes can alter the path. An estimate that succeeds with a privileged account may conceal an authorization failure for the real caller, so the simulation context must match the intended action.
46. How should an application decode a contract failure?
Use the correct ABI to decode custom errors or revert data when available, and combine that with the transaction context. Distinguish contract rejection from RPC transport failure, insufficient funds, user rejection and timeout.
Do not expose raw internal details as the only user message or claim a decoded error is authoritative when the ABI is uncertain. Preserve diagnostic data for engineers and provide an actionable explanation. If the outcome is unknown, inspect the transaction and state before encouraging a retry that could duplicate an operation.
47. Why can abi.encodePacked be dangerous for signed or hashed messages?
Packed encoding omits some type and length information, so different combinations of dynamic values can produce the same concatenated bytes. Hashing those bytes does not repair the ambiguity in the encoding.
Use an unambiguous typed encoding appropriate to the protocol, such as standard ABI encoding or EIP-712 for structured signatures. Review the complete schema and domain rather than merely choosing a cryptographic hash. A strong hash protects the bytes supplied to it; it cannot distinguish two meanings that were encoded into identical bytes.
48. What problem does EIP-712 solve?
EIP-712 defines typed structured-data hashing and signing with domain separation. It makes the message schema and context explicit and enables wallets to present more meaningful signing information than an opaque byte string.
It does not itself enforce replay protection, expiry or business authorization. The verifier must check those rules and consume the appropriate nonce or identifier. The local example below hashes synthetic data and demonstrates that changing the domain or nonce changes the digest; it does not create a signature or execute an authorization.
JavaScript (ethers 6.17.0) — typed-data hashing without signing
Run this standalone CommonJS file with ethers@6.17.0 available. The synthetic addresses are identifiers for the local hash fixture; no contract is contacted. The repeated hash assertion intentionally shows why a verifier needs stateful replay protection.
49. Which fields help separate a typed-data signing domain?
Common domain fields include a name, version, chain ID and verifying contract, with the exact domain defined by the application’s protocol. They distinguish otherwise identical messages intended for different contexts.
Validate the domain actually used by the verifier and the wallet request. A displayed application name is not a security boundary by itself, and omitting chain or contract binding can enable unintended reuse. Upgrades may also require deliberate version handling so previously issued permissions do not silently acquire a different meaning.
50. How should an application prevent replay of a signed permission?
Bind the permission to its intended domain, action and subject, then enforce a nonce, unique identifier or other consumption rule atomically with execution. Check deadlines and any revocation mechanism according to the protocol.
Merely including a nonce in the signed data is insufficient if the verifier never checks or advances it. Test repeated submission, concurrent attempts and cross-domain reuse. A failed operation’s nonce-consumption policy should be intentional so users and relayers understand whether the same authorization remains usable.
51. How does contract-account signature verification differ from key recovery?
For a conventional key-based signature, a verifier may recover the signer and compare it with an expected address. A contract account can define its own validation policy, commonly exposed through ERC-1271, and return the specified success value.
Do not assume one ECDSA recovery path supports every account. Contract validation can depend on state and may change after owner rotation or policy updates. Handle failures and reverts carefully, and verify at the relevant time and chain context rather than treating an old validation result as permanently valid.
52. What should Sign-In with Ethereum verification check?
Verify the signed message and the relying party’s expected domain, URI, nonce, timing and chain context, using the appropriate account validation method. The nonce should be issued and consumed through a secure session-establishment flow.
Account control is only the authentication input; application authorization and session security remain separate responsibilities. Prevent replay and phishing across origins, expire sessions appropriately and avoid treating a wallet connection as a completed login. A valid signature for another site must not create a session on this one.
53. How do a permit signature and an onchain approval differ?
A permit-style flow uses a signed authorization that another party can submit to update an allowance under the token’s supported standard. A conventional approval is directly submitted as a transaction by the approving account.
Permit can improve user experience, but it still grants spending authority and requires correct nonce, deadline and domain checks. Not every token implements the same permit scheme. Verify the exact interface and account compatibility, and make the spender and amount understandable before asking the user to sign.
54. How should token transfers handle unusual token behavior?
Use suitable reviewed wrappers for supported return-value conventions and define explicit assumptions about fees, rebasing and callbacks. Where the received amount matters, compare relevant balances rather than assuming the requested amount arrived unchanged.
A wrapper cannot make every token economically or operationally compatible. An integration may need to reject unsupported mechanics or account for them deliberately. Test representative behavior and adversarial callbacks, and avoid allowing arbitrary tokens into accounting logic that assumes fixed balances and standard transfer semantics.
55. Why do safe NFT transfers involve receiver callbacks?
Safe transfer mechanisms can check whether a receiving contract supports the expected token-receipt interface, reducing the risk of sending a token to code that cannot handle it. This check involves an external interaction.
Treat the callback as a control-transfer boundary and establish safe state before it occurs. Receiver acceptance does not prove the recipient is trustworthy or that every subsequent action is safe. Test rejection and reentrancy behavior rather than interpreting the word safe as a general security guarantee.
56. How should a contract distinguish ownership from operational roles?
Separate the power to administer the system from narrower permissions such as pausing, updating an oracle or managing a registry. Assign the least authority needed and define who can grant or revoke each role.
A role model adds complexity, so document the permission graph and test transitions as well as ordinary function calls. A restricted operator is not truly restricted if it can grant itself administrator rights. Consider recovery, rotation and accidental loss of authority without introducing an undocumented backdoor.
57. What risks arise from an upgradeable proxy?
A proxy can preserve an address while executing replaceable implementation code, introducing risks around upgrade authorization, initialization and storage compatibility. Users rely on both the current implementation and the governance that can change it.
Review the proxy pattern and upgrade mechanism specifically. An apparently immutable interface can change behavior after an upgrade, and an incorrect storage layout can corrupt existing state. Test upgrades with realistic prior state and verify that implementation and proxy initialization cannot be seized by an unintended caller.
58. Why is storage layout important during upgrades?
An upgraded implementation interprets the proxy’s existing storage according to its own layout. Reordering or changing fields incompatibly can make old values appear as different variables and break balances, roles or configuration.
Use the tooling and conventions appropriate to the chosen upgrade framework, and compare layouts as part of release review. A new implementation compiling successfully says nothing about compatibility with existing deployed state. Exercise a migration from representative old state and assert invariants before and after the upgrade.
59. What is the difference between a constructor and an initializer in a proxy design?
A constructor executes when its own contract is created, while a proxy normally needs initialization of the proxy’s storage through a call path that executes implementation logic in that context. Initialization must be authorized and protected against unintended repetition.
Do not assume the implementation’s constructor populated the proxy’s owner or roles. Protect implementation initialization as required by the framework as well, and test both uninitialized and already-initialized cases. Deployment sequencing and atomic setup matter because an exposed initialization window can be exploitable.
60. How should pause mechanisms be designed?
Define exactly which operations pause and which remain available, such as safe withdrawals or administrative recovery. The mechanism should address a stated incident scenario and have explicit authority, monitoring and unpause conditions.
A global pause can limit damage but also trap users or create a powerful censorship capability. Test partial workflows and interactions with external protocols rather than assuming every operation can stop safely. Communicate the power accurately and avoid presenting a pausable system as having no privileged operator.
61. What should a multisignature policy consider beyond its threshold?
Evaluate signer independence, device and organizational separation, recovery procedures, transaction review and the consequences of signer loss or collusion. A three-of-five threshold is weak if all five keys depend on the same compromised workstation or administrator.
Review modules and delegated permissions that may bypass the ordinary threshold. Test routine rotation and emergency procedures without using real assets in interview exercises. The operational process must make signers understand the actual calldata and target, not merely approve a familiar-looking request.
62. How do timelocks change governance risk?
A timelock delays eligible administrative actions, creating time for monitoring and response before execution. Its value depends on what actions are covered, who can schedule or cancel them and whether users have a realistic exit or mitigation path.
A delay does not make a malicious upgrade safe, especially if another role can bypass it. Analyze emergency exceptions and interactions with multisignature authority. Monitoring must decode the scheduled action and notify the right people; an unnoticed delay provides little practical protection.
63. How should oracle freshness be validated?
Check the timestamp and validity conditions defined by the oracle interface and the application’s acceptable age policy. Also validate units, scale, sign and any network-specific conditions relevant to the feed.
A nonzero price can still be stale or refer to the wrong asset. Define what the contract does when the feed is unavailable or outside bounds: revert, pause a subset of actions or use a carefully justified fallback. A fallback to an easily manipulated market price can make the failure policy more dangerous than stopping.
64. How can price manipulation affect contract logic?
If a contract uses a manipulable observation to value collateral, execute a trade or grant credit, an attacker may change that observation long enough to exploit the dependent action. The vulnerability is the mismatch between the price’s trust assumptions and the operation’s value at risk.
Analyze liquidity, observation windows, update timing and the cost of manipulation. A time-weighted price can reduce some attacks but has its own lag and market assumptions. Test the whole economic sequence, not just whether the oracle returns a syntactically valid number.
65. What is slippage protection?
Slippage protection constrains the acceptable execution result, such as a minimum output or maximum input, relative to the user’s intent. It helps reject an unfavorable execution when state changes before inclusion.
It does not guarantee the best price or eliminate front-running and sandwich risk. Set bounds and deadlines based on the user’s informed choice, and show the actual assets and units. Overly permissive defaults can make the control ineffective, while excessively tight bounds can cause frequent paid failures.
66. What is maximal extractable value?
MEV refers to value available through transaction inclusion, exclusion or ordering beyond ordinary execution fees. It arises because ordering and state changes can affect economic outcomes.
For application design, identify whether pending user actions reveal profitable opportunities and what constraints limit exploitation. Private submission or batching may change exposure but introduces other trust and availability assumptions. Avoid promising that one routing choice eliminates every form of ordering risk, especially across multiple contracts and chains.
67. How should a commit-reveal scheme be evaluated?
A commit-reveal scheme first publishes a commitment and later reveals the value and required secret material. It can hide an input temporarily and bind the participant to a choice, provided the encoding and randomness are appropriate.
Analyze non-reveal behavior, deadlines, incentives and who learns what at each stage. A participant may refuse to reveal after seeing others’ values, and a low-entropy secret may be guessed from its commitment. The protocol needs a plan for these cases rather than treating hashing alone as a complete fairness solution.
68. Why is block data usually unsuitable as secure randomness?
Publicly observable or influenceable block fields can be predicted or manipulated within the protocol’s constraints. If valuable outcomes depend on them, an actor may gain an advantage through timing, ordering or selective participation.
Use a randomness mechanism whose assumptions match the value at risk and consider withholding or delayed fulfillment. Even a cryptographically sound randomness source needs correct request binding and consumption logic. Test that a user cannot request repeatedly and keep only favorable outcomes when that would violate the intended game or allocation rule.
69. How should event processing handle duplicates?
Give each observed log an identity tied to its chain and block context, transaction and log position, then make derived updates idempotent. Persist processing checkpoints atomically with the corresponding derived state where practical.
A duplicate delivery should not credit an account twice. However, deduplication must also accommodate reorgs and replay: treating a displaced log as permanently consumed can prevent correct rebuilding. Keep canonicality and processing state explicit rather than using one irreversible “seen transaction” flag for every purpose.
70. How should an indexer recover from a reorganization?
Detect that the stored block ancestry no longer matches the canonical chain, find the common ancestor and reverse or rebuild affected derived state before processing the replacement branch. Retain enough block and log identity to perform this reconciliation.
External side effects need separate treatment. An email can be marked provisional, but an irreversible payout requires stronger settlement policy. Test a synthetic fork with conflicting events and verify that balances and histories match the new canonical branch, not merely that the indexer resumes advancing its block number.
71. How should several contract reads use a consistent state snapshot?
Read against the same explicit block context when the results must be interpreted together. Otherwise, successive latest-state calls may observe different blocks and produce a combination that never existed at one point in time.
Where supported, a block hash can make the intended snapshot more precise than a moving label. Handle unavailable or reorganized snapshots and provider limitations. A multicall can improve consistency and efficiency, but examine its execution context and failure behavior rather than assuming every batching mechanism has identical semantics.
72. How should large integers cross a JavaScript API boundary?
Keep onchain integers as BigInt or exact decimal/hex strings according to the API contract. Do not convert arbitrary uint256 values to JavaScript Number, whose safe integer range is much smaller.
JSON serialization requires deliberate handling because native BigInt is not directly serialized by ordinary JSON.stringify. Define the representation and validate it on receipt. A value that looks reasonable in a UI can already be rounded before signing, so preserve exactness from input parsing through encoding and confirmation display.
73. How should an application choose what data to store onchain?
Store only what the contract must verify or enforce, considering cost, public visibility and long-term persistence. Large documents and personal data often belong elsewhere, with carefully designed commitments or references when appropriate.
A hash can support integrity checking but does not automatically anonymize predictable data or guarantee availability. Decide who retains the original, how users retrieve it and what happens when correction or deletion is required. The architecture should make those limitations explicit before committing data that is difficult to remove.
74. How should content-addressed data remain available?
Maintain explicit retention and replication responsibilities, such as controlled pinning or other durable storage arrangements, and monitor retrieval from the user’s expected access paths. A valid CID is an integrity reference, not a storage service-level agreement.
Test retrieval after one provider fails and track whether all required DAG blocks remain available. Gateways can improve access but add operational dependencies. Preserve the ability to verify retrieved content and avoid confusing a gateway’s successful HTTP response with proof that the intended content was returned.
75. How should mutable names pointing to immutable content be handled?
Separate the immutable content identifier from the mutable naming or registry layer that selects the current version. The update authority and resolution process determine who can redirect users to different content.
Cache with an appropriate freshness policy and show version information when changes matter. A content-addressed document can be immutable while its advertised name points elsewhere tomorrow. Verify both the content integrity and the authority of the pointer, especially for application frontends and token metadata.
76. What should smart-contract unit tests cover?
Exercise successful and rejected calls, boundary values, authorization, emitted events and relevant state transitions. Include callers and contract behaviors that challenge assumptions rather than only the intended happy path.
Use exact assertions for the property under examination, such as an unauthorized write leaving state unchanged. Compilation is not execution evidence, and a high line-coverage percentage does not establish meaningful assertions. Preserve deterministic fixtures and make failure messages identify the violated invariant.
77. How do fuzz tests complement example-based contract tests?
Fuzz tests explore many generated inputs or action sequences, helping uncover cases the author did not enumerate. They are most valuable when paired with clear properties such as conservation, authorization or bounded accounting relationships.
Constrain inputs only according to real preconditions, and avoid filtering away the dangerous cases. Reproduce failures with the recorded seed or minimized example. Fuzzing increases exploration but cannot prove correctness across every external dependency or economic condition, so combine it with focused examples and other analysis.
78. What makes a useful contract invariant?
A useful invariant states a property that must hold across all relevant reachable states or transitions, such as no unauthorized account changing a protected record. It should reflect the actual specification and include assumptions about external components.
Avoid simplistic balance equalities that fail under legitimate forced transfers, fees or rebasing. Define the accounting model precisely and test adversarial sequences. An invariant that always holds because the test never reaches the sensitive operation provides little confidence; verify that the harness exercises meaningful states and can detect a deliberate violation.
79. What does source-code verification on an explorer establish?
Verification can establish a relationship between supplied source, compiler settings and deployed bytecode under the explorer’s process. It improves transparency and helps users inspect the implementation.
It does not establish that the code is safe, audited or governed appropriately. Proxy addresses may require inspecting the active implementation and upgrade authority as well. Preserve exact compiler versions, optimizer settings, linked libraries and metadata so verification is reproducible rather than relying only on a reassuring badge.
Evidence | Supports | Does not alone prove |
|---|---|---|
Successful compilation | Accepted source and generated artifact | Correct executed authorization |
Verified source | Source/settings relationship to bytecode | Security or honest governance |
Scoped audit | Review findings for specified artifacts | Absence of all vulnerabilities |
Passing tests | Observed behavior for exercised cases | Complete economic and integration safety |
80. How should deployment configuration be made reproducible?
Record the compiler version, EVM target, optimizer settings, dependency versions, constructor or initializer arguments and intended chain/address relationships. Keep deployment manifests and verification evidence tied to the reviewed build.
A source file alone may compile to different output under different settings or dependencies. Use controlled release procedures and compare expected bytecode and configuration before activation. Interview examples can demonstrate compilation locally, but should not imply that a compiler check alone validates an actual deployment or its operational permissions.
Web3 Interview Questions and Answers for Experienced
These answers focus on diagnosis and design under uncertainty. Look for explicit authority maps, testable invariants and recovery plans that match the actual contract and network capabilities.
81. How would you map the trust assumptions of a Web3 application?
List each component that can change behavior, withhold service, misreport data or authorize privileged actions. Include contracts, upgrade administrators, wallets, RPC providers, frontends, indexers, oracles and bridges rather than stopping at the consensus layer.
For each assumption, describe the failure consequence and the user’s available response. A contract may remain correct while a compromised frontend requests a harmful approval. The resulting map should guide controls and product claims, making clear which guarantees are cryptographic and which depend on organizations or operational processes.
Identify who can change code, configuration and permissions.
Map the sources of external data and their failure behavior.
Separate chain settlement from frontend and indexer observations.
Document user recovery and exit options for each failed assumption.
82. How would you decide whether to keep a critical operation offchain?
Compare the need for shared verifiability and composability with privacy, latency, cost and correction requirements. Keep an operation offchain when the blockchain cannot meaningfully enforce the relevant truth or when the added persistence creates unacceptable consequences.
A hybrid design can commit to selected results while retaining sensitive processing elsewhere, but it must define who attests to those results and how disputes are resolved. Do not use an onchain hash to imply that the underlying computation or source data was independently verified when it was not.
83. How would you investigate a transaction reported as failed by the frontend?
Separate user rejection, submission failure, provider timeout, pending state, replacement and included execution failure. Gather the chain ID, account, nonce and known transaction hashes, then inspect canonical receipts and relevant contract state through a reliable view.
A timeout can leave the outcome unknown while the transaction succeeds later. Avoid asking the user to repeat the business action until that uncertainty is resolved. Compare the frontend’s cached or indexed state with the chain and preserve enough evidence to identify whether the defect lies in execution, observation or presentation.
84. How would you design a transaction state machine for the user interface?
Represent meaningful states such as awaiting authorization, submitted, pending, included, confirmed according to policy, failed and replaced. Keep unknown outcomes distinct from definitive failure, and reconcile them after reload or provider interruption.
Store the business operation’s relationship to all relevant transaction attempts. A replacement may change the hash without creating a new user intent. Explain fees and settlement uncertainty in plain language, and avoid a progress indicator that reaches “complete” merely because the wallet returned a submission response.
85. How would you prevent duplicate business operations after a submission timeout?
Assign an operation identity and reconcile it with known transactions and contract state before retrying. Where the protocol supports it, enforce idempotency or unique operation consumption onchain rather than relying solely on the frontend remembering a click.
An account nonce prevents replay of one transaction sequence position, but a new transaction with a new nonce can repeat the same business action. Test crash and restart boundaries between signing, submission and receipt persistence. The recovery path must distinguish “not submitted” from “submitted but not yet observed.”
86. How would you assess a proposed contract upgrade?
Review the behavioral change, storage compatibility, initialization, permission changes and effects on existing integrations. Test representative prior state and adversarial paths, and compare the reviewed artifact with the exact implementation proposed for activation.
Evaluate governance as part of the change: who can execute it, what delay applies and what users can do if they object. A technically correct upgrade can still introduce a new trust assumption. Communicate changed guarantees and define rollback or recovery limits without assuming state changes can always be reversed safely.
Compare the proposed artifact with the reviewed build.
Check storage and initialization against existing state.
Exercise authorized, unauthorized and adversarial transitions.
Review governance delay, bypass paths and recovery limits.
87. How would you respond to a suspected compromised administrator key?
Determine the key’s actual permissions and inspect pending and completed privileged actions. Follow the established incident process to restrict remaining authority, rotate or revoke compromised access where possible and preserve evidence.
Do not assume a pause or multisignature automatically covers every path. Check delegated modules, upgrade rights and delayed actions already scheduled. Communicate confirmed facts and uncertainty, and assess whether recovery actions themselves could worsen the situation. Preparation should include rehearsed authority maps and escalation procedures before an incident occurs.
88. How would you evaluate whether a multisignature is meaningfully decentralized?
Examine control independence rather than counting addresses. Determine who holds each signing capability, whether signers share infrastructure or management, and whether modules or recovery paths allow a smaller group to bypass the advertised threshold.
Assess availability as well as compromise resistance. Geographically distributed signers may improve resilience but slow urgent response. Document realistic failure combinations and test rotation procedures. A five-address configuration operated by one person should not be presented as five independent decision-makers.
89. How would you review a cross-chain application’s failure model?
Trace the source action, message verification, relay, destination execution and any acknowledgement or refund path. Identify finality assumptions, replay protection, ordering and what happens when only part of the workflow completes.
There is no general atomic transaction spanning independent chains merely because the UI presents one action. Model delayed, duplicated and out-of-order messages, and verify that recovery cannot mint or release value twice. Explain the bridge’s validator, proof and administrator assumptions separately from each chain’s native security.
90. How would you handle an L2 sequencer outage?
Determine which operations stop, what escape or forced-inclusion mechanisms the specific network provides and how the application obtains reliable state during the outage. Communicate provisional versus settled status and avoid pretending the usual latency guarantees still apply.
Oracle-dependent actions may need network-specific outage and recovery checks, including a grace policy after service resumes. Test the documented path rather than assuming every L2 has equivalent fallback behavior. A working L1 does not automatically mean users can immediately complete every L2 application action.
91. How would you compare two scaling networks for an application?
Compare settlement, proof and data-availability designs alongside sequencer control, upgrade authority, exit mechanisms, tooling, costs and operational history. Evaluate the deployed configuration, because a roadmap can promise guarantees that are not yet active.
Use the application’s requirements to weigh trade-offs. A low-latency game and a high-value settlement workflow may make different choices. Keep fee estimates and throughput claims tied to realistic workloads, and account for bridge and withdrawal complexity rather than comparing only advertised transaction costs.
92. How would you design around data withholding risk?
Identify which data users need to reconstruct state or exit, who must publish it and how availability is verified. Choose a design whose withholding response is acceptable for the application’s risk level.
A validity proof can establish a transition’s correctness without ensuring every user can obtain the underlying data. Analyze committee assumptions, retention windows and recovery procedures separately. Test the operational ability to retrieve required data and avoid claiming that a cryptographic commitment alone guarantees availability.
93. How would you assess an oracle fallback policy?
Evaluate whether the fallback is independent, fresh and resistant to the same failure that affected the primary source. Define when it activates, how values are compared and which operations remain safe under reduced confidence.
A fallback that always returns a number can be worse than a controlled halt. For example, replacing a stale robust feed with a thin spot market may expose the contract to manipulation. Test stale, divergent and unavailable inputs, and document who can alter the policy during an incident.
94. How would you analyze an economic attack that passes all access-control checks?
Model the sequence of permitted actions and the incentives around them. An attacker may exploit pricing, ordering, accounting or liquidity assumptions without calling any forbidden function.
Use adversarial simulations and invariant tests to examine the whole sequence, including interactions with external protocols. A contract can be locally correct while a composed system allows value extraction the designers did not intend. Distinguish a code defect from a flawed economic assumption so the remedy addresses the actual mechanism.
95. How would you evaluate a zero-knowledge claim in a product design?
Ask what statement is proved, which inputs are public or private, who generates and verifies the proof and what setup or cryptographic assumptions apply. A proof system’s name does not establish the application’s privacy guarantees.
Metadata, transaction timing and public outputs may still reveal sensitive information. Circuit correctness and the connection between the proof and the intended action also require review. A validity proof for execution can improve correctness without hiding user activity, so communicate the precise property rather than using zero knowledge as a general privacy label.
96. How would you handle confidential or regulated data requirements?
Start with data minimization and identify what must remain off public infrastructure. Public-chain persistence and replicated history can conflict with correction, deletion or confidentiality requirements, so architecture and legal requirements must be evaluated together for the relevant context.
Encryption and commitments can help specific designs but do not automatically solve key compromise, metadata leakage or predictable-input guessing. Keep policy claims jurisdiction-specific and involve qualified expertise where needed. An engineering interview should assess the candidate’s ability to identify these constraints rather than invite unsupported universal compliance assurances.
97. How would you review a wallet-signing experience for misleading consent?
Compare the displayed request with the exact encoded action, including chain, target, spender, amount, expiry and delegated authority. Test whether the user can distinguish a login message from a transferable or reusable permission.
Readable typed data improves presentation but does not guarantee understanding or honest UI behavior. Consider simulation, clear permission summaries and narrowly scoped requests. Verify cancellation and rejection paths, and ensure a frontend cannot silently substitute a broader authorization after the user reviewed a different intent.
98. How would you secure the frontend supply chain of a decentralized application?
Treat build dependencies, hosting, DNS, release credentials and configuration as security-critical components. A compromised frontend can request harmful transactions even when the deployed contracts have no new defect.
Use controlled builds, reviewed dependency updates, artifact integrity and constrained release access, with monitoring for changed contract targets or signing requests. Content-addressed hosting can help identify an artifact but does not establish that users were directed to the approved identifier. Protect the mutable discovery and naming layer as well.
99. How would you distinguish verified source from an audited system?
Verified source concerns the correspondence between published source and deployed bytecode under specified settings. An audit is a scoped review of particular code and assumptions at a particular point in time; neither is a guarantee of complete safety.
Check whether the deployed implementation, configuration and upgrade state match what was reviewed. Understand excluded dependencies and unresolved findings. Product claims should describe the evidence accurately, and engineering decisions should still include testing, monitoring and incident preparation rather than treating a badge as the end of risk analysis.
100. How would you use formal verification responsibly?
Define properties and assumptions that correspond to the actual contract behavior, then use formal methods to establish those properties within the model. The quality of the specification and environment model is central to the result.
A proof of one arithmetic property does not establish secure governance, correct oracle data or an honest frontend. Review coverage and assumptions alongside the proof and complement it with execution tests and operational analysis. If the model excludes external callbacks, it cannot settle a question about cross-contract reentrancy.
101. How would you make a contract test suite detect false confidence?
Introduce controlled violations of the properties the suite claims to protect and confirm the relevant assertions fail. Inspect coverage of caller identities, boundary values, state sequences and external interactions, not only source-line execution.
A test that deploys a contract and calls every method can still miss an authorization defect if it always uses the owner. Preserve negative controls and verify that failed setup cannot skip assertions silently. Distinguish compiler checks, simulated execution and public-network observations in the evidence report.
102. How would you test reentrancy defenses beyond one withdrawal function?
Create adversarial callees that attempt callbacks into related functions and inspect shared invariants during external interactions. Include token receiver hooks and cross-contract dependencies where the design uses them.
A guard on one entry point may leave another path available, and a read-only observation of inconsistent state can affect another protocol. Test the system’s relevant state relationships rather than merely checking that a named guard exists. Keep the threat model explicit so the test’s limits are understandable.
103. How would you review a contract with unbounded iteration?
Identify whether user-controlled or growing state can make an operation exceed feasible gas limits. Consider both state-changing operations and reads invoked by other contracts, because an apparently harmless view function can still block an onchain workflow.
Use bounded batches, pagination or pull-based designs where appropriate, with clear progress and completion semantics. Test large realistic states and adversarial growth. A loop that works with ten test accounts may permanently strand an administrative or distribution operation after the dataset grows.
104. How would you design a pull-payment workflow?
Record each recipient’s entitlement and let recipients claim through an isolated operation, rather than forcing one batch to transfer to every recipient. This can reduce the impact of one recipient rejecting payment or consuming excessive resources.
The claim path still needs authorization or recipient binding, safe accounting and reentrancy analysis. Define expiry and recovery policies explicitly, and avoid a design where an administrator can redirect claims unexpectedly. Pull-based execution changes failure isolation; it does not eliminate the need to secure each transfer.
105. How would you handle token accounting with fees or rebasing?
Define whether the application tracks nominal units, actual received balances or shares of an underlying pool, then ensure every transition follows that model. Fees and rebasing can invalidate assumptions that balances change only through the application’s own transfers.
Measure relevant balance deltas or use an appropriate share-accounting design, and test rounding and extreme cases. Some protocols should reject unsupported tokens rather than add ambiguous accounting. Document which token behaviors are accepted and how users’ entitlements respond to supply or balance changes outside their direct control.
106. How would you assess rounding in a financial smart contract?
Identify the units and precision of each intermediate value and specify the intended rounding direction for each operation. Integer division truncation can systematically favor one party or accumulate value across repeated actions.
Test small amounts, boundary values and repeated deposit-withdraw cycles, not only large representative trades. Use suitable full-precision arithmetic where required and review overflow assumptions. A mathematically equivalent rearrangement can change integer results, so explain the economic consequence of the chosen implementation rather than treating rounding as cosmetic.
107. How would you make an indexer rebuild trustworthy?
Retain the source range, chain identity, block ancestry and transformation version, then replay deterministically into a clean target. Compare derived totals and representative records with independent contract observations at a consistent block context.
Test reorg handling and schema migrations as part of rebuilding, and avoid mixing old and new transformation logic without a version boundary. A rebuilt database that has the right row count can still assign ownership incorrectly. Use domain invariants and sampled exact comparisons to establish meaningful confidence.
108. How would you monitor a Web3 application beyond node uptime?
Monitor user-visible transaction completion, contract events and state invariants, privileged actions, oracle freshness, indexer lag and dependencies such as RPC and storage. Tie alerts to consequences and response ownership.
A node can be healthy while the application points to the wrong contract or an indexer stops advancing. Distinguish expected traffic changes from failures and retain chain/block context for diagnosis. Monitoring should cover both integrity and availability without exposing signing material or sensitive user data in logs.
109. How would you plan recovery when onchain actions cannot simply be rolled back?
Identify which state transitions are irreversible under the application’s settlement assumptions and design compensating actions or controlled migration paths where appropriate. Recovery may require a new transaction, governance action or user participation rather than restoring a database snapshot.
Do not promise compensation that the contract or organization cannot provide. Rehearse incident scenarios and document authority, communication and evidence requirements. Offchain services can often be restored independently, but their rebuilt state must reconcile with the accepted chain history rather than overwrite it with a preferred past.
110. How would you evaluate a key-recovery design?
Assess who can initiate recovery, what evidence or approvals are required, what delay applies and how the legitimate user can detect and contest an unauthorized attempt. Recovery changes the account’s trust model and may be its weakest authorization path.
Balance compromise resistance with realistic loss scenarios. A design that is impossible to recover may be unacceptable for the product, while an easy support override may undermine user control. Test guardian loss, collusion and stale contact information without assuming the happy-path recovery procedure proves resilience.
111. How would you prevent replay across chains and deployments?
Bind authorizations to the intended chain and verifying deployment through the protocol’s domain or equivalent context, then enforce application-level consumption. Review whether upgrades, forks or cloned deployments preserve or change the intended validity scope.
A chain identifier alone does not distinguish two contracts on that chain, and a contract address alone may recur elsewhere. Test cross-chain and cross-contract negative cases. Explicitly decide whether any permission is intentionally portable; accidental portability is an authorization defect, not a composability feature.
112. How would you evaluate account abstraction or delegation for a product?
Examine the authorization model, bundler or relayer dependencies, sponsorship policy, recovery and execution limits of the specific mechanism. Distinguish contract-account flows from EIP-7702 delegation rather than treating account abstraction as one uniform protocol.
Convenience features such as batching or sponsored fees introduce policy decisions about who may execute what and who pays. Test replay, revocation, failure accounting and malicious delegates. The user should understand the scope and persistence of authority, especially when one signature can affect future account behavior.
113. How would you analyze a sponsored-transaction service?
Define who qualifies for sponsorship, which operations are allowed and how the sponsor bounds cost and abuse. Verify the authorization independently of untrusted client fields and account for failures that still consume resources.
Rate limits alone may not prevent an attacker from creating many identities. Use appropriate budgets, operation constraints and monitoring, and ensure a sponsor cannot unexpectedly change the user’s intended call. Separate transaction execution success from billing or reimbursement logic so one does not silently conceal failure in the other.
114. How would you choose between public and private transaction submission?
Compare exposure to public pending-transaction observation with the private route’s trust, censorship, availability and information-leakage assumptions. The best choice depends on the operation’s ordering risk and the network’s available infrastructure.
Private submission is not a universal confidentiality or execution guarantee. Understand fallback behavior: automatically rebroadcasting publicly may defeat the original protection. Track inclusion and expiry, and make the application’s retry policy consistent with the user’s slippage and deadline constraints.
115. How would you review governance voting beyond token balances?
Analyze voting power acquisition, delegation, snapshots, proposal thresholds, quorum, execution authority and emergency paths. A vote’s apparent legitimacy can be undermined by concentration, temporary voting power or an executor with broader discretion than participants expect.
Test the sequence from proposal through execution, including cancellations and failed calls. Explain whether governance can change user entitlements or upgrade critical code. A transparent vote record does not by itself establish fair participation or safe outcomes; those are design and institutional questions as well as technical ones.
116. How would you handle an externally discovered contract vulnerability?
Provide a clear reporting channel and a process to assess reproducibility, affected deployments and potential impact without exposing users to additional harm. Preserve evidence and coordinate remediation according to the system’s actual administrative capabilities.
Avoid publicizing exploit details before an appropriate response is ready, while keeping stakeholders informed through the agreed process. Verify fixes against the original failure and related invariants, and inspect whether the vulnerability may already have been exercised. A patch to source code is insufficient if deployed contracts remain unchanged.
117. How would you review AI-generated Solidity or signing code?
Check the intended property, supported versions, authorization, units, external calls and error paths independently of how plausible the code looks. Generated code may use outdated patterns, confuse message hashing with signature validation or omit nonce consumption.
Require reproducible compilation and meaningful negative execution tests for the relevant claims. Compare dependencies and APIs with primary documentation, and do not interpret a generated explanation as evidence. Keep ownership with the engineer who can justify the behavior and identify what remains untested.
118. What should a practical Web3 interview exercise assess?
Use a small contract or transaction-flow problem with a clear business requirement, then introduce an unauthorized caller, changed chain or uncertain submission outcome. Ask the candidate to explain the state transition and evidence needed to declare success.
A useful exercise assesses exact units, trust boundaries, error handling and test design rather than requiring a public deployment or real assets. Compiler output and local fixtures can support the discussion, but the candidate should distinguish those checks from executed contract behavior and production readiness.
119. How should an engineer communicate the limits of a Web3 prototype?
State exactly which components were implemented and tested, the versions and network assumptions, and which claims remain unverified. Separate local compilation, hashing, simulated execution and real integration evidence.
For example, a typed-data hash test can demonstrate domain separation but cannot establish correct wallet presentation or onchain nonce enforcement. Clear limits help the next engineer choose meaningful tests. Avoid both exaggerated safety claims and vague disclaimers that fail to identify the actual missing evidence.
120. What would a strong Web3 architecture proposal demonstrate?
It would connect a justified product need to explicit trust assumptions, exact authorization and state transitions, suitable data placement and a realistic recovery model. It would also show how tests and operational evidence establish the properties users rely on.
A strong proposal can explain why some components remain centralized, what administrators can change and how failures are detected and handled. The goal is a defensible system whose guarantees match its implementation, not the maximum number of blockchain components or the broadest claim of decentralization.
Web3 Documentation and Further Reading
These primary sources support further study of Ethereum-oriented application engineering and content-addressed systems. Check the exact chain, deployed implementation, compiler target and library version before applying a pattern; standards and verified source do not by themselves establish application security.
Similar Posts
