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

AboutContactPrivacyTerms
Skip to lesson

Course contents

  • How to Use This Course
  • Reading Paths
  • Concept Map
  • Meet DCRouter
  • Glossary
  • Part 0: What Verification Is8
  • Part 1: What Can Go Wrong11
  • Part 2: Specifications as Checkable Rules8
  • Part 3: Observability and Controllability7
  • Part 4: Stimulus11
  • Part 5: Checking11
  • Part 6: Coverage10
  • Part 7: Formal and Simulation10
  • Part 8: Verification Levels and Reuse8
  • Part 9: Planning and Risk9
    • The Verification Plan
    • Feature Extraction
    • Risk-Based Prioritisation
    • Estimating Effort
    • Metrics and Their Traps
    • Regression Strategy
    • Managing Change
    • Planning DCRouter
    • Drills: Planning and Risk
  • Part 10: Emulation and Prototyping8
  • Part 11: Post-Silicon Validation8
  • Part 12: Bug Economics8
  • Part 13: Debug7
  • Part 14: Sign-Off7
  • Part 15: Verification in Context8
  • Part 16: Case Studies5
  • Part 17: Capstones5
  • Part 18: Interview Preparation6
Loading lesson

‹Part 9: Planning and Risk
  1. Topics
  2. First Principles of Verification Strategy
  3. Part 9: Planning and Risk
  4. The Verification Plan

Part 9 · Planning and Risk · Senior (S)

The Verification Plan

A verification plan states what will be verified, how, at which level, with what evidence, in what order and when it counts as done. It is written for several readers at once: engineers who execute it, designers who review it, managers who schedule it and the sign-off board who judge against it. What a good plan contains, and what separates a plan from a test list.

On this page

    Note

    Level: Senior (S) · Answers: What should we verify first, and how much?

    Before this: Part 9 overview, Requirements Traceability

    A new verification lead inherits a project with 1,800 tests, a coverage database and a spreadsheet called "vplan" that lists test names. Asked what the tests are meant to prove, which requirements are still unverified and when the block will be done, nobody can answer from the spreadsheet. It records what was built, not what was intended. The lead's first job is to write the plan the project never had.

    What is a verification plan, and what should it contain?

    The obvious answer, and why it breaks

    The obvious plan is a list of tests to write. A test list describes activity, not intent: it cannot show that a requirement has no test, that two tests check the same thing, that a feature needs formal rather than simulation, or what "done" means. A plan starts from what must be true about the design and works down to how each truth will be shown.

    The idea: intent, method, evidence, order, done

    Section

    Answers

    Lessons that feed it

    Scope and references

    Which design, which specification versions, what is out of scope

    Part 2

    Features and rules

    Every requirement, numbered, with its source

    Lessons 2.2, 9.2

    Risk and priority

    Which features matter most and are most likely to be wrong

    Lesson 9.3

    Method and level per feature

    Directed, random, formal, emulation; block, subsystem or chip

    Parts 4, 7, 8

    Checks and coverage per feature

    How a wrong behaviour is detected; how exercise is measured

    Parts 5, 6

    Environment and resources

    Testbenches, VIP, models, tools, people

    Lesson 8.4

    Schedule and milestones

    What is verified by when; estimates with uncertainty

    Lesson 9.4

    Metrics and done criteria

    What evidence closes each feature; what signs off the block

    Lessons 9.5, Part 14

    Change process

    How late changes are assessed and re-verified

    Lesson 9.7

    One plan, several readers

    Reader

    Needs from the plan

    Verification engineers

    What to build and check, in what order

    Designers and architects

    Whether their intent was understood: they review the features and rules

    Managers

    Effort, schedule and risk, honestly stated

    Sign-off reviewers

    The criteria the evidence will be judged against, agreed in advance

    Later teams (derivatives, silicon validation)

    What was verified, how, and what was waived

    Properties of a plan that works

    • Traceable: every feature to the specification, every check and bin to a feature (lesson 2.6).

    • Prioritised: the riskiest features first, not the easiest.

    • Living: updated as the specification, the design and the findings change; versioned with them.

    • Measurable: each feature's "done" is a piece of evidence, not an opinion.

    • Reviewed: by designers and architects before work starts, when corrections are cheap.

    How real teams run plans

    Practice

    Purpose

    Plans in a structured format linked to coverage and test results

    Status computed, not reported by hand

    Plan reviews with design and architecture at the start

    Misunderstood intent caught before testbenches are written

    Plan versions tied to specification versions

    Changes in intent visible as plan changes

    What breaks

    The opening story (illustrative) is common: a test list that grew for two years with no plan behind it. When the lead mapped tests to the specification, a quarter of the requirements had no test, a third of the tests overlapped heavily, and two features nobody had planned were verified only by accident. Three weeks of planning redirected more effort than the previous three months of test writing.

    Why this matters

    Principal lens. Ask to see the plan before the tests: features traced to the specification, risk, method and level per feature, checks and coverage, done criteria and a change process. A project without one is busy, not verifying; a plan is the only artefact that can show what is still unproven.

    Interview

    Asked: "What is in a verification plan?"

    Weak answer: A list of the tests we will write.

    Strong answer: What must be true and how we'll show it. Scope and references; every feature and rule, numbered and traced to the spec; risk and priority; the method and level for each feature (directed, random, formal, emulation; block, subsystem, chip); the checks and coverage that make each feature's evidence; environment and resources; schedule with honest estimates; metrics and done criteria agreed with sign-off; and a change process. It's reviewed by designers at the start and kept current, so status can be computed from it.

    Follow-ups: (1) Who should review a plan? (2) How is a plan different from a test list?

    Check yourself Why can't a test list show that a requirement is unverified?

    It lists what exists; a requirement with no test simply does not appear, while a plan starting from the requirements shows it with an empty evidence column.

    Check yourself Why should done criteria be agreed with sign-off reviewers at the start?

    So the evidence is gathered against criteria everyone accepted, instead of argued over at the end when changing course is expensive.

    Key takeaways

    • A plan states intent, method, evidence, priority and done for every feature; a test list only records activity.

    • It serves engineers, designers, managers, sign-off and later teams at once.

    • Keep it traceable, prioritised, measurable, reviewed and current.

    Keep going

    Next: Lesson 9.2, Feature Extraction. Breaking a specification into verifiable features.

    Related topics

    • Part 9 overview: Planning and Risk

    Previous

    90 / 160

    Next: Feature Extraction

    Up next

    Up nextFeature Extraction

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Risk-Based Prioritisation
    • Estimating Effort
    • Metrics and Their Traps