As a Solana Engineer,
Please slap yourself if you cannot clearly explain at least 10 of the following:
Accounts model vs account-based chains
Program Derived Addresses (PDAs)
Seeds & bump mechanics
Account ownership rules
Rent exemption mechanics
Lamports vs SOL accounting
System Program responsibilities
Upgradeable program loader internals
Instruction serialization (Borsh vs Anchor)
Transaction message structure
Versioned transactions (v0)
Address Lookup Tables (ALTs)
Compute budget & compute units
Priority fees & fee markets
Transaction simulation vs execution
Preflight checks
Atomic transaction guarantees
Cross Program Invocation (CPI) mechanics
Reentrancy in Solana (why it differs from EVM)
Signer authorization model
Writable vs readonly accounts
Account locking & parallel execution
Sealevel runtime scheduling
Optimistic concurrency model
Deterministic execution constraints
Transaction size limits (1232 bytes problem)
Account data layout design
Zero-copy accounts
Account realloc patterns
Serialization cost vs compute tradeoffs
Anchor discriminator logic
Anchor account validation pipeline
Constraint macros under the hood
IDL generation & client binding
Anchor events vs logs
Program logs & debugging strategy
LiteSVM vs local validator testing
Test validator architecture
Sysvars (Clock, Rent, Instructions, SlotHashes)
Slot vs block vs epoch
Proof of History (PoH) mechanics
Leader schedule & block production
Turbine block propagation
Gulf Stream transaction forwarding
QUIC networking in Solana
Replay stage & fork choice
Commitment levels (processed/confirmed/finalized)
RPC consistency guarantees
State compression basics
Merkle tree accounts
Concurrent Merkle Trees
Compressed NFTs architecture
Token Program vs Token-2022 extensions
Associated Token Accounts derivation
Mint authority vs freeze authority
Delegation mechanics
Metaplex metadata accounts
Candy Machine architecture
On-chain randomness limitations
Oracle design patterns (Pyth/Switchboard)
Price update verification
Upgradeable program security risks
Program authority management
Multisig program patterns
Escrow design patterns
Time-locked accounts
Vesting contract mechanics
Replay attack prevention
Signature verification flow
Ed25519 program usage
Secp256k1 verification program
Compute exhaustion attacks
Account inflation attacks
Rent draining vectors
CPI depth limits
Stack frame limits
Heap allocation constraints
Deterministic randomness strategies
Idempotent instruction design
State machine modeling on-chain
Instruction replay safety
Optimistic UI vs finalized state
Indexer architecture (Helius/Triton style)
Websocket subscriptions vs polling
Event indexing from logs
RPC rate limiting strategies
Transaction confirmation UX design
Wallet adapter lifecycle
Phantom signing flow internals
Partial signing transactions
Durable nonce accounts
Offline transaction signing
MEV on Solana
Jito bundles & block engines
Priority fee auctions
Transaction landing optimization
Failed transaction debugging workflow
Compute profiling techniques
Program size optimization
BPF execution model
LLVM → SBF compilation pipeline
Stack vs heap limits in SBF
Program deployment lifecycle
Upgradeable buffer accounts
Devnet vs mainnet behavioral differences
Forks & rollback handling
State migration strategies
Backward-compatible account upgrades