A blockchain solutions architect designs end-to-end systems for clients and products, deciding whether blockchain fits, which network or framework to use, what data goes on-chain, and how it integrates with existing systems. In India this role is common in consulting and IT services firms working with banks, supply chain and government projects, balancing security, compliance, cost and scalability. Clear documentation and client communication are a large part of the job.
3 QUESTIONS FREESign up to unlock the full question bank and track your progress.Unlock every question and answer, then continue practising company-wise and package-wise.
The trilemma says a blockchain finds it hard to maximise decentralisation, security and scalability at the same time on a single layer. Raising block size or using few validators increases throughput but reduces decentralisation. Ethereum's answer is a rollup-centric roadmap: keep the base layer decentralised and secure, and move execution to Layer 2 rollups that post data back to Layer 1. Many high-throughput chains instead accept fewer, more powerful validators.
02
Write a Python function that computes a Merkle root from a list of transactions.
Hash leaves, then hash pairs until one remains, duplicating the last hash when a level is odd (Bitcoin style).
import hashlib
def h(b):
return hashlib.sha256(b).digest()
def merkle_root(txs):
level = [h(t.encode()) for t in txs]
while len(level) > 1:
if len(level) % 2:
level.append(level[-1])
level = [h(level[i] + level[i+1]) for i in range(0, len(level), 2)]
return level[0].hex()
print(merkle_root(['tx1', 'tx2', 'tx3']))
03
How do you deploy a contract to a Layer 2 testnet with Foundry?
Set the RPC URL and a deployer key, then use forge create or a script, and verify the source on the explorer.
export RPC_URL=https://sepolia.l2-example.org
export PRIVATE_KEY=0x... # testnet key only
forge create src/Counter.sol:Counter \
--rpc-url $RPC_URL --private-key $PRIVATE_KEY --broadcast
# Scripted deploy with verification
forge script script/Deploy.s.sol --rpc-url $RPC_URL \
--broadcast --verify
Use a keystore via cast wallet import instead of raw keys for anything real.
04
How do you read a contract and send a transaction with viem?
Credit deposits only after enough confirmations for the chain's risk profile, and on Ethereum prefer waiting for finalized or at least safe block tags rather than the latest block. Make the deposit indexer reorg-aware: track block hashes, detect when a parent hash changes, roll back credits from orphaned blocks and reprocess. Scale required confirmations with deposit size, and alert on unusually deep reorgs on smaller chains, which can signal a 51 percent attack.
06
Design the custody setup for an exchange's hot and cold wallets.
Keep a small float, around a few percent of assets, in hot wallets for withdrawals, secured by HSMs or MPC with rate limits, address allowlists and automated monitoring. Keep the rest in cold storage: air-gapped or multisig/MPC with keys held by different officers in different locations, plus time delays. Refill hot wallets through a manual, multi-approver process. Add proof of reserves, regular key ceremonies, insurance, and incident runbooks for freezing withdrawals if anomalies appear.
07
Tell me about working with product, legal or compliance teams on a blockchain feature.
Situation: we planned a token reward feature for Indian users, and legal raised VDA tax and securities concerns. Task: as tech lead I had to find a compliant design. Action: I ran workshops to understand their constraints, proposed non-transferable points that convert to vouchers, and documented the data flow for compliance. Result: we launched a month later than planned but with sign-off from all teams, and avoided a costly redesign after launch.
08
How do you manage deployer private keys in a CI/CD pipeline?
Never commit keys or put them in plain environment files. For testnets, use CI secret storage with restricted access. For mainnet, avoid hot keys in CI entirely: have CI produce a transaction proposal that signers approve in a multisig, or use a cloud KMS or HSM signer so the key never leaves secure hardware. Separate deployer and admin roles, transfer ownership to a multisig immediately after deployment, and log and review every deployment.
09
What is signature malleability and how is it prevented?
For any valid ECDSA signature (r, s), the value (r, n - s) is also valid for the same message. If code uses a signature as a unique ID, for example to mark it as used, an attacker can submit the flipped version and replay it. Ethereum's EIP-2 requires s to be in the lower half of the curve order for transactions. In contracts, use a library like OpenZeppelin ECDSA that enforces low s, and track nonces instead of signatures.
10
How would you implement Sign-In with Ethereum on a web back-end?
Follow EIP-4361. The server generates a random nonce and stores it in the session. The front-end builds a SIWE message with domain, address, statement, URI, chain ID, nonce and issued-at time, and the wallet signs it. The server verifies the signature with a SIWE library, checks domain, nonce, expiry and chain, then issues a session cookie or JWT and deletes the nonce. For smart contract wallets, verify via ERC-1271 isValidSignature.
11
How do you handle unclear or changing requirements from a client?
Situation: a client asked for a marketplace dApp but kept changing royalty and fee rules. Task: deliver without endless rework. Action: I wrote a short spec with examples and edge cases, got sign-off, and made fees configurable parameters with limits instead of hard-coded logic. Changes went through a simple change log with impact estimates. Result: we delivered in eight weeks, and later fee changes needed only a governance transaction, not a redeployment.
A multisig wallet is a smart contract, such as a Safe, that needs M of N owner signatures to execute a transaction; rules are visible on-chain and easy to audit, but every action costs extra gas and works per chain. An MPC wallet splits one private key into shares held by different parties who jointly produce a normal signature; it looks like a regular address, works on any chain and allows key rotation, but the security depends on the off-chain implementation.
EIP-4844, shipped in the Dencun upgrade in March 2024, added blob-carrying transactions. Blobs are large data chunks of about 128 KB that rollups use to post batch data, priced in a separate fee market and pruned by nodes after roughly 18 days. Contracts cannot read blob contents, only their KZG commitments. This cut L2 data costs dramatically. Later upgrades raised blob capacity, and PeerDAS in the Fusaka upgrade lets nodes sample data instead of downloading every blob.
14
What are Delegated Proof of Stake and Proof of Authority?
In Delegated Proof of Stake, token holders vote for a small set of block producers who validate on their behalf, giving high throughput but more centralisation. In Proof of Authority, a fixed set of known, reputable validators sign blocks; their identity, not stake, is at risk. PoA, often via Clique, IBFT or QBFT, suits private and consortium EVM networks and some testnets, where participants are known and fast, predictable block times matter more than open participation.
15
What is the difference between optimistic rollups and zk-rollups?
Optimistic rollups assume batches are valid and allow a challenge window, typically about seven days, during which anyone can submit a fraud proof; this makes them EVM-compatible and simpler but slows native withdrawals. Zk-rollups submit a validity proof with each batch, so L1 verifies correctness mathematically and withdrawals finalise once the proof is accepted. Zk proving is computationally heavy and EVM equivalence was harder, though zkEVMs have matured a lot by 2026.
16
How do you verify a signed message inside a Solidity contract?
Recompute the message hash, add the Ethereum signed message prefix, recover the signer and compare it.
import {ECDSA} from '@openzeppelin/contracts/utils/cryptography/ECDSA.sol';
import {MessageHashUtils} from '@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol';
function verify(address signer, uint256 amount, uint256 nonce, bytes calldata sig) public view returns (bool) {
bytes32 h = keccak256(abi.encode(address(this), block.chainid, amount, nonce));
bytes32 eth = MessageHashUtils.toEthSignedMessageHash(h);
return ECDSA.recover(eth, sig) == signer;
}
Track used nonces to block replays.
17
What is finality, and how does probabilistic finality differ from deterministic finality?
Finality is the guarantee that a confirmed transaction will not be reversed. In proof of work, finality is probabilistic: each new block on top makes reversal exponentially less likely, so exchanges wait for several confirmations. In BFT-style and Ethereum proof of stake, finality is economic and deterministic: once two-thirds of stake attests to a checkpoint, reverting it would require burning at least one-third of all staked ETH. Ethereum finalises in about two epochs, roughly 13 minutes.
18
A user's transaction has been pending for an hour. How do you troubleshoot it?
First check it on a block explorer: if it is not found, it was never broadcast. If pending, the fee is probably below current market rates, or an earlier transaction with a lower nonce is stuck and blocking it. On Ethereum you fix it by sending a replacement with the same nonce and a higher max fee and priority fee, or cancel by sending zero ETH to yourself with that nonce. Then make the wallet estimate fees dynamically.
19
A product team wants to store user documents and personal details directly on a public chain. What do you advise?
Do not put personal data on a public chain. Data there is permanent, public and replicated globally, which conflicts with the right to erasure under India's DPDP Act and GDPR, and storage is extremely expensive. Store documents encrypted in off-chain storage, keep only a salted hash or commitment on-chain for integrity, and control access through the application. If the data must be deleted, delete the off-chain copy and the encryption key; the hash alone reveals nothing.
20
What are zero-knowledge proofs, and how do zk-SNARKs and zk-STARKs differ?
A zero-knowledge proof lets a prover convince a verifier that a statement is true without revealing why, for example proving a transaction is valid without exposing the details. zk-SNARKs have very small proofs and cheap verification, but many schemes need a trusted setup and rely on elliptic curves. zk-STARKs need no trusted setup, use hash-based cryptography considered post-quantum safe, but produce larger proofs. zk-rollups use them to prove batches of transactions to Ethereum.
21
Your protocol is being exploited right now. What do you do?
Act fast with a prepared runbook. Pause affected contracts through the guardian or multisig, and disable front-end actions. Gather the core team and security partners in a war room. Trace the attack transactions to understand the bug and estimate losses, and check whether a white-hat rescue of remaining funds is needed. Communicate publicly with facts and no speculation, contact exchanges and bridges to flag stolen funds, then fix, audit the fix and publish a post-mortem.
22
What is a Merkle Patricia Trie and why does Ethereum use it?
A Merkle Patricia Trie combines a Patricia (compressed prefix) trie with Merkle hashing. Ethereum uses it to store world state, account storage, transactions and receipts, with each root stored in the block header. It allows efficient insert, update and lookup by key, and any value can be proven against the root with a proof. Its weakness is large proof size, which is why Ethereum researchers plan to move to Verkle or binary hash trees for stateless clients.
23
How do you handle a user on the wrong network in your dApp?
Use contract.on for live events and queryFilter for history.
const abi = ['event Transfer(address indexed from, address indexed to, uint256 value)'];
const token = new Contract(TOKEN, abi, provider);
token.on('Transfer', (from, to, value, event) => {
console.log(from, to, value.toString(), event.log.blockNumber);
});
const filter = token.filters.Transfer(null, MY_ADDRESS);
const past = await token.queryFilter(filter, -5000); // last 5000 blocks
console.log(past.length);
Use a WebSocket provider for live events, and page large ranges because providers limit block spans.
25
How do you read the latest finalized block with ethers.js, and why use it?
Pass the block tag to getBlock. The finalized tag returns the latest block that Proof of Stake has finalised, which cannot be reverted without slashing a third of stake.
import { JsonRpcProvider } from 'ethers';
const provider = new JsonRpcProvider(process.env.RPC_URL);
const latest = await provider.getBlock('latest');
const safe = await provider.getBlock('safe');
const finalized = await provider.getBlock('finalized');
console.log(latest.number - finalized.number); // usually about 64-96
Use finalized for deposits and accounting; use latest for UI updates.
// script/Deploy.s.sol
pragma solidity ^0.8.24;
import {Script, console} from 'forge-std/Script.sol';
import {Counter} from '../src/Counter.sol';
contract Deploy is Script {
function run() external returns (Counter c) {
vm.startBroadcast();
c = new Counter();
vm.stopBroadcast();
console.log('Counter deployed at', address(c));
}
}
# Run it with an encrypted keystore account
forge script script/Deploy.s.sol --rpc-url $RPC_URL \
--account deployer --broadcast --verify
Broadcast output in the broadcast folder records addresses for later scripts.
27
You are asked to design a cross-chain bridge. What are the main risks and design choices?
Bridges hold large pooled funds, so they are top hacking targets. Main risks are compromised validator or multisig keys, faulty message verification, and replay of messages across chains. Prefer verification based on light clients or zk proofs over a small trusted multisig. Use rate limits, per-transfer caps, pausing, monitoring of mint-versus-lock balances, and a delay for large transfers. Get multiple audits, run a bug bounty, and consider established messaging protocols instead of building from scratch.
28
Design a back-end relayer so users can make transactions without holding gas.
Users sign an EIP-712 meta-transaction or an ERC-4337 UserOperation. The relayer validates the signature, checks business rules and rate limits per user, then submits it, paying gas from a hot wallet or via a paymaster. Contracts must verify the original signer, using ERC-2771 trusted forwarders or account abstraction. Manage nonces carefully with a queue, replace stuck transactions, keep the relayer wallet funded and monitored, and cap daily sponsorship to prevent abuse.
29
Your target users in India have never used crypto wallets. How do you design onboarding?
Hide crypto complexity. Offer login with phone or email using embedded or smart contract wallets, so no seed phrase is needed at first. Sponsor gas with a paymaster so users need no tokens. Show amounts in rupees and plain language, support regional languages, and explain actions in simple terms. Provide account recovery via passkeys or guardians, and let advanced users export to self-custody later. Ensure KYC and tax requirements are clear where money is involved.
30
How do you test against real mainnet contracts using a fork?
Anvil or Foundry tests can fork a live chain at a block, so you interact with real tokens and protocols locally.
# Start a local fork
anvil --fork-url $MAINNET_RPC --fork-block-number 21000000
# Or fork inside a test
function setUp() public {
vm.createSelectFork(vm.envString('MAINNET_RPC'), 21000000);
}
# Give yourself tokens or impersonate a whale
deal(address(usdc), alice, 1_000e6);
vm.prank(whale);
Pinning the block number keeps results reproducible and makes RPC caching effective.
31
Four organisations are building a private EVM network. Which consensus would you pick: Raft or QBFT?
Raft is crash fault tolerant: fast and simple, but it assumes no node lies, so it fits when all members trust each other's infrastructure. QBFT is Byzantine fault tolerant and tolerates f malicious nodes out of 3f+1, so with four validators it survives one bad actor and gives immediate finality. Since the organisations are separate businesses that may not fully trust each other, I would choose QBFT and run at least four validators, ideally more.
32
Your fantasy sports contract needs live match scores. How do you get that data on-chain?
Smart contracts cannot call web APIs, so use an oracle. Options include a decentralised oracle network such as Chainlink Functions to fetch from several sports APIs and aggregate, or an optimistic oracle where results are proposed and can be disputed. Settle only after the match result is final, use multiple data sources, add a dispute window for high-value pools, and handle cancelled matches. Avoid a single back-end key posting results, which is a central point of failure.
33
A group of banks wants a shared KYC ledger. Would you choose a public chain, a Layer 2 or Hyperledger Fabric?
For shared KYC among regulated banks I would lean to a permissioned framework such as Hyperledger Fabric or a private EVM network. Members are known, data is confidential, and regulators expect access control and data residency in India. Fabric channels and private data collections restrict who sees what, and Raft ordering gives fast finality without gas fees. A public chain or L2 fits only if we need open verification, and even then only hashes and attestations would go on it.
34
Your staking validator is missing attestations and losing rewards. How do you investigate?
Check that both execution and consensus clients are synced and peering well, since low peer count or a lagging execution client causes missed duties. Look at system clock sync through NTP, CPU, memory and disk I/O, as slow disks often cause delays. Review client logs and metrics in Grafana, check for pending client upgrades before a fork, and verify network ports are open. Never start a second copy of the same validator key as a fix, because that causes slashing.
35
What is MEV and what is proposer-builder separation?
MEV, maximal extractable value, is profit a block producer or searcher earns by including, excluding or reordering transactions, for example arbitrage, liquidations and sandwich attacks on swaps. On Ethereum, most validators use MEV-Boost, where specialised builders assemble profitable blocks and bid for them through relays, separating block building from proposing. This spreads MEV revenue to validators but concentrates building power. Enshrined PBS and inclusion lists are being researched to reduce censorship risk.
36
After a transaction is confirmed, your front-end still shows old data. How do you fix it?
The UI is probably reading cached results or a lagging RPC node. After tx.wait() resolves, explicitly refetch or invalidate the relevant queries, for example with wagmi or TanStack Query invalidation. Show optimistic updates while pending. If you use an indexer, it may lag by a few blocks, so poll until it reaches the receipt's block number. Use the same RPC endpoint for writes and immediate reads, and avoid long caching for balances.
37
Tell me about a technical decision you made where you had to balance trade-offs.
Situation: our loyalty-points product needed on-chain points but users would not pay mainnet fees. Task: pick a chain. Action: I compared three rollups and a sidechain on fees, security model, wallet support and bridge maturity, built a quick benchmark, and wrote a one-page decision record with risks. Result: we chose a rollup with live fraud proofs, cut per-transaction cost by over 95 percent, and documented a migration path if our requirements changed.
38
What are state channels, such as the Lightning Network?
A state channel locks funds in an on-chain contract or multisig between parties, who then exchange many signed off-chain updates and settle only the final state on-chain. Lightning on Bitcoin links channels into a network so payments route through intermediaries using hashed timelock contracts. Channels give instant, nearly free payments but need participants to be online or use watchtowers, and they lock liquidity, so they suit repeated payments between known parties rather than general smart contracts.
39
What are seed phrases and HD wallets (BIP-39, BIP-32, BIP-44)?
BIP-39 encodes random entropy as a 12 or 24 word mnemonic, which is turned into a binary seed. BIP-32 defines hierarchical deterministic wallets that derive a tree of key pairs from that seed. BIP-44 standardises the derivation path, for example m/44'/60'/0'/0/0 for the first Ethereum account. So one backed-up seed phrase can restore unlimited addresses across chains. Whoever knows the phrase controls every derived account, so it must never be stored online.
40
What is the difference between an execution client and a consensus client, and why does client diversity matter?
Since the Merge, an Ethereum node runs two pieces of software. The execution client, such as Geth, Nethermind, Besu, Erigon or Reth, runs the EVM, holds state and handles transactions. The consensus client, such as Lighthouse, Prysm, Teku, Nimbus or Lodestar, runs Proof of Stake. They talk over the Engine API. Client diversity matters because a bug in a client used by over two-thirds of validators could finalise an invalid chain and cause mass slashing.
Frequently asked questions
What does a Blockchain Solutions Architect do?
A blockchain solutions architect designs end-to-end systems for clients and products, deciding whether blockchain fits, which network or framework to use, what data goes on-chain, and how it integrates with existing systems. In India this role is common in consulting and IT services firms working with banks, supply chain and government projects, balancing security, compliance, cost and scalability. Clear documentation and client communication are a large part of the job.
Which skills are tested in a Blockchain Solutions Architect interview?
Expect questions on Solution design, Permissioned networks, Layer 2 selection, Key management, Stakeholder communication. Most rounds also ask you to explain a project and solve one practical problem live.
How do I prepare for a Blockchain Solutions Architect interview?
Revise Blockchain Fundamentals, Consensus and Scaling, Cryptography for Blockchain, dApp Development first using the topic sheets, practise the questions on this page aloud, then do one full mock interview to practise timing.