1. LandOffer
  2. Blog
  3. All articles
  4. FPGA Portfolio for Job Applications: Show RTL, a Testbench, and Waveform Evidence

Job search

FPGA Portfolio for Job Applications: Show RTL, a Testbench, and Waveform Evidence

Build a reviewable RTL portfolio with complete counter code, fifteen directed checks, actual VCD transitions and a deliberately caught defect.

9 min readLandOffer team

An FPGA portfolio becomes easier to assess when a reviewer can follow one claim from the RTL to a failing check and a recorded signal transition. A board photograph or source file alone leaves a reviewer without the expected behavior and the check that tested it. Start with a small design whose intended behavior fits in a paragraph, then provide enough evidence for someone else to challenge it.

This guide includes an original enabled counter, a complete self-checking testbench, actual Icarus Verilog simulation results, and a deliberately broken variant. The example demonstrates a reviewable RTL workflow. It does not establish device timing, synthesis results, or board operation. Compare the evidence with requirements in recent LandOffer.ai job listings before deciding which missing project stage would help your application.

Developer examining a small unpowered circuit board beside an evidence notebook and abstract signal traces.

Choose a claim that your files can support

For an entry-level RTL or verification application, a compact project can reveal how you specify behavior, drive stimulus, detect errors and explain results. For a role centered on timing closure or board bring-up, the same project leaves substantial requirements unaddressed. Read the deliverable in the posting: a verified module, a constrained implementation and a functioning physical interface require different evidence.

AMD's current UG900 documentation distinguishes RTL behavioral simulation, performed before synthesis or implementation, from post-implementation simulation, which can include timing behavior. Our counter run used source-level simulation only. A clock toggling every five simulated nanoseconds does not show that an FPGA implementation meets a 100 MHz constraint.

The official documentation was reviewed on October 23, 2026. The worked files and observed command results below are original local teaching artifacts, not an employer project or a vendor benchmark. No FPGA, vendor implementation tool or waveform GUI was tested for this article.

Worked example one: give a counter an explicit contract

Here is the complete behavioral contract: a three-bit counter updates on a rising clock edge; synchronous active-high reset takes priority over enable; enable advances the count modulo eight; disabling enable holds the previous value. Startup count is unspecified until a reset edge. That last sentence matters because assigning an initial zero in the testbench would hide the design's actual initialization behavior.

Save this complete module as enabled_counter.sv:

`timescale 1ns/1ps
module enabled_counter(input logic clk, input logic reset, input logic enable, output logic [2:0] count);
  // Single clock, synchronous active-high reset; reset has priority over enable.
  always_ff @(posedge clk) begin
    if (reset) count <= 3'd0;
    else if (enable) count <= count + 3'd1;
  end
endmodule

The absence of a final else is intentional for this clocked process: the registered count retains its value when neither reset nor enable applies. Reset is synchronous because the process responds to the positive clock edge. An asynchronous-reset design would need a different specification and corresponding tests.

Save the complete companion file as counter_tb.sv:

`timescale 1ns/1ps
module counter_tb;
  logic clk=0, reset=0, enable=0;
  logic [2:0] count;
  integer checks=0;
  enabled_counter dut(.*);
  always #5 clk=~clk;
  task step(input logic r,input logic en,input logic [2:0] expected,input string label);
    logic [2:0] before_edge;
    @(negedge clk); before_edge=count;reset=r;enable=en;
    // Check synchronous reset only after a known value exists.
    #1;
    if (checks>0 && count !== before_edge) $fatal(1,"changed between clock edges: %s",label);
    @(posedge clk);#1;
    if (count !== expected) $fatal(1,"%s expected=%0d actual=%0d",label,expected,count);
    checks=checks+1;
    $display("CHECK %0d t=%0t reset=%0b enable=%0b count=%0d %s",checks,$time,reset,enable,count,label);
  endtask
  initial begin
    $dumpfile("counter.vcd");$dumpvars(0,counter_tb);
    step(1,1,0,"reset priority from startup");
    step(0,1,1,"first increment");step(0,1,2,"second increment");
    step(0,0,2,"hold disabled");step(0,1,3,"resume");
    step(0,1,4,"increment 4");step(0,1,5,"increment 5");
    step(0,1,6,"increment 6");step(0,1,7,"maximum");
    step(0,1,0,"modulo 8 rollover");step(0,0,0,"hold after rollover");
    step(0,1,1,"increment after rollover");step(1,1,0,"synchronous reset while enabled");
    step(0,1,1,"restart after reset");step(0,0,1,"final hold");
    $display("PASS: %0d directed checks; RTL simulation only",checks);$finish;
  end
  initial begin #1000;$fatal(1,"watchdog timeout");end
endmodule

Each step call supplies a literal expected value and a behavior label. The sequence includes startup reset with enable asserted, two initial increments, a disabled hold, resumption, the maximum value, rollover, another hold, reset during operation and restart. The expected results are visible for review rather than calculated with the same update expression as the DUT.

Inputs change at a falling edge. The task checks one nanosecond later that a previously known count has not changed, then compares the output one nanosecond after the following rising edge. This separates stimulus from sampling and allows the clocked assignment to settle. These are selected interedge checks, not a continuous assertion that every possible off-edge transition is impossible.

The first such check is skipped while count is unknown. Case inequality in the output comparison also prevents an unknown value from quietly satisfying the expected numeric result. The watchdog terminates a hung run, although this particular sequence completed before its timeout.

Run the test and retain the result

With Icarus Verilog installed, run from the directory containing both files:

iverilog -V
vvp -V
iverilog -g2012 -Wall -s counter_tb -o counter.vvp enabled_counter.sv counter_tb.sv
vvp counter.vvp

Icarus separates compilation from execution: iverilog produces a simulation program and vvp runs it. Its command-line documentation identifies -g2012 as the SystemVerilog language selection and -s as the top-module selection. -Wall enables a documented group of warnings; it is not proof that every potential defect has been checked.

The saved version commands identify Icarus Verilog 13.0 stable for both compiler and runtime. Compilation returned zero with no stderr output; execution returned zero and printed:

CHECK 9 t=96000 reset=0 enable=1 count=7 maximum
CHECK 10 t=106000 reset=0 enable=1 count=0 modulo 8 rollover
CHECK 13 t=136000 reset=1 enable=1 count=0 synchronous reset while enabled
PASS: 15 directed checks; RTL simulation only

The saved simulation.log contains all fifteen successful comparisons. Keep the exit code alongside the log so a reviewer can distinguish a finished passing run from a few successful checks followed by a fatal error. The number fifteen describes this directed sequence, not a coverage percentage, proof over all input combinations or certification of the design.

Worked example two: connect a waveform to a caught defect

The testbench writes counter.vcd with $dumpfile and $dumpvars. The VVP documentation describes VCD as the default trace format for these dumps. Here, the original VCD remains available together with an SVG rendered from its actual transitions and a JSON event listing. The editorial illustrations on this page are conceptual artwork, not simulation captures.

A magnifying glass over a contrasting counting bead, with notebooks suggesting code and signal inspection.

The file declares a one-picosecond timescale; the companion SVG labels its horizontal axis in nanoseconds. Divide a raw timestamp by 1,000 before comparing it with the table below. The testbench's printed t=106000 is 106 ns, one nanosecond after the 105 ns rising edge that changes the count.

Selected interval or edge Actual recorded behavior Interpretation
Before 15 ns Count remains unknown The DUT has not yet received a resetting rising edge.
Reset asserted at 10 ns; rising edge at 15 ns Count becomes zero at 15 ns Consistent with synchronous reset and reset priority in this case.
Enable falls at 40 ns; rising edge at 45 ns Count holds two The disabled cycle does not increment.
Rising edges at 95 ns and 105 ns Count changes to seven, then zero The three-bit value rolls over under continued enable.
Reset asserted at 130 ns; rising edge at 135 ns Count changes from one to zero at 135 ns Reset during operation takes effect at the next clock edge.
Final rising edge at 155 ns Count holds one The final disabled comparison passes at 156 ns.

At the disabled rising edge at 45 ns, count remains two rather than advancing to three. A VCD records changes, so a held value can span several clock edges without another count entry. Explain the input and clock alongside the bus; a flattened screenshot of count alone would lose that context.

Now challenge the testbench with a specific bug. In a separate negative-control directory, copy the module into counter_saturating.sv and replace its enabled update with:

else if (enable) count <= (count == 3'd7) ? 3'd7 : count + 3'd1;

Keep the module name enabled_counter and reuse the unchanged testbench. Run from that separate directory:

iverilog -g2012 -Wall -s counter_tb -o mutant.vvp counter_saturating.sv ../counter_tb.sv
vvp mutant.vvp

The altered module compiled successfully, but its runtime returned one. Nine comparisons passed before the tenth comparison failed with modulo 8 rollover expected=0 actual=7 at 106000 ps. There is no successful CHECK 10 line in that log. This distinguishes detecting the error from merely generating a visually plausible trace.

This negative control establishes that the current test catches this saturation defect. It does not establish that other defect classes would be detected. For example, the sequence does not exhaust all reset/enable histories, establish formal properties, or test another width. Describe additional tests as future work until you have run them and preserved their results.

Package a project someone else can reproduce

The completed example directory includes both source files, simulation.log, counter.vcd, waveform.svg, waveform-events.json, render-waveform.py, the intentionally broken source and its failure log, plus a reproducibility README. The Python renderer reads the VCD beside its own script and converts picosecond timestamps to a nanosecond axis; its output is derived evidence, while the VCD is the original signal record.

To regenerate the diagram in a working copy, run:

python3 render-waveform.py

The README should distinguish files needed to rebuild from files retained as results. Generated simulator executables may help inspection in the same environment, but source and commands are the reproducibility starting point. Record tool versions, the top module, working directories and expected exit codes. Keep the mutant's dump separate because its testbench also names the output counter.vcd.

Include one concise explanation of an engineering choice. Here, reset priority prevents an enabled cycle from incrementing during reset; the literal expected sequence exposes that priority and the rollover boundary. Also include one known limit: no synthesis, placement, routing, static timing analysis, resource report, bitstream or board test was performed. There is no supported slack, power or device-frequency number to place in a resume bullet.

Before sharing your own repository, remove credentials, private paths, employer material and licensed files you cannot redistribute. For an independently built project, identify borrowed components and your contribution. A public review packet should let someone rerun authorized code without needing access to your work account or a proprietary design tree.

Write the application claim at the demonstrated level

A supported portfolio description for this example is: “Implemented a three-bit enabled counter with synchronous reset; ran fifteen directed checks in Icarus Verilog, documented VCD transitions and demonstrated detection of an intentionally introduced saturation defect.” The linked project should contain the files that make every part of that sentence inspectable.

Avoid adding “timing closed,” “hardware validated” or “production ready” to that sentence. If the role asks for those capabilities, add a separately documented implementation or board stage and state its device, constraints, results and remaining issues. A reviewer can then distinguish the completed stage from the next one you intend to learn.

Choose a project you can explain from requirement through test result, including a result that would make the test fail. Identify a relevant requirement in current LandOffer.ai openings, choose the evidence that addresses it, and keep the remaining gap explicit. A portfolio supports a technical conversation; it cannot guarantee an interview or replace experience the employer specifically requires.

Download the worked example files

Download the companion example files. The archive contains the original educational artifacts discussed above. Review its README and source before running code; fictional inputs and local test results retain the limits stated in this article.

Sources and Further Reading