
Interviews for mid-career chip engineers are not like campus interviews. With five to fifteen years behind you, nobody needs you to recite the setup time equation. Panels want to know whether you can size a design from a traffic pattern, find the real problem inside a report with four thousand warnings, and make a sound call three weeks before tape-out.
This list collects 50 technical and problem-solving questions for VLSI, RTL, verification, timing, low power, DFT and physical design roles in 2026. For each one we say what the panel is really testing and what a strong answer covers. Several are worked problems with numbers, because that is where experienced candidates stand out.
Key takeaways
- Mid-career questions test judgment: trade-offs, sizing, triage and debug, not definitions. Most of the 50 below are scenarios, not textbook questions.
- Check the arithmetic first. Several classic questions (FIFO depth, memory bandwidth, test time) hide a trap that a quick rate check exposes.
- Expect 2026 topics: power intent, reset domain crossings, temperature inversion, chiplets, memory bandwidth for AI, and how you would check AI-written RTL.
- Scenario questions on schedule, disagreement and cross-team bugs carry as much weight as the technical ones at this level.
- Answer with a structure: state assumptions, work the numbers, name the risk, then say what you would do.
In this list
- RTL and micro-architecture (1 to 7)
- Clocks, CDC and resets (8 to 13)
- Timing closure and STA (14 to 19)
- Low power and power intent (20 to 23)
- Verification and debug (24 to 31)
- DFT, test and silicon bring-up (32 to 36)
- Physical design and advanced nodes (37 to 41)
- Chiplets, memory and AI systems (42 to 45)
- Judgment and leadership scenarios (46 to 50)
RTL and micro-architecture
1. A writer bursts 64 words every 200 cycles at 1 GHz. The reader takes one word per cycle at 300 MHz. How deep must the asynchronous FIFO be?
What it tests: whether you check the long-term rates before sizing for the burst.
A strong answer: start with the average. 64 words every 200 ns is 320 million words per second, and the reader drains only 300 million. No depth works, because the FIFO fills a little on every burst and eventually overflows. Say so, then offer fixes: backpressure on the writer, a wider read port or a faster read clock. If the reader ran at 400 MHz, it would drain about 26 words during the 64 ns burst, leaving about 39 behind. Add a few entries for pointer synchronization latency and you land near 48, or 64 if you keep power-of-two Gray-coded pointers.
2. Add a register stage to a valid/ready interface without losing throughput. What goes wrong with a simple register?
What it tests: flow control under timing pressure.
A strong answer: registering valid and data alone leaves ready as a long combinational path back through the stage. Registering ready as well means the upstream side can send one more beat after the downstream side stalls, and that beat has nowhere to go. The standard fix is a two-entry skid buffer: one entry holds the in-flight beat, so the stage keeps full throughput and both directions are registered. Mention that the cost is one extra data register and that the buffer must be verified for back-to-back stalls.
3. A 32-port crossbar meets function but misses timing by 15%, and the floorplan puts the ports at opposite chip edges. How do you rework it?
What it tests: joint micro-architecture and physical thinking.
A strong answer: the arbiter logic and the wires are both on the path, so fix both. Split the crossbar into regional stages near each port group with a pipelined link between them, which turns one long path into two short ones at the cost of a cycle of latency. Replace a single 32-way arbiter with grouped arbiters plus a second level, and check that fairness is still acceptable. Register outputs at the port side so the long wires start from a flop. Then rerun throughput and latency simulations, because extra pipeline stages change buffer depths and credit counts.
4. A 512-bit datapath runs at 1 GHz, and the CRC over the full width will not close timing. What are your options?
What it tests: arithmetic structure under a hard timing limit.
A strong answer: a parallel CRC is a wide XOR tree, and at 512 bits its depth is the problem. Pipeline the tree over two or three stages and accept the latency. Better still, use the fact that CRC is linear: compute partial CRCs on smaller slices in parallel, then combine them by shifting each partial result through a fixed matrix for its position before XORing them. Discuss the end-of-packet case, where the last word is only partly valid and needs its own correction logic, and how you would prove the result against a reference model over random packet lengths.
5. A multiplier in a FIR filter is on the critical path. How do you close timing without changing the function?
What it tests: pipelining, retiming and arithmetic tricks.
A strong answer: pipeline the multiplier and balance the other taps; switch to a transposed form so the adder chain is broken by registers; for constant coefficients, use canonical signed digit shift-and-add instead of a full multiplier. Each adds latency, so check that the system tolerates it. Mention retiming in synthesis and its limits around reset and observability. Background in re-timing long combinational paths.
6. Lookups return out of order with variable latency, but packets must leave in order at one per cycle. Sketch the design.
What it tests: ordering and resource sizing.
A strong answer: tag each request, store results in a reorder buffer indexed by tag, and retire from the head only when its result is valid. The buffer depth must cover the worst-case lookup latency at full rate, or you need credits to stop issue. Discuss what happens on a lost or errored response, and how you would verify ordering with a scoreboard.
7. After synthesis, your block is 30% larger than the estimate. How do you find out why?
What it tests: structured investigation.
A strong answer: read the area report by hierarchy and find the outliers. Common causes: memories built from flops because a macro was not instantiated, inferred latches, wide multiplexers from loose case statements, multipliers that should have been shifts, constants that did not propagate, and resets on large datapath registers that do not need them. Compare against the estimate's assumptions, not just against the netlist.
Clocks, CDC and resets
8. A synchronizer passed CDC sign-off, yet field units show a failure roughly once a month that traces to that crossing. How do you investigate?
What it tests: moving from rules to physics when sign-off was clean.
A strong answer: start with the numbers: compute MTBF from the real destination clock, the real data toggle rate and the library's metastability data, then multiply the failure rate by the number of units in the field. A design that looks safe on one chip can fail monthly across a large fleet. Then check the implementation: are the flops the library's synchronizer cells, are they placed close together with no logic or long wire between stages, and is the source driven straight from a flop? Combinational logic before a synchronizer can glitch, and a glitch can be captured. Also check whether the signal really is a stable level, or a short pulse the tool was told to ignore. Fix with a third stage, proper cells and placement constraints, and add the check to sign-off.
9. How do you move a 32-bit configuration value between clock domains?
What it tests: picking the right CDC scheme.
A strong answer: Gray coding only works for values that change by one, such as counters. For general data, hold the bus stable and pass a synchronized qualifier (a request and acknowledge handshake, or a toggle), then capture the bus in the destination domain. For truly static configuration written before use, declare it quasi-static and back that with an assertion or a software rule, not just a waiver.
10. Two control signals cross into the same domain through separate synchronizers, and a state machine there occasionally takes a wrong branch. What happened?
What it tests: reconvergence, one of the hardest CDC bugs to see in simulation.
A strong answer: each synchronizer can resolve one cycle earlier or later than the other, so for one cycle the destination sees a combination of the two signals that never existed at the source. Simulation rarely shows it because simulated synchronizers have fixed latency. Fix it by crossing one encoded value with a handshake, by deriving both signals from one synchronized signal, or by adding a qualifier that is asserted only once both are stable. Mention that CDC tools report reconvergence and that metastability injection in simulation can expose it.
11. Software resets one subsystem while the rest of the chip keeps running, and a register in a live block occasionally picks up garbage. What is wrong, and how do you fix it?
What it tests: reset domain crossings in a real system.
A strong answer: when the source flop resets asynchronously, its output can change at any time relative to the live clock, so the destination can capture a metastable or wrong value even though both flops share a clock. Fixes: stop the destination from sampling during the reset (a qualifier or isolation signal, asserted before the reset and released after it), order the reset so the receiver is quiet first, or reset both domains together. Add the sequence to the software reset procedure and run an RDC check, since a CDC check alone will not report it.
12. Design a glitch-free clock multiplexer.
What it tests: clock handling under change.
A strong answer: each clock gets its own enable, synchronized in its own domain (often on the falling edge), and each enable is gated by the other's disabled state. The current clock is switched off at its low phase before the new one is switched on, so no short pulse appears. Point out that both clocks must be running for a switch to complete, and that STA needs the mux described with the right clock definitions.
13. Your CDC tool reports 4,000 violations a week before sign-off. How do you triage them?
What it tests: handling noise without hiding real bugs.
A strong answer: fix the setup first: missing or wrong clock definitions, missing clock groups and unmarked static signals cause most of the volume. Then group by rule and by crossing, so one root cause clears hundreds of lines. Review the remaining groups with the designer of each interface. Waive only with a written reason and, where possible, an assertion that proves the assumption. Never waive in bulk to meet a date.
Timing closure and STA
14. After clock tree synthesis, a path between two flops has a large hold violation. Where do you fix it?
What it tests: confirming the problem before fixing it.
A strong answer: first check that it is real: the right clocks, no missing false path or multicycle constraint, and common path pessimism removal applied. If it is real, add delay close to the capture flop's data pin, so other paths from the same launch flop are not slowed, and check that the fix does not create setup violations in the slow corner. If skew is the cause, adjusting the clock tree may be cleaner than buffering.
15. Setup fails only at the cold corner. Why might cold be the worst case?
What it tests: current knowledge of advanced nodes.
A strong answer: temperature inversion. At low supply voltages on recent nodes, the threshold voltage rises at low temperature enough to outweigh the mobility gain, so cells get slower when cold. Sign-off must therefore include cold corners at low voltage, and the worst corner can differ by path type. Mention that self-heating can also shift device temperature in dense logic.
16. The implementation tool says a block is 200 ps short of timing; the sign-off tool says it passes. Which do you trust, and how do you close the gap?
What it tests: tool correlation, a daily mid-career problem.
A strong answer: trust the sign-off tool for the final call, but treat a gap this large as a problem, because the implementation tool is optimizing against the wrong picture. Compare a few paths line by line: extraction, crosstalk settings, derates, clock latency modeling, common path pessimism removal and the libraries loaded. Align the settings where you can, then set a correlated margin in implementation so it neither over-fixes (wasting area and power) nor under-fixes (leaving surprises for the last week).
17. The next project needs 20% higher frequency on the same node with the same power budget. Where do you look for the gain?
What it tests: performance engineering across disciplines.
A strong answer: profile the critical paths: how many are logic depth, how many are wire delay, and how many sit on a few structures such as an adder, a memory output or a register file. Logic depth points to micro-architecture changes such as extra pipeline stages, prediction or a different algorithm. Wire delay points to the floorplan. Faster cells cost leakage, so spend them only where needed; useful skew and memory choices can buy more. Be honest that 20% at the same node and power usually needs architectural change, and say what it costs in latency, area and verification.
18. STA is clean, but parts fail at speed on the tester. Where do you look?
What it tests: the gap between models and silicon.
A strong answer: unconstrained or wrongly constrained paths, dynamic voltage drop under test activity that is higher than functional activity, crosstalk not captured, temperature on the die, and model accuracy. Use shmoo plots of voltage against frequency, at-speed scan diagnosis to find the failing paths, and compare them against the timing report. Check whether scan shift power, not functional timing, is the real issue. Background in tackling timing analysis inaccuracies.
19. The constraints file holds 3,000 false paths and multicycle paths inherited over five projects. How do you clean it up safely?
What it tests: knowing that exceptions can hide real failures.
A strong answer: every exception is a place where STA has stopped checking, so a stale one can mask a real violation. Remove broad wildcards first, then check each remaining exception against the current RTL, ideally with a tool that verifies exceptions formally or with assertions in simulation. Compare timing reports before and after each batch, review the doubtful ones with the designers, and record the reason beside each exception that survives. Background in multicycle paths and false paths in STA.
Low power and power intent
20. Power-aware simulation passes, but in silicon a sleeping block corrupts data in a live block on about one wake-up in a hundred. Where do you look?
What it tests: power intent bugs that only show in hardware.
A strong answer: check isolation first: are all outputs of the switchable domain isolated, with clamp values the receiver treats as idle, and is isolation released only after the domain is fully powered and restored? A missing or late isolation enable lets floating values reach live logic. Then check the power-up timing: switches turned on in stages take time, and if control logic releases isolation on a fixed delay rather than an acknowledge, slow parts or low voltage can break it. Compare the UPF with the netlist using a static power check, and review the power controller's sequence against the switch acknowledge signals.
21. After power-up, a block's retention registers sometimes come back with wrong values. What are the likely causes?
What it tests: retention in practice, not in the spec.
A strong answer: the save may happen after the clocks or inputs have already started changing, the retention supply may droop during the power-down transient, or the restore may run before the main supply has settled. Reset can also clash with restore if both are asserted around the same time. Check the controller's ordering against the cell library's retention requirements, simulate the sequence with power-aware models, and measure the retention supply on the bench. A design rule that blocks reset during restore often fixes the race.
22. Idle leakage now dominates your chip's energy. What are your options?
What it tests: breadth across design and process.
A strong answer: power gating, with a break-even time below which switching costs more than it saves; more high-threshold cells off the critical paths; body bias on processes that support it; lower retention voltage for memories; and system-level changes such as racing to idle. Quantify with leakage per corner, since leakage rises steeply with temperature. Related: transistor sizing and multi-Vt design.
23. When does RTL clock gating save power, and when does it cost you?
What it tests: knowing the overheads.
A strong answer: gating a wide register bank that is idle most of the time saves clock tree and flop power. Gating a few bits rarely pays for the gating cell. The enable must meet a tighter timing check because the gating cell sits early in the clock tree, and scan needs a test enable to force clocks on. Measure with realistic activity, not toggle assumptions.
Verification and debug
24. Code and functional coverage were 100%, yet a bug reached silicon. How?
What it tests: what coverage does not measure.
A strong answer: coverage measures what you chose to define. The scenario may have needed a cross that was never written, the bug may have been exercised but not checked (an observability gap in the scoreboard or assertions), or the stimulus may have been correlated so rare combinations never met. Fixes: review the plan against the spec, add checkers, and use formal on control logic.
25. One random seed in 10,000 fails. How do you debug it?
What it tests: method.
A strong answer: confirm the failure reproduces with the same seed and build. If it does not, suspect races in the testbench or nondeterminism. Then shorten the test, dump waves around the first divergence, and work backward from the checker's error to the first wrong value. Decide early whether it is a design or testbench bug, and add a directed test so it never returns.
26. Your team has a month and two engineers. Which blocks get formal verification, which get simulation, and how do you justify it?
What it tests: spending scarce effort where it finds bugs.
A strong answer: rank blocks by risk: new control logic with many concurrent cases (arbiters, cache controllers, credit and flow control, power sequencing) gains most from formal, because simulation rarely reaches its corner cases. Large datapaths and long end-to-end flows stay in simulation. Reused, silicon-proven blocks get light formal apps such as connectivity checks. State what each choice will prove, how you will know a proof is deep enough, and what the residual risk is. The answer should read like a plan you could defend to a project manager.
27. Write an assertion: every request is granted within 8 cycles unless it is cancelled.
What it tests: SVA fluency and its pitfalls.
A strong answer: assert property (@(posedge clk) disable iff (!rst_n) req |-> ##[1:8] (gnt || cancel)); Then point out the weakness: if requests overlap, one grant can satisfy several attempts. Fix it with a request ID or a local variable, and say whether a request must stay high until granted.
28. In the lab, data corruption appears about once a day under heavy traffic, and no simulation reproduces it. How do you corner it?
What it tests: post-silicon debug with little visibility.
A strong answer: first make it happen faster: raise traffic, vary voltage, frequency and temperature, and see which conditions change the rate. A rate that moves with voltage or temperature points to timing or noise; a rate that does not points to logic. Use on-chip trace, performance counters and error status to capture the state around the failure, and narrow it by disabling features one at a time. Once you have a hypothesis, build a targeted simulation or formal check for that exact sequence. Close with how you would screen parts already shipped, and whether a firmware workaround is possible.
29. A netlist simulation fails on a test that passes at RTL, and the waveform shows X values spreading from one flop. How do you work through it?
What it tests: gate-level debug and X handling.
A strong answer: trace the X back to its first appearance. Common sources: a flop without reset that RTL simulation initialized optimistically, a memory model that powers up as X, a timing violation flagged in timing simulation, or an RTL construct (such as a case statement with X-optimistic behavior) that synthesis built differently. Decide whether it is a real hardware problem, a missing reset or initialization, or a simulation artifact, and fix the right thing. Note that X-pessimism and X-optimism differ between RTL and gate level. See GLS interview questions and zero-delay simulation.
30. A full-chip simulation hangs. How do you find where?
What it tests: system-level debug.
A strong answer: list outstanding transactions per interface, check credit counters and FIFO levels, and look for a cycle of waits, which signals deadlock. Protocol checkers on interconnect ports narrow it quickly. If needed, bisect by replacing blocks with models. Report whether it is a design deadlock or a testbench that never sends what the design waits for.
31. An AI assistant wrote some RTL and tests for your block. How would you decide whether to trust them?
What it tests: a 2026 question about judgment with new tools.
A strong answer: treat the output like code from a new team member. Run lint, CDC and synthesis checks, review it against the spec line by line, and verify it with checks written independently, not by the same tool that wrote the design. Use formal properties or equivalence checks where possible, and measure coverage. Be clear about IP and confidentiality rules for what you share with the tool.
DFT, test and silicon bring-up
32. A design has 2 million scan flops, 16 scan channels and 100x compression, shifting at 100 MHz. Estimate test time for 5,000 patterns.
What it tests: quick test cost arithmetic.
A strong answer: 16 channels times 100 gives 1,600 internal chains of about 1,250 flops each. Each pattern needs about 1,250 shift cycles, or 12.5 microseconds, since load and unload overlap. 5,000 patterns take about 62.5 ms plus capture cycles and setup. Then discuss what moves it: more channels, higher shift speed (limited by power), or fewer patterns. Compare with scan test time calculation.
33. Parts fail during scan shift but pass in function. What is going on?
What it tests: test power awareness.
A strong answer: shift toggles far more flops than functional operation, causing voltage droop and heat. Use low-power fill for don't-care bits, lower the shift frequency, stagger clocks across chains, or partition the test. Check also for hold problems on the scan path itself, which appear at any speed.
34. Stuck-at coverage is stuck at 93% and the target is 99%. How do you find the missing coverage?
What it tests: DFT analysis, not just running ATPG harder.
A strong answer: break the untested faults down by class: tied or constant logic, logic around black-boxed memories and analog blocks, uncontrollable clocks or resets, non-scan flops, and X sources that mask observation. Each class has its own fix: test points, wrappers or bypass logic around memories, test-mode control of clocks and resets, and X blocking. Estimate how much coverage each fix buys, and agree with the design team which RTL changes are acceptable this late.
35. First silicon will not boot. What do you check, in order?
What it tests: calm, structured bring-up.
A strong answer: supplies and current draw, then clocks and PLL lock, then reset release. Next, JTAG ID read and scan chain integrity, then memory BIST, then the boot ROM path with any debug trace available. Compare each step with simulation and keep a log. Name the decision points where you would involve the board, package or firmware teams.
36. Yield on a new product is 15 points below plan. How does test help find out why?
What it tests: linking test data to the fab and the design.
A strong answer: start with a Pareto of failing test bins, then look at wafer maps for spatial patterns: edge, center, one reticle position or scratch lines each point to different causes. Run scan diagnosis on failing parts and combine the results across many dies to find a repeated cell, net or layout feature. Memory bitmaps separate single bits from rows, columns and blocks. Correlate with process data, and feed systematic layout causes back as design rules or DFM fixes.
Physical design and advanced nodes
37. A block met timing in synthesis but is badly congested after placement. What do you do?
What it tests: placement judgment.
A strong answer: find the hotspot type: cell density, pin density near complex cells, or narrow channels between macros. Fixes include moving macros and widening channels, placement blockages, reducing high pin-count cells, and physically aware synthesis. If the logic structure is the cause, such as a large crossbar, go back to the RTL owner. See the effect of whitespace and aspect ratio.
38. Late in the project, the router cannot finish a congested block without DRC violations, and timing degrades with every reroute. What do you do?
What it tests: knowing when to stop iterating and change the input.
A strong answer: look at where the violations cluster and why: pin access on dense cells, a narrow channel between macros, or a high-fanout net crossing the block. Repeated reroutes rarely fix a structural problem. Options, from cheapest: local cell spreading and blockages, swapping to cells with easier pin access, moving or rotating a macro, adding a routing layer to the block if the stack allows, and, if the logic is the cause, asking for an RTL change such as duplicating a heavily loaded register. Estimate the schedule cost of each and decide with the project lead.
39. What changes for physical design with backside power delivery?
What it tests: keeping up with process roadmaps.
A strong answer: moving power to the back of the wafer frees front-side tracks for signals and shortens the path from supply to transistor, which helps voltage drop. It also changes power grid design, extraction and thermal behavior, and makes some failure analysis and debug from the back harder. Be honest about what you have and have not used in production.
40. A logic bug is found after tape-out preparation. How do you plan a metal-only ECO?
What it tests: late-stage fixes.
A strong answer: make the RTL fix, generate the ECO netlist change, and map it onto spare cells or gate array fillers using only metal layers. Check with logic equivalence against the fixed RTL, rerun timing and physical checks, and confirm the change fits the available spares near the logic. Keep a written record of every ECO.
41. Dynamic voltage drop analysis shows a large droop in one region during a specific vector. What do you do?
What it tests: judgment on power integrity, not just adding decap.
A strong answer: first ask whether the vector is realistic: a scan or worst-case vector may switch far more logic than any real workload. If it is real, find what switches together, often a clock gating release waking a large block or a burst of memory accesses. Options: add decoupling capacitance, strengthen the grid locally, spread high-activity cells, stagger clock enables or slow the wake-up. Rerun timing with voltage-aware analysis to confirm the paths in that region still pass.
Chiplets, memory and AI systems
42. Would you split this large SoC into chiplets? How do you decide?
What it tests: system trade-offs.
A strong answer: chiplets help when the die approaches the reticle limit, when yield on one large die is poor, or when parts are better on different nodes. They cost die-to-die interface area, power and latency, package cost, known good die testing and more complex verification. Decide which interfaces cross the boundary, their bandwidth and latency needs, and whether a standard such as UCIe fits. See what chiplets are and how they assemble.
43. Estimate the memory bandwidth needed to run a 70-billion-parameter language model at 20 tokens per second, batch size 1, with 8-bit weights.
What it tests: back-of-envelope sizing for AI hardware.
A strong answer: at batch 1, each new token reads roughly all the weights once: about 70 GB. Twenty tokens a second needs about 1.4 TB/s, before the key-value cache and activations. That rules out a single standard DRAM channel and points to HBM, several memory devices, or batching to reuse weights. The model memory sizer on The Semiconductor Hub helps with the capacity side.
44. Adding a second thread on a shared-cache CPU barely speeds up a workload. How do you find out whether the hardware is to blame?
What it tests: performance analysis across hardware and software.
A strong answer: read the performance counters: cache misses, coherence traffic, memory bandwidth used and stall cycles. Heavy coherence traffic between the cores often means false sharing, where two threads write different data in the same cache line. Saturated memory bandwidth means the workload was already memory-bound. Long lock waits point to software. Show how you would test each hypothesis with a small benchmark before blaming the design. More in Top 50 CPU architecture interview questions.
45. Your accelerator reaches only 30% of its peak compute on a target workload. How do you find the limit?
What it tests: performance analysis.
A strong answer: compute the workload's arithmetic intensity, operations per byte moved, and place it on a roofline against the chip's peak compute and memory bandwidth. If it sits under the memory roof, the fix is data reuse, tiling, compression or more bandwidth, not more compute. If it sits under the compute roof, look at utilization: pipeline stalls, poor mapping or synchronization. The roofline model tool on The Semiconductor Hub shows the method.
Judgment and leadership scenarios
46. Three weeks before tape-out, a key customer asks for a feature change. What do you do?
What it tests: risk-based decisions.
A strong answer: size the change quickly: RTL, verification, timing and physical impact, and what it puts at risk. Lay out options, such as a configurable path behind a disable bit, a firmware solution, or the next stepping, each with its risk and date. Let the business decide with facts, and write the decision down.
47. You disagree with the architect's choice for a key block. How do you handle it?
What it tests: influence without authority.
A strong answer: bring data, not opinion: a quick model, a prototype result or a comparison table. Raise it early, in the right forum, and listen for constraints you did not know. If the decision stands, commit to it fully and record the risk. Interviewers look for respect and evidence, not for who was right.
48. Two teams blame each other for a failure at their shared interface. How do you resolve it?
What it tests: getting to facts across teams.
A strong answer: put a protocol checker on the interface and capture the failing transaction. Compare it with the written spec. Often the spec is ambiguous, and both teams read it correctly in different ways. Fix the spec, then the design, and add the case to both teams' regressions.
49. You are asked to plan verification for a new IP with a fixed date. Where do you start?
What it tests: planning under constraint.
A strong answer: list the features from the spec and rank them by risk and by customer use. Decide what simulation, formal and reuse will cover, estimate effort per item, and compare it with the people and time available. Agree on what can be cut or deferred before the work starts, and define the sign-off criteria in advance.
50. Tell us about the hardest bug you have found.
What it tests: how you think, and whether you learn.
A strong answer: use a clear structure: the symptom, the hypotheses you considered, how you narrowed them down, the root cause, the fix and what you changed so it would not recur. Keep it specific and technical, and give credit to others where due. Our posts on the 5 Whys for root cause analysis and biases in problem solving help with the structure.
How to prepare
- Practice out loud. Work three or four of the number problems on paper, then explain them in two minutes each.
- Prepare three stories. A hard bug, a disagreement, and a schedule trade-off. Most scenario questions map to one of them.
- Refresh one area outside your role. A verification engineer who can talk about timing, or a physical designer who understands CDC, stands out.
- Be clear on confidentiality. Describe your past work in general terms and never share a former employer's internal details.
For deeper lists by discipline, see our Top 50 RTL design and micro-architecture questions, Top 50 IP and full chip verification questions, Top 50 DFT questions, Top 50 physical design questions and Top 50 VLSI interview questions.
Conclusion
At mid-career, the panel already assumes you know the basics. What they test is whether you check assumptions, work the numbers, see the risk and choose a sensible path. Practice the questions above with that in mind, and your answers will show judgment, which is what experienced hires are paid for.
The answers above are outlines, not complete solutions; different companies, nodes and flows will add their own details. Questions are representative of common interview topics and are not taken from any company's actual interviews.


Your comments will be moderated before it appears here.