RTL Design / Module 12: Career & Interview
Lesson 12.1 · Portfolio

Present your I2C project like a hiring manager expects

You finished Module 11 — you have synthesizable RTL, a self-checking TB, and a design review. Now the hard part: making a stranger care in two minutes. Hiring managers don't want a protocol lecture. They want evidence you can own a block, defend trade-offs, and ship.

What interviewers actually score

Can you explain why you split CSR / byte FSM / bit engine? Can you show verification proof? Do you know what's missing? "I coded I2C" fails all three.

1

The 2-minute story arc

Every strong project pitch follows the same five beats. Practice until you can deliver this without slides in 90–120 seconds, then pause for questions.

Interview pitch story arc

Five beats, fixed time budget. Don't skip verification or gaps — that's where senior engineers listen hardest.

Problem→Architecture→RTL choices→Evidence→Gaps
BeatWhat to sayLink to Module 11
Problem"SoC needs a low-pin-count sensor bus. I2C is open-drain, multi-drop, software-programmable rate."11.1 Protocol
Architecture"Three layers: CSR for SW, byte FSM for protocol, bit engine for pad timing."11.3 Architecture
RTL choices"Open-drain oe pads, CLKDIV for rate, ABORT path, NACK in STAT."11.4 RTL
Verification"Self-checking TB: write+ACK, NACK, abort — all PASS."11.5 TB
Improve"Next: clock stretch + SDA 2-FF sync — documented in review."11.6 Review
2

Sample script — read aloud three times

Customize names and numbers, but keep the structure. Time yourself — if you're over 2:30, cut protocol detail.

pitch_script.txt — 2-minute version
"I built a synthesizable I2C master as a capstone block — the kind of peripheral
you'd hang off an APB or AHB bus in a sensor SoC.

The problem: software needs to talk to EEPROMs and IMUs over two wires with
programmable clock rate and clean error reporting.

Architecture: three layers. CSR holds ADDR, TXDATA, CLKDIV, and control bits.
A byte FSM sequences START, address byte, data byte, ACK checks, and STOP.
The bit engine bit-bangs open-drain SCL and SDA with output-enable — that's
the pad-safe pattern from our open-drain lesson.

Key RTL choices: I separated protocol sequencing from bit timing so the FSM
stays readable. NACK sets a status flag instead of hanging the bus. ABORT
returns to IDLE within a few cycles. CLKDIV gives software rate control without
re-synthesis.

Verification: self-checking testbench with three directed tests — happy-path
write with ACK, wrong-address NACK, and mid-transaction abort. All pass.
I attached a waveform showing START, ACK sample, and STOP.

What I'd improve for silicon: clock stretching for slow slaves, a 2-FF
synchronizer on sda_i, and a read path. I documented those gaps in my
one-page design review rather than pretending v1 is tape-out ready.

Happy to walk through the byte FSM or the CSR map."
Delivery tip

Point at a waveform or block diagram while you speak beats 2–4. Interviewers remember visuals; they forget verbatim Verilog.

3

Portfolio repo checklist

Your GitHub (or portfolio folder) is the artifact behind the pitch. A hiring manager may clone it before the interview.

  • README.md — one-paragraph summary, block diagram image, how to run sim, expected PASS output
  • rtl/ — i2c_csr.v, i2c_byte_fsm.v, i2c_bit_engine.v, i2c_master_top.v (matches 11.4)
  • tb/ — self-checking testbench with clear test names
  • docs/ — CSR map (from 11.2), design review PDF/markdown
  • waves/ — one PNG with START / ACK / STOP labeled (from TEST 1)
  • LICENSE — MIT or Apache-2.0 so reviewers can share internally
  • No secrets — no employer IP, no copied commercial RTL
Suggested repo layout: i2c-master-capstone/ ├── README.md ← start here (diagram + run instructions) ├── rtl/ │ ├── i2c_csr.v │ ├── i2c_byte_fsm.v │ ├── i2c_bit_engine.v │ └── i2c_master_top.v ├── tb/i2c_master_tb.v ├── docs/csr_map.md ├── docs/design_review.md └── waves/test1_write_ack.png
README sectionMinimum content
OverviewWhat bus role, what transactions supported, what's explicitly out of scope
ArchitectureThree-layer diagram — link to your 11.3 mental model
CSR mapTable of offsets — CTRL, STAT, ADDR, TXDATA, CLKDIV
Run simExact command + expected last line: === ALL I2C TESTS PASSED ===
Known gapsBullet list — stretch, read, 10-bit, multi-master, SDA sync
WaveformEmbedded image with 2-sentence narrative
▶ Re-run your capstone in the simulator
4

Waveform screenshot narrative

A raw waveform without labels is useless. Annotate these events on your PNG:

  1. START — SDA falls while SCL high
  2. Address byte — 8 bits MSB-first on SDA, SCL toggling
  3. ACK slot — master releases SDA (oe=0), slave pulls low
  4. Data byte — same pattern
  5. STOP — SDA rises while SCL high

Caption template: "TEST 1: write 0x3C to slave 0x50. Red markers: START, ACK after address, ACK after data, STOP. STAT.DONE asserts 2 cycles after STOP."

Connect back to timing diagram literacy and waveform debug method — interviewers may ask you to sketch this from memory.

5

Anti-patterns — what kills your credibility

Anti-pattern 1

"I coded I2C." — Says nothing about architecture, verification, or trade-offs. Replace with the five-beat pitch.

Anti-pattern 2

Protocol lecture with no RTL. — Interviewers aren't hiring you to recite the spec. They want your FSM, your CSR, your error paths.

Anti-pattern 3

Claiming tape-out ready. — v1 has known gaps. Say "FPGA-lab ready with documented CDC waiver" instead.

Anti-pattern 4

No sim instructions. — If the reviewer can't run === ALL I2C TESTS PASSED === in 5 minutes, they assume it doesn't work.

Anti-pattern 5

Blaming the testbench when asked about NACK. — NACK is a feature. Explain STAT.NACK and your directed test 2.

Weak phraseStrong replacement
"It mostly works""Three directed tests pass; gaps are documented in design review Section 6"
"I2C is easy""Simple protocol, but pad timing and error paths need careful FSM design"
"I used AI to write it""I own the architecture and can walk every FSM state — ask me anything"
"Fully verified""Directed verification of write, NACK, abort — no coverage closure yet"
6

Hiring manager scorecard

Interviewers often use a mental rubric like this. Score yourself before the interview — target ≥16/20.

#Criterion012
1Clear problem statementVaguePartialSoC context + bus role
2Architecture explanationCan't drawOne layerThree layers + interfaces
3RTL trade-off reasoning"It works"One choiceoe pads, CLKDIV, ABORT, NACK
4Verification evidenceNoneManual simSelf-checking TB + PASS log
5Honest gapsDenies gapsLists one≥3 with priority order
6Waveform literacyNo wavesUnlabeledAnnotated START/ACK/STOP
7CSR / software interfaceUnknownNames regsExplains START pulse + STAT poll
8CDC / pad awarenessSilent"It's slow"sda_i sampling + sync plan
9Response to "what's hardest?"GenericProtocolBit timing + open-drain + ACK sample
10Portfolio artifact qualityNo repoCode onlyREADME + review + waves

16–20: Strong portfolio story. 10–15: Fix README and rehearse pitch. Below 10: Finish 11.6 review pack before interviewing.

7

Follow-up questions — rehearse answers

❓

"Draw the byte FSM."

IDLE → START → ADDR → ACK_CHK → DATA → ACK_CHK → STOP → IDLE. ABORT from any state. See safe FSM design.

❓

"Why separate bit engine?"

FSM reasons about bytes; bit engine owns SCL phase and oe timing. Single responsibility — easier lint and reuse.

❓

"Biggest silicon risk?"

Async sda_i without 2-FF sync; missing clock stretch. Both in review gaps with v1.1 plan.

❓

"How would you add read?"

Byte FSM rd phase, shift in on TX_BIT, load RXDATA CSR, master NACK on last byte.

8

Design review as interview prop

Bring your 11.6 one-page review to the interview (printed or on tablet). Walk sections 1–7 in 3 minutes when they say "tell me about a project."

How to use the review doc live

Page 1: block diagram — "three layers, software polls STAT."

Page 1: lint summary — "no latches, no multi-drive on oe."

Page 1: CDC — "sample when SCL high; gap documented."

Page 1: gaps — "stretch first, then read path."

Senior engineer signal

Listing gaps before the interviewer asks is the single highest-trust move in a junior RTL interview. It shows you think like a reviewer, not just a coder.

9

Phone screen vs onsite — adjust depth

StageTimeFocusBring
Recruiter screen15 minOne-line project summary + role fitResume, GitHub link
Hiring manager30–45 minFull 2-min pitch + architecture deep diveBlock diagram, review doc
Technical onsite45–60 minWhiteboard FSM + verification + gapsLaptop with sim ready
Panel / team fit30 minCollaboration, review culture, learning speedExtension roadmap (v1.1/v1.2)

Phone screen script (30 sec): "I built an I2C master capstone — CSR, byte FSM, bit engine, self-checking TB, design review with documented gaps. Happy to go deeper on architecture or verification in the next round."

Onsite tip

Offer to run sim live: === ALL I2C TESTS PASSED === in 30 seconds beats 10 minutes of verbal description. Have the command in your README and terminal history ready.

10

STAR format for behavioral + technical mix

Some interviewers blend behavioral and technical. Map your capstone to STAR:

STARI2C capstone example
SituationCourse capstone required a complete peripheral block with verification and review sign-off
TaskDesign synthesizable I2C master with CSR, error handling, and self-checking TB
ActionSplit into three layers; wrote directed tests for NACK/abort; documented CDC gap honestly
ResultAll tests PASS; one-page review approved; identified clock stretch as v1.1 priority
STAR trap

Don't make Result vague ("it worked"). Quantify: "3 directed tests, 0 lint errors, review signed off with 4 documented gaps."

11

Connect earlier modules to your story

Weave these course topics into follow-ups — shows breadth beyond I2C:

TopicHow to mention in I2C context
Blocking vs non-blocking"All sequential logic uses <=; TB uses blocking for stimulus"
Latches / multi-drive"Lint-clean: oe only driven by bit engine; IOBUF at pad"
CDC sync"sda_i gap — would add 2-FF per our CDC lesson"
Self-checking TB"Checker tasks compare slave model vs expected — no manual wave squinting"
FPGA vs ASIC"Behavioral pads in sim; IOBUF + constraints for FPGA build"
Handshakes"STAT.DONE is level status; START is single-cycle pulse — classic req/ack variant"
Specification"One-page spec drove CSR offsets before I wrote RTL — spec-first workflow"
12

Mock interview drill — 20-minute self-test

Set a timer. No notes for the first pass; use notes on retry.

  1. 0:00–2:00 — Deliver full pitch from Section 2 without stopping
  2. 2:00–5:00 — Draw three-layer block diagram on paper
  3. 5:00–8:00 — Sketch byte FSM states; label ABORT path
  4. 8:00–12:00 — Explain NACK test + expected STAT bits
  5. 12:00–15:00 — List 3 gaps + which you'd fix first and why
  6. 15:00–20:00 — Open repo README — can you find sim command in <30s?
  • Pitch under 2:30 without "um" more than twice
  • Block diagram has all three layers labeled
  • Can explain open-drain in one sentence
  • Waveform PNG exists and is labeled
  • Design review PDF/markdown is linked in README

Pass criteria: Complete all 6 steps without opening RTL source. If you need the code to answer, you don't own the design yet — revisit 11.3 and rehearse again.

13

Common interviewer objections — responses

ObjectionStrong response
"This is just a course project.""It's structured like industry IP: spec, RTL, TB, review. I can extend it — v1.1 clock stretch is scoped."
"No industry experience.""True for employment years — but I have end-to-end block ownership evidence. What would you want to see in a take-home?"
"I2C is too simple.""The protocol is — the engineering is in pad modeling, error paths, and review discipline. Happy to discuss harder blocks I've studied in the course."
"Did you use AI?""I used the course curriculum and can defend every FSM state and CSR bit. Ask me to modify CLKDIV behavior live."

🎯 What to remember

  • Five beats: problem → architecture → RTL choices → verification → honest gaps.
  • Portfolio = README + runnable sim + waveform narrative + design review.
  • Never lead with "I coded I2C" — lead with ownership and evidence.
  • Use the hiring manager scorecard — rehearse until ≥16/20.
  • Module 12.2 covers whiteboard RTL patterns you'll get as follow-ups.
Advertisement