Practice free

ECE Core Interview Questions for Freshers (2026) — with Answers

Updated August 2026

This set is for the ECE student who wants a core job — electronics, embedded, semiconductor, telecom, instrumentation — rather than the one converting to software. That distinction matters because the preparation is almost entirely different, and almost every placement resource available to you was written for the other path. If you are weighing the switch instead, our ECE-to-CS-or-VLSI guide covers that decision and our community answer on ECE to software covers the final-year version of it. This page assumes you have decided you want the core route.

Two things are worth knowing about how these interviews run before you start revising. First, they go at your own syllabus rather than at a puzzle bank — the questions below are ordinary undergraduate ECE, asked with follow-ups. Second, the follow-up is nearly always "why", or "what did you actually measure". An interviewer who has worked in this field can tell within two questions whether you have handled a circuit or only read about one, and that is the single largest differentiator between candidates with identical transcripts.

So learn each answer as a mechanism you can explain rather than a definition you can recite, and attach a concrete example from your labs or project wherever you can. The questions here are grouped as analog, digital, microcontrollers and embedded, signals and communication, VLSI fundamentals, and the practical questions — which is roughly the order most interviews move in.

Frequently asked questions

What is the difference between a BJT and a MOSFET, and when would you use each?

A BJT is a current-controlled device — base current controls collector current — while a MOSFET is voltage-controlled, with gate voltage controlling the channel. That single difference drives most of the practical consequences: a MOSFET draws essentially no steady gate current so it is trivial to drive from a logic pin and has very high input impedance, while a BJT needs base drive current supplied continuously. In practice MOSFETs dominate switching and digital applications and any power switching where conduction loss matters, since a fully-on MOSFET behaves like a small resistance while a BJT holds a roughly fixed saturation voltage. BJTs remain useful in analog work for their transconductance and low noise in some designs, and in low-cost small-signal switching. If you can add that MOSFET switching loss is dominated by gate charge and transition time, you are answering above fresher level.

What is an operational amplifier, and what do the ideal assumptions actually mean?

An op-amp is a high-gain differential amplifier used almost always with feedback rather than open-loop. The ideal assumptions are infinite open-loop gain, infinite input impedance, zero output impedance and infinite bandwidth. What matters is what they let you do: with negative feedback and very high gain, the amplifier drives its two inputs to nearly the same voltage, which is the virtual short — and because input impedance is very high, essentially no current flows into the inputs. Those two facts alone let you analyse almost every standard configuration by inspection. Say that rather than reciting the list, and be ready for the follow-up about what breaks in a real device: finite gain-bandwidth product, input offset voltage and bias currents, slew rate limiting on fast large signals, and a limited output swing.

Why is negative feedback used so widely?

Because it trades away gain — which is cheap — for properties that are expensive: stability, predictability and linearity. With heavy negative feedback the closed-loop behaviour is set by the feedback network, usually a ratio of resistors, rather than by the device parameters, which vary with temperature, supply and manufacturing spread. It also increases bandwidth, reduces distortion and lets you set input and output impedance by topology. The honest caveat worth adding is the cost: feedback around an amplifier with phase shift can oscillate, which is why stability, phase margin and compensation exist as topics at all. A fresher who mentions that feedback can make a circuit unstable, rather than treating it as free improvement, stands out.

Walk me through a simple DC power supply.

Transformer to step the mains voltage down, rectifier to convert AC to unidirectional, filter capacitor to smooth the pulsating output into DC with some ripple, and a regulator to hold the output steady against changes in input and load. Two details interviewers probe. The capacitor sets ripple: larger capacitance and larger load resistance mean less ripple, and a full-wave rectifier ripples at twice the line frequency so it needs less capacitance than a half-wave one for the same ripple. And a linear regulator dissipates the difference between input and output as heat, which is why the same job is done with a switching regulator when efficiency matters. If you have actually built one in a lab, say what you measured on the scope — the ripple waveform is the thing everyone has seen and few can describe.

Combinational versus sequential circuits?

A combinational circuit's output depends only on its present inputs — adders, multiplexers, decoders, encoders. A sequential circuit's output depends on present inputs and on stored state, so it contains memory elements and almost always a clock. The practical consequence is that combinational logic is analysed with truth tables and Boolean algebra, while sequential logic needs state diagrams and timing analysis, because now the question is not only what the output is but when it is valid. Interviewers usually follow up by asking what limits the speed of a sequential circuit, and the answer is the longest combinational path between registers plus the flip-flop timing requirements — which leads directly into setup and hold time.

What is the difference between a latch and a flip-flop?

A latch is level-sensitive — it is transparent while its enable is asserted, so the output follows the input during that whole period. A flip-flop is edge-triggered, capturing its input only at a clock edge. That difference makes flip-flops the building block of synchronous design, because everything updates at one well-defined instant and timing can be analysed. Latches are used deliberately in some designs but unintended latches are a classic bug: in RTL, an incompletely specified combinational block — a case statement without a default, or an if without an else — infers a latch, which is one of the first things a reviewer looks for. Being able to name that failure mode is worth more than the definition.

Explain setup time and hold time.

Setup time is the interval before the clock edge during which the data input must already be stable; hold time is the interval after the edge during which it must remain stable. Violate either and the flip-flop may go metastable — settling to an unpredictable value after an indeterminate delay — which is a real and serious failure rather than a theoretical one. The two are fixed differently: a setup violation is about the path being too slow, so it can be fixed by slowing the clock or shortening the logic path, while a hold violation is about the path being too fast and slowing the clock does not help at all, which is why buffers are inserted to add delay. That asymmetry is the point of the question. If you can add that crossing between clock domains requires a synchroniser precisely because of metastability, you have answered a level above.

What is a multiplexer, and where would you use one?

A multiplexer selects one of several inputs onto a single output, controlled by select lines — n select lines choose among 2^n inputs. The uses worth naming are practical: routing one of several data sources onto a shared bus, sharing one expensive resource such as an ADC channel or a display across several signals, and implementing arbitrary logic functions, since a mux with the right inputs can realise any truth table. Its complement is the demultiplexer, and a decoder is the related device that activates one of 2^n outputs from an n-bit code, used for address decoding and chip select. Interviewers sometimes ask you to build a specific function from a mux, so practise mapping a truth table onto one.

Synchronous versus asynchronous counters?

In a synchronous counter every flip-flop is clocked by the same clock, so all outputs change together and the maximum speed is set by one flip-flop delay plus the combinational logic that generates the enables. In an asynchronous or ripple counter, each stage clocks the next, so the change propagates through the chain and the delays accumulate — which makes it simpler and cheaper but slower, and produces transient false states while the ripple is in progress. Those transients are the practical problem: decoding the outputs of a ripple counter can produce glitches, which is why synchronous design is standard in anything that matters. State the trade-off in those terms rather than just naming the difference.

Microprocessor versus microcontroller?

A microprocessor is a CPU that needs external memory and peripherals to form a system; a microcontroller integrates CPU, memory and peripherals — timers, ADC, communication interfaces, GPIO — on one chip. The consequence is a difference in purpose rather than in quality. Microcontrollers suit embedded control where cost, size, power and deterministic timing matter and the program is fixed; microprocessors suit general-purpose computing where performance and flexibility matter and an operating system manages resources. If asked to go further, the useful additions are that microcontrollers typically run code from on-chip flash with small RAM, often without an OS or with a small RTOS, and are frequently designed for very low standby power — which is why a battery device uses one.

What happens when an interrupt occurs?

The processor finishes the current instruction, saves enough context to resume — at minimum the program counter and status, with the rest saved by the handler or by hardware depending on architecture — looks up the vector for that interrupt, and jumps to the interrupt service routine. On return, context is restored and execution continues where it left off. What interviewers are really testing is whether you know the rules for writing an ISR: keep it short, do not block or busy-wait in it, avoid anything that can itself be delayed such as printing or waiting on a peripheral, and communicate with the main loop through a flag or buffer rather than doing the work inside the handler. Add priority and nesting if you know the architecture, and mention that shared variables touched by both an ISR and main code need care — which leads straight to the volatile question.

What does the volatile keyword do, and why does embedded code need it?

It tells the compiler that a variable can change outside the flow of the code it can see, so it must not cache the value in a register or optimise away reads of it. Three situations need it and they are the standard answer: a variable modified by an interrupt service routine and read by main code, a memory-mapped hardware register whose value the peripheral changes, and a variable shared with another thread of execution. Without it, a polling loop such as while(flag) can be optimised into an infinite loop because the compiler proves nothing in that loop modifies flag. The important limitation to state if you want to answer well: volatile guarantees the access happens, not that it is atomic — a multi-byte variable shared with an ISR still needs the access protected, which is a different problem with a different fix.

Compare UART, SPI and I2C — when would you use each?

UART is asynchronous and point-to-point: two wires, no clock, both ends configured to the same baud rate, with framing by start and stop bits. Simple and universal, but no shared bus and the clock accuracy must match. SPI is synchronous with a master clock, full duplex, typically four wires plus one chip-select per device, and is the fastest of the three — used where throughput matters, such as displays, memory and ADCs. I2C is synchronous with two wires shared by many devices, each addressed, with open-drain lines and pull-up resistors, so it is the choice when you need several slow peripherals on few pins — sensors, EEPROMs, real-time clocks. State the trade-off explicitly: SPI costs pins and buys speed, I2C costs speed and buys pin count and addressing, UART costs a shared bus and buys simplicity. Mentioning the pull-ups and addressing for I2C signals that you have actually wired one.

What is a timer used for in a microcontroller, and what is PWM?

A timer is a counter driven by a clock, and its usefulness comes from counting independently of the CPU: it can generate periodic interrupts for a scheduler, measure the interval between events by input capture, produce delays without blocking the processor, and drive output compare hardware. PWM — pulse width modulation — uses that compare hardware to produce a square wave with a controlled duty cycle, and the key insight is that the average power delivered follows the duty cycle. That is why it controls motor speed, LED brightness and heater power efficiently: the switch is either fully on or fully off, so it dissipates very little, unlike a linear approach. If you have used PWM in a project, say what frequency you chose and why, since frequency selection is where real understanding shows.

What is a watchdog timer?

A counter that resets the system unless the software periodically refreshes it. It exists because embedded systems run unattended for long periods and can hang — an infinite loop, a lost interrupt, a corrupted state — where a desktop application would simply be restarted by a person. If the main code stops behaving, it stops refreshing the watchdog, and the reset recovers the system. The subtlety worth mentioning is that a watchdog only helps if it is refreshed from a place that proves the system is actually working: refreshing it inside a timer interrupt that keeps running while the main loop is stuck defeats the entire mechanism, and that is a real bug pattern rather than a theoretical one.

What are the different memory types in a microcontroller?

Flash for program code and constants — non-volatile, read quickly, written in blocks with limited erase cycles. SRAM for variables, stack and heap — fast, volatile, and usually the scarcest resource, which is why embedded code avoids large buffers and dynamic allocation. EEPROM, or a flash region emulating it, for small amounts of data that must survive power loss such as calibration values and settings, written byte-wise but slowly and with finite endurance. Registers are the fastest storage, and memory-mapped peripheral registers occupy the address space too. The practical point interviewers like: knowing which section your variables land in — a large const array in flash versus in RAM — is the difference between a program that fits and one that does not.

State the sampling theorem and explain aliasing.

A signal band-limited to a maximum frequency must be sampled at more than twice that frequency to be reconstructed without loss — the Nyquist criterion. If it is not, frequency components above half the sampling rate fold back and appear as lower frequencies indistinguishable from genuine ones, which is aliasing, and it is irreversible: once folded, no processing recovers the original. The practical consequence is the anti-aliasing filter — an analog low-pass filter before the ADC, which must be analog precisely because the damage happens at sampling. The everyday example interviewers accept is a wheel that appears to rotate backwards on video. If you can add that real signals are never perfectly band-limited, so the filter and the sampling rate are chosen with margin, you are answering practically rather than from the textbook.

Why do we modulate a signal at all?

Four reasons, and the first is the one to lead with: antenna size. Efficient radiation requires an antenna comparable to the wavelength, so transmitting a baseband audio signal directly would need an impractically enormous antenna — shifting it to a high carrier frequency makes the antenna reasonable. The others are that modulation allows many signals to share a medium by occupying different frequency bands, which is multiplexing; that higher frequencies offer more available bandwidth; and that some schemes trade bandwidth for noise immunity. On AM versus FM: AM varies amplitude, is simple and bandwidth-efficient but noise adds to amplitude so it is more susceptible; FM varies frequency, uses more bandwidth and gives better noise performance, which is why it is used for quality audio broadcast.

What is quantisation, and what does ADC resolution mean?

Sampling discretises a signal in time; quantisation discretises it in amplitude, mapping each sample to the nearest of a finite set of levels. Resolution is the number of bits, giving 2^n levels, so the step size is the full-scale range divided by 2^n — a 12-bit ADC over a 3.3 V range has steps of roughly 0.8 mV. The error introduced is quantisation noise, and the standard relationship worth knowing is that each additional bit improves the signal-to-noise ratio by about 6 dB. Two practical points that separate a prepared candidate: resolution is not the same as accuracy, since offset, gain error and non-linearity limit how meaningful the last bits are; and the reference voltage sets the absolute meaning of every reading, so a noisy or drifting reference degrades an otherwise good converter.

Why is CMOS used for digital circuits?

Because it draws almost no static power. In a CMOS inverter the pull-up PMOS and pull-down NMOS networks are complementary, so in either stable logic state one path is off and there is no direct path from supply to ground — current flows mainly while switching, to charge and discharge capacitance and briefly as both devices conduct during the transition. That gives dynamic power roughly proportional to capacitance, supply voltage squared and switching frequency, which is why lowering supply voltage is such a powerful lever and why clock gating exists. It also gives full rail-to-rail output swing and good noise margins. The honest modern caveat, if you want to go further, is that leakage current has become significant as devices shrink, so static power is no longer negligible in advanced processes.

Blocking versus non-blocking assignments in Verilog?

Blocking assignment with = executes sequentially within the block, like statements in a normal programming language — each completes before the next begins. Non-blocking assignment with <= evaluates all right-hand sides first and updates the left-hand sides together at the end of the time step, which models what real flip-flops do when a clock edge arrives simultaneously across a design. Hence the rule that matters and that interviewers are testing: use non-blocking in sequential always blocks describing clocked logic, and blocking in combinational blocks. Mixing them produces a design whose simulation and synthesis behaviour differ — the classic hard bug, because the code appears to work in one and fails in the other. Being able to say why the rule exists, rather than only stating it, is the answer they are looking for.

What are the main stages of a VLSI design flow?

At fresher depth: specification, then RTL design in Verilog or VHDL, functional verification by simulation, synthesis into a gate-level netlist against a technology library, then the physical stages — floorplanning, placement, clock tree synthesis and routing — followed by static timing analysis and physical verification such as DRC and LVS, and finally tapeout. Two ideas make this more than a list. Verification is the largest part of real projects, frequently a majority of the effort, which surprises students who assume design dominates. And timing is checked throughout rather than at the end, because a design that meets timing in synthesis can fail after routing when real wire delays appear. Knowing which stage you would want to work in, and why, is a good thing to have an opinion about.

FPGA versus ASIC — what is the trade-off?

An FPGA is a reconfigurable device you program with your design, so the hardware is fixed and the function is not. An ASIC is fabricated for one design. The trade is economics and performance: an FPGA has essentially no non-recurring engineering cost and lets you change the design after manufacture, but each unit is more expensive, slower and more power-hungry than an equivalent ASIC. An ASIC costs an enormous amount to develop and mask, and a mistake means a respin, but it wins decisively on unit cost, speed and power at volume. So FPGAs suit prototyping, low volumes, and applications where the design must evolve; ASICs suit high volume or extreme performance and power requirements. For a fresher, the practical relevance is that FPGA work is far more accessible for projects — and a working FPGA project on your resume is strong evidence for a digital-design interview.

How would you debug a circuit that works intermittently?

This is the question that most reliably separates people who have built things from people who have not, and the marks are for method rather than for a specific answer. Start by making it reproducible — find what changes between working and failing: temperature, movement, supply voltage, a particular input, time since power-on. Then divide the system: check the power rails first with a scope rather than a multimeter, because ripple and droop hide from an averaged reading, then verify signals at boundaries between stages to localise where correct becomes incorrect. Suspect the physical layer early, since intermittency is disproportionately connections — a cold solder joint, a breadboard contact, a loose header, a shared ground with too much resistance. Check whether the failure correlates with something switching, which suggests noise coupling or a supply glitch. And change one thing at a time, writing down what you changed, because the most common way people lose an intermittent fault is by making three changes at once and never learning which mattered.

What instruments have you used, and how would you measure a small AC signal riding on a DC level?

Answer honestly about what you have personally used — oscilloscope, function generator, multimeter, power supply, logic analyser, spectrum analyser if you have — because the follow-up will expose an exaggeration immediately. For the measurement: use an oscilloscope in AC coupling mode, which blocks the DC component so you can increase vertical sensitivity to see the small variation without the trace leaving the screen. Add the details that show real use: keep the probe ground lead short to avoid picking up noise, use ×10 probe setting to reduce loading on the circuit, check the probe is compensated, and be aware that AC coupling has a low-frequency cutoff so it distorts very slow signals. This is precisely the sort of question where one specific true story from a lab beats a page of theory.

What will you be asked about your final-year project?

Expect the interview to spend more time here than anywhere else, and expect the questions to go downwards rather than sideways: not what the project did, but why each choice was made and what you personally built. Which controller did you use and why that one; what were the specifications and did you meet them; what did you measure and with what; what failed the first time and how did you diagnose it; what would you change with another two months. The failure mode is a candidate who describes a group project in the plural throughout — "we interfaced the sensor" — and cannot answer a single specific question about their own part. Prepare your own contribution honestly, including the parts that did not work, because a candidate who says "our filter oscillated and here is what we found" is far more convincing than one whose project apparently went perfectly.

Is a core ECE job realistic, or should I just prepare for software? (2027 batch)

Both routes are real, and the honest framing is that core roles exist and are fewer and more competitive than IT services roles — both halves of that are true, and most advice drops one. What follows is a strategy point rather than a verdict. Core drives are thinner on campus, so the search needs off-campus applications, referrals and companies that never visit your college, and it needs you to consider embedded, semiconductor, telecom, instrumentation, quality and testing roles rather than only glamorous design ones. If you are in the 2027 batch and you want core work, start now on the specific list that opens the embedded door — C to real depth, microcontrollers, interrupts and timers, UART, SPI and I2C, and something you have personally built and debugged — because very few candidates arrive with it, which is exactly why it works. And take one industrial internship if you possibly can. Converting to software is a legitimate decision made deliberately; it is a poor one made because nobody explained that the core route needs a different search.

I am in the 2026 batch applying off-campus now. What is enough preparation?

Enough is: your branch core solid across analog, digital, microcontrollers and communication — the questions on this page, answerable with follow-ups; one specific area prepared more deeply, chosen to match the roles you are applying to, whether that is embedded C and microcontrollers, digital design and Verilog, or communication and signal processing; your final-year project defensible end to end including its failures; and one timed aptitude cycle, since most assessments carry that section regardless of role. That is weeks rather than months for a student with reasonable fundamentals. Two additions with a high return for the time: revise your lab work so you can describe real measurements you took, and prepare a genuine answer to why core rather than IT, because it is asked directly and a vague answer reads as someone whose software applications did not work out.

Don't just read ECE core questions — get asked them

Phiny's AI interviews you on exactly these topics, follows up on weak answers, and tells you what a stronger answer looks like. Text interviews are free and unlimited.

Start a free AI mock interview

How to prepare

Where these questions get asked

Related guides