100 Electrical Engineering Research Topics for Undergraduates

If you are looking for electrical engineering research topics for undergraduates, I recommend starting with a topic that has a clear baseline and defensible measurements. This list gives you 100 beginner friendly options across communications, signal processing, control, power electronics, embedded systems, energy systems, machines, instrumentation, and data driven methods. Some topics are simulation-first, some need light lab work, and some can be done with a microcontroller and a small set of sensors.

I keep the topics practical because undergraduate research is judged by evidence. I look for results you can quantify and defend, such as lower RMS error, higher efficiency, improved stability margins, reduced total harmonic distortion, lower bit error rate, faster detection, or better classification scores.

• Communications and channel modelling
• Signal processing and data driven evaluation
• Control systems, modelling, and identification
• Power electronics, converters, and practical circuit design
• Measurement, instrumentation, calibration, and data quality
• Embedded systems, firmware experiments, and IoT systems
• Energy systems, smart grids, forecasting, and grid analytics
• Machines, drives, mechatronics, and thermal behaviour
• Materials, components, antennas, and physical hardware studies
• Protection, cybersecurity, fault analytics, and optimization

How to Choose an Electrical Engineering Undergraduate Topic

Before I pick a topic, I confirm four constraints. If any one of these fails, I narrow the scope or change the topic.

• Can I collect or generate data in 1 to 2 weeks? This can be logged sensor data, a small lab run, a simulation dataset, or public time series.
• Can I analyze it with tools I already know? I use Python, MATLAB, Octave, SPICE, or spreadsheets, but I avoid adding new toolchains late.
• Is the scope small enough for an undergraduate timeline? I keep one main variable and one system, not multiple subsystems and features.
• Can I measure an outcome? I choose metrics that I can plot and compare, such as BER, RMSE, THD, overshoot, settling time, efficiency, latency, packet loss, or F1 score.

Quick rule: If I cannot define a baseline and two metrics in five minutes, the topic is still too vague.

100 Electrical Engineering Research Topics for Undergraduates

Communications and channel modelling

1. BPSK versus QPSK under AWGN: Measure BER at 1e-3 and 1e-5 and the required SNR, and you will need Python or Octave.
2. Rayleigh fading impact on BER: Measure SNR penalty at a target BER and outage probability, and you will need Python or MATLAB.
3. Hamming versus convolutional coding benchmark: Measure coding gain at a target BER and throughput penalty, and you will need a channel coding simulation in Python or Octave.
4. OFDM PAPR reduction with clipping: Measure the PAPR CDF and BER impact after mitigation, and you will need Python with an OFDM simulation.
5. Timing offset sensitivity in OFDM: Measure BER versus timing offset and the offset threshold that breaks synchronization, and you will need Python or MATLAB.
6. Carrier frequency offset study: Measure BER versus CFO and EVM, and you will need MATLAB or Python.
7. MMSE versus ZF equalization: Measure BER and a noise enhancement proxy, and you will need Python or MATLAB.
8. CRC versus no CRC for packet reliability: Measure undetected error probability and overhead, and you will need Python.
9. ARQ retransmission tradeoff: Measure throughput, latency, and packet success rate, and you will need a packet-level simulation in Python.
10. 16-QAM versus QPSK under identical bandwidth: Measure BER and spectral efficiency at matched SNR, and you will need a baseband simulation in Python or MATLAB.

Signal processing and data driven evaluation

11. Window functions in FFT leakage: Measure amplitude estimation error and leakage level, and you will need Python or Octave.
12. FIR versus IIR filter for the same specification: Measure stopband attenuation and group delay, and you will need Python or MATLAB.
13. Notch versus adaptive filter for tonal noise: Measure SNR improvement and a distortion proxy, and you will need Python DSP code.
14. Wavelet denoising parameter study: Measure SNR improvement and runtime, and you will need Python.
15. Spectrogram settings tradeoff: Measure time resolution and frequency resolution and event detectability, and you will need Python.
16. Matched filter versus threshold detector: Measure precision and recall and detection delay, and you will need Python.
17. Peak detection methods comparison: Measure false alarms per hour and timing error, and you will need Python.
18. Kalman versus EMA for sensor smoothing: Measure RMSE versus lag and noise attenuation, and you will need Python.
19. Feature engineering ablation for classification: Measure F1 score and compute cost, and you will need Python with scikit-learn.
20. Data imbalance handling study: Measure minority-class F1 and PR AUC, and you will need Python.

Control systems, modelling, and identification

21. PI versus PID on DC motor speed control: Measure overshoot and settling time and steady-state error, and you will need an Arduino, a tachometer, and Python for plotting.
22. Lead compensator versus PID for phase margin target: Measure achieved phase margin and rise time and robustness to parameter drift, and you will need MATLAB or Python control libraries.
23. Anti-windup methods under actuator saturation: Measure recovery time after saturation and overshoot reduction, and you will need a control simulation in Python or Octave.
24. Discrete versus continuous controller implementation: Measure stability margins and transient response differences across sampling times, and you will need MATLAB or Octave.
25. LQR versus PID on the same plant: Measure tracking RMSE and control effort, and you will need MATLAB or Python.
26. Disturbance rejection benchmarking: Measure peak error under disturbance and recovery time, and you will need simulation tools.
27. Observer based control versus raw feedback: Measure estimation RMSE and closed-loop tracking error, and you will need MATLAB or Python.
28. System identification from step response: Measure model fit RMSE and prediction error on new data, and you will need Python curve fitting or Octave.
29. Model predictive control lite versus PID: Measure constraint violations and tracking error, and you will need MATLAB or Python.
30. Robustness to parameter drift: Measure performance degradation versus parameter variation and stability margin reduction, and you will need a simulation environment.

Power electronics, converters, and practical circuit design

31. Buck converter switching frequency sweep: Measure output ripple and an efficiency proxy and peak switch stress, and you will need LTspice and Python for plotting.
32. Snubber RC versus RCD comparison: Measure peak voltage reduction and added loss proxy, and you will need SPICE.
33. Diode versus synchronous rectification crossover: Measure efficiency versus load current and the threshold current where synchronous rectification wins, and you will need datasheet models and SPICE.
34. Capacitor ESR sensitivity study: Measure ripple change and transient overshoot sensitivity to ESR, and you will need SPICE.
35. Inverter PWM SPWM versus SVPWM (simulation-first): Measure THD and dominant harmonic magnitudes, and you will need MATLAB or Python with FFT analysis.
36. Power factor correction concept comparison: Measure power factor and input current THD, and you will need a simulation model in SPICE or MATLAB.
37. Thermal model validation for MOSFET heatsinking: Measure predicted versus measured temperature rise and model error, and you will need datasheets, a temperature sensor, and Python.
38. PCB decoupling placement study (lab or simulation): Measure supply ripple and an EMI proxy in the frequency domain, and you will need SPICE with an oscilloscope optional.
39. Op-amp filter topology comparison: Measure cutoff accuracy and Q sensitivity and output noise, and you will need SPICE.
40. Comparator hysteresis design for noisy signals: Measure false trigger rate and response delay, and you will need SPICE or a breadboard test.

Measurement, instrumentation, calibration, and data quality

41. ADC resolution versus measurement quality: Measure quantization error and an ENOB estimate and repeatability, and you will need a microcontroller ADC and Python.
42. Anti-aliasing filter choice study: Measure alias amplitude versus cutoff choice and passband distortion, and you will need SPICE and FFT code.
43. Current sensor bandwidth characterization: Measure rise-time tracking error and phase delay proxy, and you will need a current sensor and logging.
44. Temperature sensor time constant estimation: Measure the fitted time constant and fit RMSE for a step response, and you will need sensor logging and Python.
45. Noise characterization of a sensor front end: Measure RMS noise and spectral peaks and SNR, and you will need Python FFT tools with an oscilloscope optional.
46. Calibration model comparison: Measure RMSE and max error and residual patterns, and you will need Python or spreadsheets.
47. Repeatability versus reproducibility experiment: Measure within-day variance and between-day variance and confidence bounds, and you will need any repeatable setup and logging.
48. Contact resistance trending for connectors: Measure drift rate and detection sensitivity and false positives, and you will need a multimeter and repeated measurements.
49. Drift detection CUSUM versus rolling statistics: Measure detection delay and false alarms per day, and you will need Python.
50. Sensor fusion with two sensors: Measure RMSE versus a reference and robustness to spikes, and you will need two sensors, a microcontroller, and Python.

Embedded systems, firmware experiments, and IoT systems

51. IoT environmental monitoring node design: Measure power consumption and uptime and packet loss, and you will need an ESP32, an MQTT broker, and Python.
52. Edge versus cloud processing comparison: Measure latency and energy per inference proxy and accuracy, and you will need a microcontroller or SBC and Python.
53. Sleep scheduling for battery life: Measure average current draw and wake latency and data loss risk, and you will need a microcontroller and a multimeter.
54. Interrupt versus polling timing study: Measure jitter and missed events and CPU load proxy, and you will need a microcontroller and logging.
55. Debounce algorithm benchmarking: Measure false triggers and latency and CPU cycles, and you will need a microcontroller.
56. Simple data compression for sensor logs: Measure compression ratio and reconstruction error and runtime, and you will need Python.
57. Time synchronization in sensor networks: Measure clock drift and timestamp error over time, and you will need two or more devices and NTP style synchronization.
58. LoRa versus Wi-Fi telemetry tradeoff: Measure range and packet success rate and energy per message, and you will need a LoRa module, an ESP32, and logging.
59. Bluetooth Low Energy advertisement tuning: Measure discovery latency and power draw and connection success rate, and you will need a BLE development board.
60. Secure firmware update concept evaluation: Measure update success rate and rollback reliability, and you will need a microcontroller and a signing or hashing library.

Energy systems, smart grids, forecasting, and grid analytics

61. PV output forecasting persistence versus regression: Measure MAE and RMSE and bias by time of day, and you will need a PV dataset and Python.
62. Load profile clustering for households: Measure cluster quality and stability across weeks, and you will need Python.
63. Anomaly detection in smart meter data: Measure precision and recall and false alarms per day, and you will need Python.
64. Non-intrusive load monitoring feature study: Measure F1 score and generalization across days, and you will need a NILM dataset and Python.
65. Harmonic distortion estimation sensitivity: Measure THD variation versus window length and sampling settings, and you will need FFT analysis in Python.
66. Transformer equivalent circuit parameter extraction: Measure parameter fit error and predicted voltage regulation error, and you will need test data or synthetic data and Python.
67. Microgrid load shedding strategy comparison: Measure unserved energy and recovery time and number of load trips, and you will need simulation tools.
68. Demand response algorithm study: Measure peak reduction and customer comfort proxy and stability, and you will need a load dataset and Python.
69. Islanding detection methods comparison (simulation-first): Measure detection time and false positives, and you will need MATLAB or Python.
70. Battery state of charge estimation comparison: Measure SoC error under variable loads and drift over time, and you will need a dataset or a low-voltage test rig and Python.

Machines, drives, mechatronics, and thermal behaviour

71. Brushless DC motor commutation method study: Measure speed ripple and efficiency proxy and torque ripple proxy, and you will need a BLDC motor setup and logging.
72. Stepper motor microstepping versus full step: Measure positional error and vibration proxy and power draw, and you will need a stepper driver with an IMU optional.
73. Motor fault detection from vibration features: Measure classification accuracy and false alarm rate, and you will need a vibration dataset or an accelerometer and Python.
74. Induction motor parameter estimation (simulation or lab): Measure model fit error and sensitivity to load, and you will need MATLAB or Python.
75. Acoustic noise reduction techniques in small motors: Measure spectral peak reduction and overall noise level proxy, and you will need a microphone and Python FFT.
76. Drive derating algorithm based on temperature: Measure overheating events avoided and performance loss, and you will need a temperature sensor and a microcontroller.
77. Encoder versus sensorless speed estimation: Measure speed RMSE and robustness to load changes, and you will need a motor, a sensorless estimator, and logging.
78. Regenerative braking control concept (simulation-first): Measure recovered energy and stability under braking profiles, and you will need simulation tools.
79. Thermal management study for a small enclosure: Measure temperature rise and time to steady state and cooling effectiveness, and you will need sensors and logging.
80. Reliability test planning for a simple circuit: Measure failure rate estimate sensitivity and confidence bounds, and you will need Python with optional stress testing.

Materials, components, antennas, and physical hardware studies

81. Conductive ink formulation screening (lab optional): Measure resistivity and adhesion and durability under bending, and you will need basic materials and a multimeter.
82. Dielectric material comparison for capacitors (low voltage): Measure leakage current and capacitance stability over time, and you will need an LCR meter or a multimeter method.
83. Insulation material aging under heat: Measure resistance drift and breakdown proxy and visual degradation, and you will need a heat source and a multimeter.
84. Piezoelectric energy harvesting prototype: Measure power output versus load and efficiency proxy, and you will need a piezo element and a rectifier circuit with an oscilloscope optional.
85. EMI shielding effectiveness study: Measure attenuation in dB across frequency, and you will need an SDR or a spectrum analyzer if available.
86. Antenna miniaturization tradeoff (simulation-first): Measure return loss and bandwidth and efficiency, and you will need an EM simulator or a validated open-source tool.
87. IoT antenna placement sensitivity: Measure RSSI and packet loss versus placement and orientation, and you will need a Wi-Fi or BLE device and logging.
88. Wireless sensor calibration drift with environment: Measure drift rate and correction effectiveness, and you will need sensors and repeated logs.
89. Printed circuit trace resistance versus temperature: Measure resistance slope versus temperature and model fit, and you will need a multimeter and a controlled heat source.
90. Solder joint quality influence on resistance and noise: Measure resistance variance and noise RMS, and you will need a simple measurement setup and repeated samples.

Protection, cybersecurity, fault analytics, and optimization

91. Cybersecurity in smart grids concept study: Measure detection precision and response latency on simulated events, and you will need synthetic logs and Python.
92. Intrusion detection for IoT traffic (dataset-first): Measure ROC AUC and false positive rate, and you will need Python and a network traffic dataset.
93. Fault location in distribution lines (simulation-first): Measure location error and detection time, and you will need MATLAB or Python.
94. Digital relay logic evaluation: Measure trip time and selectivity and false trip rate, and you will need a protection simulation model.
95. Load forecasting model comparison: Measure MAE and RMSE and peak error, and you will need a load dataset and Python.
96. Energy theft detection anomaly study: Measure precision and recall and cost savings proxy, and you will need a smart meter dataset and Python.
97. Predictive maintenance from current signature: Measure classification F1 and robustness to noise, and you will need a dataset and Python.
98. PLC versus wireless for rural telemetry (simulation or small lab): Measure latency and packet delivery ratio and reliability under noise, and you will need two communication setups and logging.
99. Human activity recognition with IMU: Measure accuracy and F1 score and energy per inference proxy, and you will need an IMU, a microcontroller, and Python.
100. Multi-objective optimization for converter design (simulation-first): Measure Pareto front quality and the efficiency versus ripple tradeoff, and you will need Python optimization libraries.

Undergraduate Electrical Engineering Research Proposal (Template + Examples)

If a lecturer asks for a proposal, I use the structure below because it is short, defensible, and easy to grade.

What the Proposal Must Include (Minimum)

• Proposed title
• Background and problem statement
• Objectives (3 to 5)
• Research questions or hypotheses
• Scope and limitations
• Methodology (data, variables, tools, analysis plan)
• Expected outputs or deliverables
• Timeline (8 to 10 weeks)
• References

Undergraduate Proposal Template (Copy and Paste)

Proposed Title:
Comparison of [A] versus [B] for [metric] under [conditions] using [method or tool].

Background (150 to 250 words):
Briefly explain the system, the practical problem, and why the comparison or measurement matters.

Problem Statement (1 to 3 sentences):
State the gap you will address and what will be measured or improved.

Objectives:

• To measure [primary metric] for [baseline] and [proposed method] under [conditions].
• To compare [A] versus [B] using [metric 1] and [metric 2].
• To analyze the trade-off between [goal 1] and [goal 2] and recommend [best choice] for [use case].

Research Questions:

• Which option performs better, [A] or [B], under [condition]?
• How sensitive is performance to [parameter]?
• What is the best operating region given the measured trade-offs?

Scope and Limitations:
Define the system boundary, the dataset or hardware setup, the parameter ranges, the time window, and what will not be covered.

Methodology (bullet format):

• Study type: comparative, experimental, simulation, or dataset-based evaluation
• Data source: logged measurements, public dataset, synthetic simulation, or controlled lab test
• Variables:
  • Independent: [X]
  • Dependent: [Y]
  • Controls: [C]
• Tools: [Python or MATLAB or Octave or SPICE] plus any hardware used
• Analysis plan: baseline comparison, parameter sweep, statistical summary, plots, and sensitivity checks

Expected Outputs or Deliverables:
Plots and tables, a comparison report, a validated model, a prototype demo, and a short recommendation based on results.

References:
Support your background and methodology with peer-reviewed journal or conference papers (e.g., search in IEEE Xplore or Google Scholar).

Timeline (8 to 10 weeks):
Week 1 topic selection and baseline definition, Week 2 literature scan and methodology, Weeks 3 to 4 data collection or simulation, Weeks 5 to 6 analysis and plots, Weeks 7 to 8 writing and revision, Weeks 9 to 10 final edits and submission.

3 Proposal Examples (Undergraduate-Friendly)

Example 1, communications (simulation-first):

• Title: BPSK versus QPSK under AWGN by BER and required SNR using Python
• Data: synthetic bit streams and channel noise in simulation
• Analysis: BER curves, required SNR at target BER, sensitivity checks
• Deliverable: plots, comparison table, recommendation by target reliability

Example 2, instrumentation (microcontroller plus sensor):

• Title: Kalman versus EMA for sensor smoothing by RMSE versus lag using Python
• Data: logged sensor data with a simple reference or repeatable input
• Analysis: error metrics, lag estimation, robustness to spikes
• Deliverable: filter comparison report and recommended settings

Example 3, power electronics (simulation-first):

• Title: Buck converter switching frequency sweep by ripple and stress metrics using SPICE
• Data: SPICE simulations across frequency and load points
• Analysis: ripple measurements, peak stress, efficiency proxy, sensitivity plots
• Deliverable: recommended operating region and design guidance

How I Turn Any Topic Into a Strong Research Question

• Comparative: Which performs better, A or B, under condition C?
• Impact: How does X affect Y in Z system?
• Assessment: What is the current performance, risk, or quality of X in Z context?
• Optimization: What value of X minimizes Y or maximizes performance under constraints?

Recommended Structure for an Undergraduate Electrical Engineering Paper

1. Introduction
2. Literature review
3. Methodology
4. Results
5. Discussion, including limitations
6. Conclusion and recommendations
7. References

FAQ

Are these topics suitable for undergraduate electrical engineering students?
Yes. I selected these topics to be realistic for undergraduate timelines and typical access to tools such as Python, MATLAB, Octave, SPICE, and basic microcontroller kits.

Can I do an electrical engineering research topic without a lab?
Yes. Many topics are simulation-first or dataset-first, so you can validate results using plots and metrics such as BER, RMSE, THD, settling time, efficiency, and F1 score.

What makes a topic “undergraduate friendly” in electrical engineering?
A topic is undergraduate friendly when it has a clear baseline, one main variable, and two to three measurable metrics, so the methodology and results are easy to defend.

How do I choose the best topic from the list?
I recommend choosing the topic that you can collect or generate data for within 1 to 2 weeks, and then writing the baseline and two success metrics before you build anything.

Do I need hardware for these topics?
Not always. If you do not have hardware access, choose simulation-first or dataset-first items. If you do have hardware access, keep it minimal by using one microcontroller and one or two sensors.

Can I turn a topic into a capstone project?
Yes. To make a topic capstone-friendly, add a concrete deliverable such as a prototype, a tested design, a comparison report with recommendations, or a small decision tool.

What metrics should I include in my results section?
I recommend using metrics that match the topic type, such as BER and EVM for communications, RMSE and lag for filtering, overshoot and settling time for control, THD and efficiency for power electronics, and accuracy and F1 score for classification.

Are there safety concerns I should avoid as an undergraduate?
Yes. If a topic involves mains voltage, high power converters, or lithium battery charging, I recommend a simulation-first approach or a supervised low-voltage setup with proper safety equipment.