Persistent Systems Blockchain Interview Questions & Answers
Curated interview practice questions with answers. These are practice scenarios, not a verified list of past interview questions.
About Persistent Systems hiring for Blockchain roles
Persistent Systems is an Indian technology services company focused on software product engineering, digital transformation, cloud and data services. It serves clients in banking, healthcare, life sciences and software. In India it hires for software engineers, quality engineers, data engineers and analysts, often through campus drives with coding-focused assessments.
For Blockchain roles, this Persistent Systems practice set focuses most on Smart Contract Security (6), Ethereum and the EVM (6), Consensus and Scaling (4), Solidity Programming (4). It has 15 easy, 15 medium questions, so you can start easy and work up to the harder ones.
Company type
IT services
Headquarters
Pune, India
Main India offices
Pune, Nagpur, Bengaluru, Hyderabad, Goa
Persistent Systems Blockchain interview process
Online assessment (aptitude + coding)
Technical round 1
Technical round 2
HR round
Typical pattern based on public candidate experiences. Rounds vary by role, team and year.
Solved for Persistent SystemsStart 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
Why is on-chain randomness insecure, and what should you use instead?
Values like block.timestamp, blockhash or block.prevrandao are visible to or partly controlled by block producers, and any contract can read them in the same transaction and only proceed when the outcome is favourable. So lotteries and NFT trait reveals based on them can be gamed. Use a verifiable random function such as Chainlink VRF, which delivers randomness with a cryptographic proof in a later transaction, or a commit-reveal scheme for simpler cases.
02
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.
03
What is the difference between constant and immutable?
constant variables must be assigned a compile-time value and are inlined into the bytecode, for example uint256 constant MAX = 1000. immutable variables are assigned once in the constructor and then embedded in the deployed code, for example an owner address or token address chosen at deployment. Neither uses a storage slot, so reading them is far cheaper than reading normal state. Use them for anything that never changes after deployment.
04
Write a basic voting contract using a struct, mapping and event.
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.
06
How do you connect a browser wallet to a dApp using ethers.js?
Browser wallets inject an EIP-1193 provider at window.ethereum. Wrap it with BrowserProvider and request accounts.
import { BrowserProvider } from 'ethers';
async function connect() {
if (!window.ethereum) throw new Error('Install a wallet');
const provider = new BrowserProvider(window.ethereum);
const signer = await provider.getSigner(); // prompts the user
const address = await signer.getAddress();
const { chainId } = await provider.getNetwork();
return { signer, address, chainId };
}
In production, use EIP-6963 discovery or a connector library so users with several wallets can choose.
07
How did integer overflow bugs happen before Solidity 0.8?
Before 0.8, arithmetic wrapped silently: a uint8 at 255 plus 1 became 0, and 0 minus 1 became the maximum value. Attackers exploited this, for example by making a balance underflow to a huge number or an overflowed multiplication pass a check, as in the 2018 batchOverflow token bug. Developers used the SafeMath library to revert on overflow. Since 0.8 the compiler checks automatically, except inside unchecked blocks and in inline assembly.
08
Why should you not use tx.origin for authorisation?
tx.origin is the EOA that started the transaction, while msg.sender is the immediate caller. If a contract checks require(tx.origin == owner), a phishing contract can trick the owner into calling it, and that contract then calls the victim; tx.origin is still the owner, so the check passes and funds can be stolen. Always use msg.sender for access control. tx.origin also breaks with smart contract wallets and account abstraction.
09
What does a smart contract audit process look like?
It starts with scoping: fixed commit, documentation, threat model and test coverage. Auditors run automated tools like Slither and fuzzers, then do manual line-by-line review, checking business logic, access control, economic attacks and integrations. They write findings rated critical, high, medium, low and informational with fixes. The team fixes issues, auditors review the fixes, and a final report is published. Audits reduce risk but do not guarantee safety, so add bug bounties and monitoring.
10
Your dApp needs a full history of user transactions and fast queries. Reading events from the node is too slow. What do you do?
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.
11
What is the difference between SHA-256 and Keccak-256?
SHA-256 is from the SHA-2 family and uses a Merkle-Damgard construction; Bitcoin uses double SHA-256 for block hashes and transaction IDs. Keccak-256 is based on the sponge construction and is what Ethereum uses for addresses, function selectors, event topics and storage slots. Ethereum's Keccak-256 is the original Keccak submission and differs from the final NIST SHA3-256 in padding, so the two give different outputs for the same input.
12
What is the difference between a full node, a light node and an archive node?
A full node downloads and validates every block and keeps the current state, so it can verify everything independently. A light node stores only block headers and asks full nodes for Merkle proofs of the data it needs, which suits mobile wallets. An archive node keeps all historical states, so you can query a balance at any past block; indexers and block explorers need it, but it requires many terabytes of storage.
13
How is public-key cryptography used in blockchain?
Each user has a private key, kept secret, and a public key derived from it. The private key signs transactions, and anyone can verify the signature with the public key, proving the owner authorised the transfer without revealing the private key. Addresses are derived from public keys. Because control of funds equals control of the private key, losing it means losing access, and leaking it means anyone can spend the funds.
14
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.
15
A user lost their private key and seed phrase. Can you recover their funds?
No. In a self-custody wallet, nobody, including the developer, can recover a lost private key; deriving it from the address is computationally impossible. If they still have the seed phrase, the wallet can be restored on any compatible app. To reduce future risk, suggest a hardware wallet, a written seed phrase stored in two safe locations, or a smart contract wallet with social recovery or passkeys, where trusted guardians can rotate the signing key.
16
What does a block contain and what is inside a block header?
A block has a header and a body. The body holds the list of transactions. The header holds metadata: the previous block hash, a timestamp, the Merkle root (or state and transaction roots in Ethereum) summarising the transactions, and consensus fields such as the difficulty target and nonce in Bitcoin. Because the header commits to all transactions through the root hash, nodes can verify a block's integrity by hashing just the header.
Reentrancy happens when a contract makes an external call, such as sending ETH, before updating its own state, and the receiver calls back into the contract to repeat the action. For example, a withdraw that sends funds and then sets the balance to zero can be re-entered to withdraw many times. The 2016 DAO hack drained millions this way. Prevent it with checks-effects-interactions, reentrancy guards, and pull payments.
18
What is the difference between receive and fallback functions?
receive() external payable runs when a contract receives plain ETH with empty calldata, for example a transfer from a wallet. fallback() runs when calldata matches no function, or when ETH arrives with data and no receive exists; it must be payable to accept ETH. Proxies use fallback to delegatecall all unknown calls to the implementation. Keep both simple, since a reverting or gas-heavy receive can break senders that use transfer with its 2300 gas stipend.
19
What is Ethereum and how is it different from Bitcoin?
Ethereum is a programmable blockchain: besides transferring its native currency ETH, it runs smart contracts, which are programs stored on-chain that execute exactly as written. Bitcoin focuses on being secure, scarce digital money with a deliberately limited scripting language and the UTXO model. Ethereum uses an account model, Proof of Stake since 2022, about 12-second blocks, and a large ecosystem of tokens, DeFi, NFTs and Layer 2 rollups built on top.
20
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.
21
What is the difference between CREATE and CREATE2?
CREATE computes a new contract's address from the deployer's address and nonce, so the address depends on deployment order. CREATE2 computes it from the deployer address, a chosen 32-byte salt and the hash of the init code, so the address is known before deployment and is the same wherever those inputs match. CREATE2 enables counterfactual wallets, deterministic factory deployments and same-address deployments across chains, but redeploying at the same address needs care.
22
How do you call read and write functions of a contract with ethers v6?
For EVM work, run a local node with Anvil from Foundry or the Hardhat network. Each gives about ten pre-funded test accounts, instant mining and console logging. You can fork mainnet at a given block to test against real contracts and balances without spending money. For integration tests, deploy to a public testnet such as Sepolia, using faucet ETH. Keep deploy scripts and RPC URLs in config so the same code targets local, testnet and mainnet.
24
How do you run Slither on a Foundry project and focus on important findings?
Install it with pip and run it from the project root; it detects Foundry automatically.
pip install slither-analyzer
slither .
# Only medium and high impact issues
slither . --exclude-low --exclude-informational
# Exclude dependencies
slither . --filter-paths 'lib|test'
# Print a summary of contracts and functions
slither . --print human-summary
Triage each finding: fix real bugs and record why false positives are safe.
25
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.
EIP-1559 splits the fee into a base fee and a priority fee. The protocol sets the base fee per block from demand: if the previous block was more than half full, it rises up to 12.5 percent, otherwise it falls. The base fee is burned. Users add a priority fee (tip) for the proposer and set maxFeePerGas as their cap. They pay base fee plus tip, never more than the cap, which makes fees more predictable.
27
How do you approve and transfer ERC-20 tokens from a script with ethers.js?
Proof of Work secures the chain with electricity and mining hardware; it is battle-tested and simple but energy-hungry and tends to centralise in mining pools. Proof of Stake secures it with locked capital that can be slashed; it uses over 99 percent less energy, gives faster economic finality and lowers hardware needs. Its critics point to stake concentration in large staking providers and more complex protocol design. Ethereum moved from PoW to PoS in the Merge of September 2022.
29
Explain public, external, internal and private visibility.
public functions can be called externally and internally, and public state variables get an automatic getter. external functions can only be called from outside, or via this.f(), and read arguments directly from calldata. internal functions and variables are available to the contract and contracts that inherit it. private is limited to the defining contract only. Note that private only restricts other contracts; the data is still fully visible on the blockchain to anyone.
Gas measures the computational work an operation needs; for example a simple ETH transfer uses 21,000 gas, and writing a new storage slot costs about 20,000. The gas limit is the maximum gas the sender allows a transaction to consume. The gas price, per unit, is what the sender pays. The fee equals gas used times the effective gas price. If execution exceeds the limit, it reverts but the used gas is still charged.
Tips to crack the Persistent Systems Blockchain interview
Practise coding problems of easy to medium difficulty, as Persistent assessments usually focus more on programming than service peers.
Revise data structures, OOP, DBMS and operating system basics for the technical rounds.
Read about Persistent's product engineering background and its partnerships with major cloud providers.
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; Persistent Systems interviewers usually ask follow-ups on your first answer.
Frequently asked questions
How many rounds are there in the Persistent Systems Blockchain interview?
Candidates usually go through 4 stages: Online assessment (aptitude + coding); Technical round 1; Technical round 2; 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 Persistent Systems Blockchain interview?
This practice set leans on Smart Contract Security (6), Ethereum and the EVM (6), Consensus and Scaling (4), Solidity Programming (4). Revise those first, then practise explaining one or two of your own projects end to end, because most Persistent Systems interviewers ask you to walk through real work.
Are these the exact questions asked at Persistent Systems?
No. These are curated practice questions that match the skills and difficulty usually tested in it services interviews like Persistent Systems's. They are not a leaked or verified list of past questions.
Where does Persistent Systems hire Blockchain professionals in India?
Persistent Systems has large teams in Pune, Nagpur, Bengaluru, Hyderabad, Goa. Openings and locations change often, so check the Persistent Systems careers page and filter by city and experience.