1-Hour Mixed Course

Spec-Driven Development

Design better, build faster, and ship safer by turning architecture and delivery expectations into executable specifications.

View Curriculum Download Course Pack
Course Snapshot
  • Duration: 60 minutes
  • Audience: Beginner to Intermediate
  • Format: Theory + Hands-on Labs + Quiz
  • Outcome: Feature-level spec-to-release workflow
How to use this course page: Read top to bottom once, then run Labs 1 and 2 with your own feature.
Get worksheets

Learning Outcomes

Write Better Specs

Create clear requirements, constraints, assumptions, and acceptance criteria that engineering can execute without ambiguity.

Build With Traceability

Map each requirement to implementation tasks and tests so every line of delivery has a rationale and validation path.

Validate With Gates

Apply objective release gates before merge and deployment to reduce late rework and production regressions.

Scale Team Consistency

Reuse a standard spec template and review checklist so teams align across architecture, coding, QA, and operations.

Who This Is For

  • Developers writing features from user stories and architecture notes
  • Tech leads who want consistent requirement-to-test traceability
  • QA and DevOps teams enforcing release gates before merge

No advanced tooling required. You can run this workflow using Markdown specs and your existing CI checks.

Before You Start

  • Pick one real backlog item to use as your training feature
  • Have your repo and pull request workflow ready
  • Keep one reviewer available for fast feedback on acceptance criteria
Recommended: 1-2 people pairing Artifact-first workflow 90-minute follow-up sprint trial

Training Scenario (Example)

Use this sample feature if you want a guided practice run:

Feature: Add deployment pre-check endpoint that validates required architecture fields before deployment.

Success Criteria: Endpoint rejects incomplete payloads, logs rule failures, and returns actionable messages.

Release Gate: All acceptance criteria mapped to tests and evidence linked in pull request.

Curriculum (60 Minutes)

Time Module What Learners Do
0:00-0:05 Welcome + Outcomes Understand what Spec-Driven Development changes in daily delivery and what the final artifact will be.
0:05-0:15 Core Concepts Learn the SDD workflow: spec authoring, review, implementation mapping, and acceptance gates.
0:15-0:30 Hands-on Lab 1 Draft a one-page feature specification with requirements, non-functional constraints, dependencies, and rollback plan.
0:30-0:45 Hands-on Lab 2 Convert the spec to implementation tasks and test cases, then create requirement-to-test traceability.
0:45-0:55 Validation + Anti-Patterns Apply release gates and detect common failure modes: vague criteria, hidden dependencies, and unverifiable statements.
0:55-1:00 Quiz + Wrap-up Complete final quiz and capture your action plan to adopt SDD in your next sprint.

Lab 1: Write the Spec

  • Define scope, assumptions, and out-of-scope boundaries.
  • Add functional requirements and measurable non-functional constraints.
  • Specify dependencies, risks, and rollback approach.
  • Produce objective acceptance criteria.
Runbook

1Write the objective in one sentence: what changes and why.

2Define 4-6 requirements and label each one with FR/NFR IDs.

3Write acceptance criteria with measurable thresholds and exact outcomes.

4Add risk + rollback notes before moving to implementation mapping.

Output: A review-ready feature spec with unambiguous acceptance statements.

Lab 2: Build From the Spec

  • Create implementation tasks mapped to each requirement.
  • Write at least one validation method per acceptance criterion.
  • Build a traceability table from requirement to code to test.
  • Run a pre-release gate checklist.
Runbook

1Create task IDs linked to each FR/NFR requirement.

2Add test IDs linked to each acceptance criterion.

3Attach evidence links for test results or validation screenshots.

4Mark each release gate as pass/fail before merge approval.

Output: Traceability matrix and release-ready validation evidence.

If You Only Have 30 Minutes

  • Minute 0-8: Read Learning Outcomes + Curriculum quickly.
  • Minute 8-18: Complete Lab 1 objective, requirements, and acceptance criteria.
  • Minute 18-26: Complete Lab 2 mapping for top 3 requirements.
  • Minute 26-30: Run release gate checklist and identify missing evidence.

Knowledge Check (Real Quiz)

Select one answer per question, then click Check Score for instant results.

1) Requirement ambiguity detection

Which requirement is least ambiguous?

2) Strong vs weak acceptance criteria

Which acceptance criterion is stronger?

3) Traceability mapping

What is missing if requirement FR-03 has code changes but no linked test case?

4) Gate-based release decisions

A release gate fails because rollback steps are not defined. What is the best action?

5) Spec anti-pattern diagnosis

Which line is a spec anti-pattern?

Downloadable full quiz: The complete quiz and answer key are included in the downloadable course pack below.

Frequently Asked Questions

Do we need special tooling to use SDD?

No. Start with a Markdown spec, issue tracker IDs, and your existing test pipeline.

How detailed should one spec be?

Keep it feature-sized. One spec should usually map to one pull request or one sprint deliverable.

What is the most common beginner mistake?

Using subjective language in acceptance criteria without measurable pass/fail thresholds.

Course Pack

Course Outline

Lecture-by-lecture plan with timing and instructor notes.

Open
Lab Worksheet

Lab prompts, deliverables, and completion checklist.

Open
Quiz + Answer Key

10-question assessment with concise rationale per answer.

Open
Spec Template

Reusable template for feature-level spec-driven delivery.

Open

Next Step

After this course, run the template on one real backlog item and enforce acceptance gates during your next pull request review.

View Module Spec Guide Explore Azure Modules