Curated interview practice questions with answers. These are practice scenarios, not a verified list of past interview questions.
About Visa hiring for Blockchain roles
Visa operates a global card payments network connecting consumers, merchants, banks and governments. Its Bengaluru technology centre works on payment processing, risk, tokenisation and data platforms. It hires in India for software engineers, QA and automation engineers, data engineers, data scientists and analysts. Many teams support global products from India.
For Blockchain roles, this Visa practice set focuses most on Cryptography for Blockchain (6), dApp Development (5), Consensus and Scaling (4), Blockchain Fundamentals (4). It has 5 easy, 16 medium, 9 hard questions, so you can start easy and work up to the harder ones.
Company type
Fintech
Headquarters
San Francisco, California, USA
Main India offices
Bengaluru, Mumbai
Visa Blockchain interview process
Online coding assessment
Technical round 1
Technical round 2
Hiring manager round
HR round
Typical pattern based on public candidate experiences. Rounds vary by role, team and year.
Solved for VisaStart practicing
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.
✓ 3 questions free • Unlock the rest in seconds
01
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.
02
Write a simple Proof of Work loop in Python with a difficulty setting.
The miner increments the nonce until the hash starts with the required number of zero hex digits.
import hashlib
def mine(data, difficulty=4):
prefix = '0' * difficulty
nonce = 0
while True:
h = hashlib.sha256(f'{data}{nonce}'.encode()).hexdigest()
if h.startswith(prefix):
return nonce, h
nonce += 1
print(mine('block-1: A pays B 5'))
Each extra zero makes mining about 16 times harder, while verifying still needs one hash.
03
What is ECDSA and why does Ethereum use the secp256k1 curve?
ECDSA is the Elliptic Curve Digital Signature Algorithm. It gives strong security with short keys: a 256-bit key is roughly as strong as a 3072-bit RSA key, which keeps transactions small. Bitcoin and Ethereum use the secp256k1 curve, whose simple structure allows efficient computation. A signature has values r and s plus a recovery id v, which lets nodes recover the signer's public key from the signature, so the sender address need not be included separately.
04
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.
05
Calculate impermanent loss when one token's price doubles.
Formula: IL = 2 x sqrt(r) / (1 + r) - 1, where r is the price ratio change.
For r = 2: sqrt(2) = 1.414, so IL = 2 x 1.414 / 3 - 1 = -0.057, about 5.7 percent.
Example: deposit 1 ETH plus 3,000 USDC when ETH is 3,000 (6,000 dollars). ETH goes to 6,000. Holding would be 9,000 dollars; the pool position is worth about 8,485. Fees earned must exceed the 515 dollar gap for providing liquidity to beat holding.
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
Write a basic voting contract using a struct, mapping and event.
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.
09
Your exchange credited a deposit, but the block was later dropped in a reorg and the funds vanished. How do you prevent this?
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.
10
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.
11
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.
Use a specific, sincere answer. For example: I first got interested when I built a small token contract in college and saw that code could hold and move value without a middleman. Since then I have completed Solidity projects, learnt Foundry testing and read audit reports. I like that the field mixes cryptography, distributed systems and finance. I want to grow as a smart contract developer and help build secure, real-world applications such as payments, tokenisation or supply chain.
13
What happens, step by step, when you send an Ethereum transaction?
The wallet builds the transaction with nonce, to, value, data, gas limit and fee fields, signs it with the private key, and sends it to a node via eth_sendRawTransaction. The node validates and gossips it to other mempools. A block builder includes it, and the proposer publishes the block. Every node executes it in the EVM, updating state and producing a receipt with status, gas used and logs. After about two epochs the block is finalised.
14
What is a hash collision and why does it matter for blockchains?
A collision is when two different inputs produce the same hash. If attackers could find collisions, they could swap one transaction or block for another with the same hash and break integrity, Merkle proofs and address uniqueness. For SHA-256 and Keccak-256, finding a collision needs about 2^128 work, which is infeasible. This is why older broken hashes such as MD5 and SHA-1 must never be used in blockchain systems.
15
A user is angry that withdrawing from an optimistic rollup to Ethereum takes seven days. How do you explain and solve it?
Explain that the seven-day window lets anyone challenge a fraudulent batch; it protects their funds. For faster exits, offer third-party fast bridges or intent-based bridges where a liquidity provider pays them on L1 within minutes for a small fee and later claims the slow withdrawal. Also show the expected timeline clearly in the UI and send a notification when funds are claimable, because most anger comes from uncertainty, not the delay itself.
16
Show a contract vulnerable to reentrancy and a fixed version.
Build or use an indexer. An indexer listens to contract events from a start block, transforms them and stores them in a database like PostgreSQL, so the front-end runs normal fast queries. Options are a subgraph on The Graph, hosted indexing services, or a custom service with ethers and a queue. It must handle reorgs by tracking block hashes, support backfilling, and expose an API. Design events up front with indexed fields that queries need.
18
Write a minimal Python example showing how blocks are linked by hashes.
Each block stores the previous hash, so changing any earlier data breaks the chain.
import hashlib, json
def block_hash(block):
data = json.dumps(block, sort_keys=True).encode()
return hashlib.sha256(data).hexdigest()
chain = [{'index': 0, 'data': 'genesis', 'prev': '0'}]
for i, tx in enumerate(['A pays B 5', 'B pays C 2'], 1):
chain.append({'index': i, 'data': tx, 'prev': block_hash(chain[-1])})
valid = all(chain[i]['prev'] == block_hash(chain[i-1]) for i in range(1, len(chain)))
print(valid)
19
An attacker borrows governance tokens with a flash loan to pass a malicious DAO proposal. How do you prevent it?
Use snapshot-based voting power: count votes from token balances at a past block, as ERC20Votes does, so tokens acquired in the same transaction have no weight. Add a voting delay before voting starts, a quorum, and a timelock between approval and execution so the community can react or a guardian can veto. Require a proposal threshold, and keep critical actions such as treasury transfers behind additional safeguards like spending limits.
20
How do you compute a function selector and decode calldata with cast?
cast handles ABI work from the command line.
# Function selector
cast sig 'transfer(address,uint256)'
# 0xa9059cbb
# Encode calldata
cast calldata 'transfer(address,uint256)' 0xAbc... 1000000
# Decode calldata from a transaction
cast 4byte-decode 0xa9059cbb000000...
# Decode with a known signature
cast decode-calldata 'transfer(address,uint256)' 0xa9059cbb...
This is useful when checking what a wallet is really asking you to sign.
21
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.
22
Tell me about a bug you missed and what you learned from it.
Situation: I shipped a rewards contract where a rounding error let users claim slightly more than earned when claiming very often. Task: fix it and prevent repeats. Action: I owned the mistake in the team call, wrote a failing test reproducing it, changed the division order to round down in the protocol's favour, and added fuzz tests on claim frequency. Result: losses were tiny, and I now always fuzz any maths involving division.
23
A simulated eth_call succeeds but the real transaction reverts. What could cause this?
The state can change between simulation and inclusion: price moved beyond slippage limits, a deadline passed, another user took the last item, or a bot front-ran the trade. Other causes are a different msg.sender or value in the simulation, a gas limit too low for the real path, block-dependent logic like block.timestamp, or a different block tag. Debug by tracing the failed transaction with cast run or a tracer and comparing inputs and state.
24
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.
25
How do you verify a deployed contract's source code on a block explorer?
Verification uploads source and compiler settings so the explorer can recompile and match the bytecode, letting users read the code.
# Foundry, using an explorer API key
forge verify-contract 0xDeployedAddr src/Counter.sol:Counter \
--chain sepolia --etherscan-api-key $KEY --watch
# With constructor arguments
--constructor-args $(cast abi-encode 'constructor(address)' 0xOwner)
# Hardhat
npx hardhat verify --network sepolia 0xDeployedAddr 0xOwner
Compiler version, optimiser runs and via-IR settings must match exactly.
Typical bugs include missing onlyOwner or role checks on sensitive functions such as mint, withdraw or setOracle, initialiser functions in upgradeable contracts that anyone can call, misconfigured roles, and a single EOA owning critical powers. Use OpenZeppelin Ownable2Step or AccessControl, give each role the minimum rights, protect admin actions with a multisig and timelock, and write tests confirming that every privileged function reverts for unauthorised callers.
27
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.
28
Users report their USDC balance shows as a tiny fraction in your dApp. What is wrong?
USDC uses 6 decimals, but the front-end probably formats every token with 18 decimals, so 100 USDC (100,000,000 base units) displays as 0.0000000001. Read decimals() from each token contract, or from a trusted token list, and use formatUnits and parseUnits with that value. Use bigint for amounts, never JavaScript floats, to avoid precision errors. Add tests with tokens of 6, 8 and 18 decimals.
29
What is a nonce in blockchain? Explain both common meanings.
In proof of work, the nonce is a number miners change repeatedly in the block header until the header hash falls below the difficulty target. In Ethereum's account model, the account nonce is a counter of transactions sent from an address; each transaction must use the next nonce, which orders transactions and prevents replay. A stuck transaction with a low nonce blocks all later ones from that account until it is mined or replaced.
30
How do you read a Chainlink price feed in Solidity safely?
import {AggregatorV3Interface} from '@chainlink/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol';
AggregatorV3Interface public feed;
uint256 constant MAX_DELAY = 1 hours;
function getPrice() public view returns (uint256) {
(, int256 answer, , uint256 updatedAt, ) = feed.latestRoundData();
require(answer > 0, 'bad price');
require(block.timestamp - updatedAt <= MAX_DELAY, 'stale price');
return uint256(answer); // scale using feed.decimals(), often 8
}
Always check staleness, sign and decimals; on L2s also check the sequencer uptime feed.
Tips to crack the Visa Blockchain interview
Learn the card payment flow involving issuer, acquirer, network and merchant, plus concepts like authorisation and settlement.
Read about tokenisation and RBI card-on-file rules, which are relevant to Visa's work in India.
Practise Java, SQL and testing fundamentals, which are commonly required for Visa engineering and QA roles.
Keep a one-minute story ready for every project on your CV: problem, your part, tools, result.
Practise the hard questions on this page aloud; Visa interviewers usually ask follow-ups on your first answer.
Frequently asked questions
How many rounds are there in the Visa Blockchain interview?
Candidates usually go through 5 stages: Online coding assessment; Technical round 1; Technical round 2; Hiring manager round; HR round. The exact rounds change with the role, team, location and your experience, so confirm the process with the recruiter.
Which topics should I prepare for the Visa Blockchain interview?
This practice set leans on Cryptography for Blockchain (6), dApp Development (5), Consensus and Scaling (4), Blockchain Fundamentals (4). Revise those first, then practise explaining one or two of your own projects end to end, because most Visa interviewers ask you to walk through real work.
Are these the exact questions asked at Visa?
No. These are curated practice questions that match the skills and difficulty usually tested in fintech interviews like Visa's. They are not a leaked or verified list of past questions.
Where does Visa hire Blockchain professionals in India?
Visa has large teams in Bengaluru, Mumbai. Openings and locations change often, so check the Visa careers page and filter by city and experience.