Skip to content
DenseChip
Learn
PracticeCode labInterview

DenseChip

Navigate

Menu

LearnPracticeCode labInterview

Tools

All toolsSV editorCode repoResume
DenseChip

Practice, courses, and chip-design tools in one focused workspace.

LearnPracticeCode labInterviewToolsLearning paths

© 2026 DenseChip

AboutRoadmapCareersInternshipsFAQContactPrivacyTerms
Skip to lesson

Course contents

  • How to Use This Course
  • The NanoSoC Tour
  • Reading Path
  • SoC Glossary10
  • SoC Metrics Reference
  • SoC Cheatsheet
  • What SoC Integration Is12
  • Architecture and Budgets21
  • Memory Maps and Address Decode26
  • Interconnect and Bus Fabrics26
  • Clock and Reset Architecture24
  • Power Architecture21
  • Interrupts, DMA and Peripherals15
  • Memories, Boot and Security21
  • IP Integration and Handoff21
  • Top-Level Verification and Bring-up21
  • Package, Pads and I/O18
  • Chip Signoff and Tapeout18
    • The Signoff Manifest
    • Waiver Governance
    • Closure Dashboards
    • Tapeout Readiness Review
      • Evidence per Owner
      • Go and No-Go
      • Last-Week Surprises
    • ECO and Respin Risk
    • Errata and Post-Silicon
  • SoC Interview Prep16
  • Capstone: Integrate NanoSoC14
Loading lesson

←Tapeout Readiness Review
  1. Topics
  2. SoC Design
  3. Chip Signoff and Tapeout
  4. Tapeout Readiness Review
  5. Go and No-Go
On this page

    Part 12 of 14, lesson 11 of 18Part 12 of 14/Chip Signoff and Tapeout/Lesson 11 of 18All levels

    Go and No-Go

    The decision rule, scored on NanoSoC with four live waivers and one new request, and what each outcome demands.

    Why it matters

    Without a written rule the decision follows the loudest voice: schedule says go, caution says no-go, and the chip goes out on confidence. The rule must exist before the meeting, score the same inputs the same way whoever reads them, and name what happens after each outcome. This lesson writes the NanoSoC rule and scores it against the hard case: four live waivers, one new request and a decision to defend. Its one job is the rule; the surprises that arrive after it is applied are next.

    The core idea

    Go needs four simultaneous truths: the manifest checker green on the signoff candidate, the dashboard with zero reds, every live waiver owned, evidenced and unexpired, and equivalence proven for every netlist including the last ECO. Any single failure is no-go, and no-go names its exit: the missing evidence, the owner, and the date of the reconvene, never an open-ended delay. For anything that changes the database sent to manufacturing, a conditional go does not exist: a go with homework is a no-go with better catering. Items that cannot change that database, such as test-program tuning, the bring-up plan or documentation, may close after release, listed with owner and date in the review record.

    The drill below uses the NanoSoC waiver set on day 182, the signoff-complete date: W-009 (false), W-014 and W-021 (proven safe) and W-027 (bounded risk) are live, evidenced and owned, so their rows stay amber. W-030, a new bounded-risk request against the verification row, arrives without its containment analysis, so that row turns red, and red is no-go with a named exit. The script scores four scenarios, so the rule is shown to return both outcomes.

    example.py
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    # Score go/no-go by rule on day 182. Waiver and metric data are
    # illustrative and extend the same waiver table used in earlier lessons.
    DAY = 182
    metrics = {"timing": "amber", "power": "green", "physical": "green",
               "crossings": "amber", "verification": "amber",
               "connectivity": "green", "equivalence": "green",
               "gate-level-sim": "green"}
    waivers = {  # id: (discipline, evidenced, expiry day)
        "W-009": ("timing", True, 210),
        "W-014": ("crossings", True, 240),
        "W-021": ("timing", True, 320),
        "W-027": ("verification", True, 280),
        "W-030": ("verification", False, 362),   # requested, containment missing
    }
    
    def decide(checker_green, equivalence, metrics, waivers, day):
        rows = dict(metrics)
        bad = []
        for wid, (disc, evidenced, expiry) in sorted(waivers.items()):
            if not evidenced or expiry <= day:
                rows[disc] = "red"               # this waiver turns its row red
                bad.append(wid)
        reds = sorted(d for d, c in rows.items() if c == "red")
        go = checker_green and equivalence and not reds
        return go, reds, bad
    
    go, reds, bad = decide(True, True, metrics, waivers, DAY)
    assert go is False and reds == ["verification"] and bad == ["W-030"]
    # the exit: W-030 containment analysis arrives and is evidenced
    resolved = dict(waivers, **{"W-030": ("verification", True, 362)})
    assert decide(True, True, metrics, resolved, DAY) == (True, [], [])
    # an expired waiver is no-go even with everything else green
    lapsed = dict(resolved, **{"W-009": ("timing", True, 181)})
    assert decide(True, True, metrics, lapsed, DAY) == (False, ["timing"], ["W-009"])
    # a missing equivalence run is no-go whatever the colours say
    assert decide(True, False, metrics, resolved, DAY)[0] is False
    print("PASS: no-go while W-030 lacks containment (owner integrator); go once resolved")

    What the review looks for

    • The rule written on the first page of the review pack, with the four truths as checkboxes.

    • The scored table for the actual inputs, showing which truth failed and the exit it demands.

    • Signatures from every owner on the outcome: a go nobody signed is a rumour.

    Verify and debug

    After a no-go, the reconvene checks only the exit items: the missing containment analysis for W-030, the rerun it requires, nothing else reopened. After a go, the manifest is sealed and any further change is an ECO against a taped baseline. Rehearse the drill quarterly with the real tables even when no tapeout looms; a rule first used under pressure will be misused under pressure.

    The go and no-go decision flow of the readiness review.
    The go and no-go decision flow of the readiness review.

    The go and no-go whiteboard is scored on this shape: classify each waiver by risk and evidence, bound the residual risk, state the decision rule. Candidates who debate the waivers without stating a rule score low on evidence no matter how sharp their classification.

    If asked for your hardest no-go, give a real case in this shape: what was missing (here, one containment analysis), what you refused to accept, and how long the named exit took. Use the NanoSoC W-030 case only if you have no case of your own, and say so.

    Check yourself All metrics green, checker green, equivalence proven, but one waiver expired yesterday. Go?

    No-go. Expired means open, open in any row the dashboard tracks is red, and red is no-go. Re-confirm the waiver with fresh evidence and reconvene.

    Related topics

    • Evidence per Owner

    • Next: Last-Week Surprises

    • Verification: The Tape-Out Review

    • Physical Design: Risk Review and Executive Signoff

    Previous

    242 / 289

    Next: Last-Week Surprises

    Up next

    Up nextLast-Week Surprises

    Sign in to save progress

    Practice this lessonPrevious lessonReport an error