Hiring for this role?

Start free with this plan

Free for your first open role.

Why Hirezen?
  • Every interviewer runs the same script and marks the same signals.
  • AI drafts the write-ups, and the debrief puts every read side by side.
  • No ATS to set up first, and no bot in the call.

Blockchain Developer interview questionsSystem Design Interview round

A 60 min interview plan with a time-boxed script, what each question is for, and the signals to score against. Key skills: Blockchain system design for deposits and withdrawals: crediting on-chain deposits correctly through reorgs and finality on Ethereum and a rollup, sending payouts exactly once with nonces and stuck transactions handled, and deciding who holds the keys that move customer funds and what the stablecoin's issuer can do to them.

Opening

Who is interviewing, how the round will run, and a question to settle the candidate in. The standard opening

The deposit that was never there

22 min
What this part is for

Purpose

Runs over a one-page architecture sketch and a short description of the product, handed over at the start. The product: business customers hold stablecoin balances, top up by sending the stablecoin to a deposit address the product gives each of them on Ethereum mainnet or on one optimistic rollup, and pay contractors out to external wallets — about 9,000 deposits and 26,000 payouts a month. The sketch is what the founding engineer built, and its defects are yours to plant. The deposit watcher polls every 12 seconds on mainnet and every 2 on the rollup: it calls `eth_getLogs` for `Transfer` events from the stablecoin contract to the deposit addresses, over blocks `lastProcessed + 1` to `latest`, credits the ledger as each log comes back, and saves `lastProcessed` as a block number with no block hash. When the RPC call errors it logs a warning and advances `lastProcessed` anyway, so that the watcher 'never gets stuck'. The ledger deduplicates credits with a unique index on the transaction hash. An hourly job sweeps deposit addresses into the hot wallet. The payout worker runs four processes; each takes a payout row, asks the node for the hot wallet's `pending` nonce, builds an EIP-1559 transaction with a maximum fee of twice the current base fee, signs it with a key read from the `HOT_WALLET_PRIVATE_KEY` environment variable on the host that also runs the watcher and the admin dashboard, and sends it; on a timeout it builds and signs a fresh transaction and tries again. The hot wallet holds the whole treasury, about $6.2 million, with no limit on amount or destination. The stablecoin is itself an upgradeable proxy whose issuer can pause all transfers and block individual addresses; the sketch never mentions this. Two choices are right and should be left alone: the watcher filters on the stablecoin's contract address rather than its symbol, and amounts are stored as integers in the token's base units. The red herring is polling — a candidate who spends five minutes replacing it with a websocket subscription has changed nothing that loses money. Book 70 minutes; the close is outside the 60.

•

I'm [YOUR_NAME] and I own the systems at [COMPANY_NAME] that move customer funds on chain. This is a design hour. The sketch in front of you is what we run today, and it has worked well enough that nobody has looked at it closely.

What this line is for

Purpose

Frames the round as redesigning something that already carries money, so the candidate has to find what is wrong before proposing what is right.

•

Nothing has gone wrong that we know of. I would like you to find out what could, and then tell me what you would build instead.

What this line is for

Purpose

Leaves every problem unnamed. A candidate who asks how the team would even know if something had gone wrong has already started.

•

Follow one deposit from the customer's transaction to the balance on their dashboard. Tell me every way the ledger can end up saying something the chain does not, and redesign the watcher so it cannot.

What this question is for, and what to listen for

Purpose

The load-bearing question. It reads whether the candidate knows how a chain changes its mind — reorganisations, finality, a node that answers with less than it was asked for — and whether their design makes the ledger follow the chain rather than the first thing the chain said.

Signals to score

  • Says crediting at `latest` credits blocks that can still be replaced, and sets a confirmation policy per chain
  • Uses the node's finalized or safe block, or a stated depth, and says what each choice costs the customer in waiting
  • Distinguishes the rollup's heads — the sequencer's, the one whose batch is posted to Ethereum, and the one final on Ethereum — and does not confuse crediting with the seven-day window for bridge withdrawals
  • Stores block hashes with the cursor, detects a reorganisation when a new block's parent hash does not match, and rewinds and re-reads
  • Refuses to advance the cursor past a failed or partial RPC response, and names provider limits on block range and result size
  • Changes the deduplication key to chain id, transaction hash and log index, and gives the batch transfer the old key silently drops
  • Shows a deposit as pending until it is final, and says what a customer may and may not do with a pending balance
  • Adds a reconciliation job that compares the ledger with the chain — transfers received at each deposit address, and total on-chain holdings against total customer balances — and alerts on any difference
  • Cross-checks the watcher against a second provider, since a single node that lags is otherwise invisible
  • Leaves what is right alone — polling with a cursor, filtering on the contract address, integers in base units — or says briefly why it is fine

Follow-up questions

  • A block containing a deposit is replaced by one that does not contain it. What does the ledger show now?
  • The RPC call timed out and the cursor moved on. How would anyone find out?
  • An exchange pays two of your customers in one transaction. What happens to the second credit?
  • On the rollup, when is a deposit final enough to credit — and is the seven-day window part of that answer?
  • Would you move the watcher to a websocket subscription?

Paying out exactly once

20 min
What this part is for

Purpose

The other direction. Payouts are where a system that talks to a chain spends its own money twice, and the sketch has three separate ways to do it.

•

Redesign the payout worker so that each payout is sent exactly once, one stuck payout never holds up the rest, and a node that times out cannot cause a double payment. Start from what goes wrong with four workers today.

What this question is for, and what to listen for

Purpose

Reads whether the candidate treats the nonce as the thing that makes a payment happen once. Candidates who have run a sender know that a retry which builds a new transaction is a second payment waiting to land.

Signals to score

  • Sees that four workers asking for the `pending` nonce at once get the same value, and assigns nonces from one serialised allocator per sending address
  • Stores the nonce and the signed transaction against the payout before sending, so a retry rebroadcasts identical bytes
  • Explains that a timeout says nothing about whether a node accepted the transaction, and that signing a new one with a new nonce can pay twice
  • Replaces a stuck transaction with the same nonce and higher fees, and knows nodes refuse a replacement that does not raise them by a minimum margin
  • Says a fee cap of twice today's base fee is overtaken after a handful of full blocks, and that every later nonce then waits behind the stuck one
  • Marks a payout paid only when its transaction is final, and returns a dropped or reorganised-out transaction to the queue under the same nonce
  • Watches the hot wallet as state — confirmed nonce against allocated nonce, balance against queued payouts — and alerts on a gap
  • Keeps fee increases inside a stated budget and pages a person beyond it
  • Says what happens when a payout already holding a nonce turns out to be unsendable, such as a transfer the token would reject, and fills that nonce rather than stalling everything behind it

Follow-up questions

  • Two workers ask the node for the nonce at the same moment. What do they get?
  • The send call timed out. Was the payout sent?
  • The base fee doubles in the next minute. What happens to the forty payouts queued behind this one?
  • How do you replace a stuck transaction, and how do you know which version landed?
  • As far as the customer's balance is concerned, when is a payout paid?

Who can move the money

18 min
What this part is for

Purpose

The key-custody read. The design is now honest about the chain; this section is about power — who can make the system pay, and what the product depends on that it does not control.

•

Last part. Set correctness aside for a moment and think about authority: who, today, can move the $6.2 million?

What this line is for

Purpose

Resets the frame from bugs to authority, which is the shift this section scores.

•

Redesign where the hot wallet's key lives and what that key is able to do. Then tell me what the stablecoin's issuer can do to your customers' balances, and what your design does about it.

What this question is for, and what to listen for

Purpose

Tests whether the candidate designs custody as limits on what a key can do rather than as a safer place to keep it, and whether they look as hard at an admin key someone else holds. The issuer half is where candidates who have held tokens but never run a product on them tend to go quiet.

Signals to score

  • Takes the key out of the environment and off the shared host, into a signing service backed by a hardware module, a cloud key service or multi-party signing
  • Makes the signing service enforce policy itself — per-payout and daily limits, allowed destinations — so a compromised caller cannot exceed them
  • Splits hot from cold: a hot float sized to a stated number of hours of payouts, refilled from cold storage that needs several people
  • Requires a second approval above a threshold, and a delay before a newly added payout destination can be paid
  • Separates the power to change the signer's policy from the power to deploy the payout service, held by different people
  • Names the issuer's powers — pausing the token, blocking an address, upgrading the contract — and what each does to a customer's balance
  • Plans for a blocked deposit or treasury address: how it is detected, what the ledger shows, and how customers hear about it
  • Monitors the token contract for upgrades and role changes as part of normal operations
  • Says which of these dependencies the product carries on its customers' behalf and should state in its terms

Follow-up questions

  • The key is in a hardware module now, and an attacker has a shell on the payout host. What can they do?
  • How large should the hot wallet be, and what decides that number?
  • The issuer blocks one of your customers' deposit addresses. What does the ledger show?
  • The token contract is upgraded on a Tuesday. How do you find out, and what do you check?
  • Who at your company can change the signing service's limits?

Closing

We are nearly out of time, so the rest is yours. Ask me about anything in how our systems meet the chain — how we credit deposits, where our keys live, what happened the last time a node fell behind.

What this line is for

Purpose

A candidate who has run this kind of system asks about finality policy, keys and past incidents; one who has not asks which providers we use. Naming the areas makes that choice the signal.

One thing you should know before deciding: [name a true, unflattering fact about your own on-chain operations — a cursor that has skipped blocks, a hot wallet larger than it needs to be, a token dependency nobody monitors]. It would land on your desk.

What this line is for

Purpose

Closes on a specific, current weakness — the reason this round's hire would want the job, and a clear signal to anyone hoping the hard parts were done. Make sure it is still true.

Their questions for you, and what happens next. The standard closing

Blockchain Developer interviews — common questions

Who is this Blockchain Developer interview plan for?
It is written for the interviewer, not the candidate: the hiring manager, engineer or panel member running the System Design Interview round for a Blockchain Developer role. It gives you a 60 min script to follow in the conversation — 3 questions with what each one is for and the signals to score against — so you are not writing the round from scratch the night before.
What does the System Design Interview round assess?
This round is focused on: Blockchain system design for deposits and withdrawals: crediting on-chain deposits correctly through reorgs and finality on Ethereum and a rollup, sending payouts exactly once with nonces and stuck transactions handled, and deciding who holds the keys that move customer funds and what the stablecoin's issuer can do to them. It works through The deposit that was never there, Paying out exactly once and Who can move the money, scoring against 28 observable signals, with follow-up prompts on all 3 questions for going deeper where an answer is thin.
How is the 60 min split up?
60 min on 3 questions. The questions take in The deposit that was never there (22 min), Paying out exactly once (20 min) and Who can move the money (18 min). The timings are there so the round stays on schedule and every candidate gets the same shape of interview — which is what makes two candidates comparable afterwards.
What other rounds should I run for a Blockchain Developer?

A single round does not cover a whole role. The other rounds in this library for a Blockchain Developer:

Hiring for this role?

Open this plan in Hirezen and make it a position in one click.

  • Every interviewer runs the same script and marks the same signals.
  • AI drafts the write-ups, and the debrief puts every read side by side.
  • No ATS to set up first, and no bot in the call.
Start free with this plan

Free for your first open role.