About this course
Engineer software that is correct, testable, and secure by design, integrating quality assurance and application-security practices throughout the development lifecycle.
Course format. Thirteen weeks, four contact hours each: a two-hour lecture (concepts and theory) and a two-hour practice session. The course is project-based; teams carry one running project end to end and present it three times, in weeks 5, 8, and 13.
What you will build
Takes an existing web application with known quality and security weaknesses and engineers it to be secure, thoroughly tested, and reliably observable: produces a formal STRIDE threat model with OWASP remediation evidence; builds a comprehensive automated test suite covering unit, integration, BDD acceptance, consumer-driven contract, browser E2E, mutation, and load tests; integrates Semgrep SAST, OWASP ZAP DAST, and Snyk dependency scanning into a GitHub Actions CI/CD pipeline with enforced quality gates on coverage, mutation-kill-rate, and security scan thresholds; implements feature-flag-controlled progressive delivery; executes chaos experiments with AWS FIS to validate resilience; and establishes SLO-backed observability with DORA metric tracking.
Expected outcomes
- Apply the test automation pyramid and black-box design techniques — equivalence classes, boundary values, decision tables, and pairwise combinatorics — to build unit, integration, BDD acceptance, E2E, and mutation test suites with measurable coverage and mutation-kill-rate targets.
- Write BDD Gherkin specifications with Cucumber and consumer-driven contract tests with Pact, enforcing executable acceptance criteria and cross-service API compatibility as mandatory CI pipeline stages.
- Define SLO-backed performance targets, run load and stress scenarios with k6, and execute chaos engineering experiments with AWS FIS to validate steady-state resilience and scope blast radius.
- Build GitHub Actions pipelines that enforce quality gates on coverage, mutation scores, and security scan results, and measure DORA metrics — deployment frequency, lead time, change failure rate, and mean time to recover — to locate and resolve delivery bottlenecks.
- Produce STRIDE threat models over data-flow diagrams, remediate OWASP Top 10 weaknesses with root-cause evidence, and integrate Semgrep SAST, OWASP ZAP DAST, and Snyk dependency scanning as enforced pipeline stages.
- Manage software supply-chain security by generating SBOMs, auditing transitive dependencies, enforcing signed commits, and applying SLSA provenance attestation to treat the build pipeline as a threat surface.
Key topics
- Automated testing & CI
- Secure coding (OWASP)
- Code review & static analysis
- Reliability & observability
Theoretical foundations
The concepts and results this course rests on.
- Test automation pyramid: unit, integration, and E2E layering; coverage targets and suite composition; cost-of-defect model and the economics of shifting quality left.
- Black-box test design theory: equivalence partitioning, boundary-value analysis, decision tables, and pairwise combinatorics for systematic input-space coverage without access to implementation internals.
- Behaviour-Driven Development: Given-When-Then Gherkin specifications, executable acceptance scenarios, three-amigos discovery workshops, and living documentation as shared language across engineering, QA, and product.
- Performance and load testing theory: configurable ramp-up profiles, p95/p99 SLO targets, spike, soak, and stress test patterns, Apdex score interpretation, and pre-production bottleneck identification.
- Consumer-driven contract testing: schema-compatible provider verification in CI and breaking-change detection across service boundaries before deployment.
- Feature flags and progressive delivery: percentage rollout targeting, user-segment rules, kill switches for instant rollback without redeploy, and trunk-based development at scale.
- DORA metrics as team health signals: deployment frequency, lead time for changes, change failure rate, and mean time to recover — used to locate delivery bottlenecks, not grade individuals.
- Chaos engineering: steady-state hypothesis definition, controlled fault injection, blast-radius scoping, game-day execution playbooks, and post-mortem documentation for systemic learning.
- Threat modeling as a design-time activity: STRIDE categories, data-flow diagrams, trust boundary identification, and mitigation backlog integration before code is written.
- Software supply-chain security: SBOM generation, transitive dependency auditing, signed commits, SLSA provenance attestation, and container image signing — treating the build pipeline as a threat surface.
Prerequisites
This is a Year-3 course. It assumes the mandatory CS core: data structures and algorithms, operating systems, computer networks, databases, software engineering, and the core mathematics (linear algebra, probability and statistics, calculus, discrete mathematics). It additionally requires the specific prior courses listed below.
Course-specific prerequisites:
- Software engineering and object-oriented programming
- Basic computer networks and web applications
Weekly schedule 13 weeks · lecture + practice
Test Fundamentals
Wk 1
Test Automation Pyramid and Shift-Left Quality
LectureCover the test automation pyramid: unit, integration, and E2E layers; coverage targets and suite composition; feedback-loop speed at each tier; and the cost-of-defect model that justifies shifting quality left.
PracticeConfigure pytest, write first unit and integration tests for the project, and record baseline statement and branch coverage.
ProjectRepository set up with a pytest baseline suite; coverage baseline documented.
Wk 2
Black-Box Test Design
LectureTeach black-box test design: equivalence classes, boundary values, decision tables, and pairwise combinatorics for systematic input-space coverage without access to implementation internals.
PracticeDerive test cases from requirements using equivalence partitioning, boundary-value analysis, and decision tables; automate the corresponding browser E2E tests with Playwright, including screenshots and traces as evidence.
ProjectTest-case repository structured by equivalence classes and boundaries; core user-flow E2E tests automated with Playwright evidence.
Wk 3
BDD and Executable Specifications
LectureIntroduce Behaviour-Driven Development: Given-When-Then Gherkin specifications, executable acceptance scenarios, three-amigos discovery workshops, and living documentation as a shared language between engineers, QA, and product.
PracticeWrite Gherkin feature files and implement step definitions using Cucumber; link scenarios to acceptance criteria and run them in the pipeline.
ProjectBDD acceptance scenarios integrated into CI; acceptance criteria mapped to Gherkin scenarios in the traceability matrix.
Wk 4
Performance and Load Testing
LectureExamine performance and load testing strategy: configurable ramp-up profiles, p95/p99 SLO targets, spike, soak, and stress test patterns, Apdex score interpretation, and bottleneck identification before production traffic arrives.
PracticeWrite k6 load scripts with ramp-up, spike, and soak profiles; record baseline p95 latency and throughput against defined SLO thresholds.
ProjectSLO targets defined; k6 baseline results documented; critical-path latency thresholds established for CI gate.
Wk 5
Test Foundations MilestonePresentation
LectureReview test strategy structure, BDD acceptance criteria, SLO definitions, coverage targets, mutation-kill-rate goals, and how each test layer contributes to deployment confidence.
PracticeTeams present their project specification: test-pyramid plan, black-box test matrix, Gherkin acceptance scenarios, k6 SLO baselines, and CI quality-gate roadmap.
ProjectApproved specification with measurable coverage targets, SLO thresholds, and BDD acceptance tests delivered.
Security and Resilience
Wk 6
Threat Modeling and Security Tooling
LectureTeach threat modeling as a design-time activity: STRIDE categories, data-flow diagrams, trust boundary identification, and mitigation backlog integration into sprint planning before code is written.
PracticeProduce a STRIDE threat model of the project using DFDs; integrate Semgrep SAST and OWASP ZAP DAST into the CI pipeline; triage findings and populate the mitigation backlog.
ProjectFormal STRIDE threat model delivered; Semgrep and OWASP ZAP stages gating the pipeline; mitigation backlog created.
Wk 7
Chaos Engineering and Resilience Validation
LectureCover chaos engineering: steady-state hypothesis definition, controlled fault injection, blast-radius scoping, game-day execution playbooks, and post-mortem documentation for systemic learning.
PracticeDefine a steady-state hypothesis for the project; run a controlled fault-injection experiment using AWS FIS; measure impact against the hypothesis and document findings in a post-mortem report.
ProjectChaos experiment executed and documented; resilience gaps identified; remediation items added to backlog.
Wk 8
Security and Resilience MilestonePresentation
LectureReview DAST findings interpretation, dependency risk scoring, the supply-chain threat surface, and how security and resilience evidence feeds release gate decisions.
PracticeTeams present an interim demo: the hardened application, threat model with OWASP remediation evidence, pipeline with SAST and DAST gates, chaos experiment results, and preliminary DORA baselines.
ProjectInterim demo with threat model, remediation evidence, chaos findings, and security pipeline gates demonstrated and defended.
Capstone Integration
Wk 9
Consumer-Driven Contract Testing
LectureIntroduce consumer-driven contract testing: schema-compatible provider verification in CI, breaking-change detection across service boundaries, and catching API incompatibilities between teams before deployment.
PracticeWrite Pact consumer contracts for the project's API boundaries; implement provider verification steps and configure the pipeline to fail on schema violations.
ProjectPact consumer contracts and provider verification integrated into CI; breaking-change detection active on all service boundaries.
Wk 10
Feature Flags and Progressive Delivery
LectureCover feature flags and progressive delivery: percentage rollout targeting, user-segment rules, kill switches for instant rollback without redeploy, A/B experimentation, and trunk-based development at scale.
PracticeImplement feature-flag-controlled rollout in the project; configure GitHub Actions quality gates that block merges on coverage thresholds, mutation-kill-rate minimums, and security scan failures.
ProjectFeature flag infrastructure active; GitHub Actions pipeline enforcing coverage, mutation, and security quality gates on every merge.
Wk 11
DORA Metrics and Delivery Improvement
LectureExplain DORA metrics as team health signals: deployment frequency, lead time for changes, change failure rate, and mean time to recover — measured to locate delivery bottlenecks, not grade individuals; used to drive continuous improvement.
PracticeInstrument the GitHub Actions pipeline to collect and visualize DORA metrics; identify one delivery bottleneck and document an improvement action.
ProjectDORA metric dashboard active; at least one delivery bottleneck identified and improvement action documented.
Wk 12
Software Supply-Chain Security
LectureExamine software supply-chain security: SBOM generation, transitive dependency auditing, signed commits, SLSA provenance attestation, and container image signing — treating the build pipeline itself as a threat surface.
PracticeRun Snyk to audit transitive dependencies and surface CVEs; generate an SBOM; enable signed commits and add SLSA provenance attestation to the pipeline.
ProjectSnyk dependency scan gating CI; SBOM generated; signed commits and provenance attestation enabled.
Capstone
Wk 13
Final Demo and DefensePresentation
LectureSynthesize secure, tested, and resilient software engineering — connect the test pyramid, threat model, chaos findings, supply-chain audit, and DORA trends into a unified quality argument.
PracticeTeams deliver the final demo and oral defense covering: threat model with OWASP remediation evidence, BDD acceptance tests, Pact contract tests, mutation results, k6 SLO attainment, AWS FIS chaos experiment outcomes, feature-flag rollout, DORA trends, and SBOM with supply-chain attestation.
ProjectFinal deliverable: comprehensive test suite, formal STRIDE threat model, Semgrep SAST and OWASP ZAP DAST and Snyk SCA pipeline gates, Pact contracts, chaos evidence, SBOM, feature-flag integration, DORA dashboard, and SLO-backed observability.
AI tools in this course.
Students use AI assistants to generate and refactor application code, then turn the same tools on themselves to find and remediate OWASP Top 10 weaknesses through guided code review. They prompt AI to expand unit, integration, REST API, schema, contract, and browser E2E suites, propose equivalence classes and edge cases, draft exploratory charters, sharpen defect reports, and generate GitHub Actions pipeline steps that wire in Postman/Newman, REST Assured, Karate, Supertest, Schemathesis, Dredd, Playwright, Cypress, Selenium, WebdriverIO, accessibility checks, k6 smoke tests, Semgrep, OWASP ZAP, and dependency scans. Agents connected to repository, browser, API, and scanner MCP servers help triage test failures, browser traces, API request/response logs, SAST findings, and DAST findings, separating real issues from false positives. AI further helps analyze telemetry and error budgets, but every security fix, test, and defect disposition is verified by the team, since vibe-coded changes can quietly introduce new attack surface or false confidence.
Student project
Teams take an existing web application with known quality and security weaknesses and engineer it to be secure, thoroughly tested, and reliably observable. They produce a formal STRIDE threat model, remediate OWASP Top 10 vulnerabilities with root-cause evidence, and build a comprehensive automated test suite spanning unit, integration, BDD acceptance, consumer-driven contract, browser E2E, mutation, and performance layers. They integrate Semgrep SAST, OWASP ZAP DAST, and Snyk dependency scanning into a GitHub Actions CI/CD pipeline with enforced quality gates, implement feature-flag-controlled progressive delivery, execute chaos engineering experiments with AWS FIS to validate resilience, generate an SBOM and enforce SLSA provenance, and establish SLO-backed observability with DORA metric tracking. Security, test quality, and resilience are revisited every week as new risks and regression surfaces emerge.
Requirements
- Work on an existing application with real, documented weaknesses — not a greenfield tutorial project.
- Demonstrate measurable improvement: a formal threat model with remediation evidence, coverage targets met, mutation-kill-rate enforced, and SLO attainment recorded.
- Integrate every tool into a unified CI/CD pipeline with gates that block merges on quality or security failures.
- Carry the project from threat model through test pyramid to chaos experiment to supply-chain audit across the full term.
- Work in a team of three or four and defend the design at each of the three presentations (weeks 5, 8, and 13).
Example projects
Online banking demo appHealthcare records portalE-commerce checkout serviceIdentity and login providerIssue-tracking platformFile-sharing applicationSurvey and forms platformBooking and reservations system
Assessment & grading
Grading is project-based, with no written exam. Teams of three or four present one running project three times.
| Component | What it covers | Weight |
|---|---|---|
| Project · Specification | Presentation 1 (week 5): problem, objectives, and architecture | 20% |
| Project · Interim | Presentation 2 (week 8): the working system demonstrated live | 30% |
| Project · Final | Presentation 3 (week 13): end-to-end demo with oral defense | 50% |
Tools & platforms
- JUnit or pytest: write unit and integration tests
- Mockito or unittest.mock: isolate units with test doubles and mocks
- JaCoCo or coverage.py: measure statement, branch, and line coverage
- Stryker or mutmut: run mutation testing and expose weak assertions
- SonarQube: track code smells, complexity, duplication, maintainability, reliability, and security hotspots
- Allure Report: publish readable automated test evidence
- Playwright, Cypress, Selenium, or WebdriverIO: automate end-to-end browser workflows with screenshots, videos, traces, and selectors
- BrowserStack: run cross-browser and cross-device regression checks
- Robot Framework: express keyword-driven acceptance and regression tests
- Vitest or React Testing Library: automate front-end component tests
- Postman, Bruno, Insomnia, or Hoppscotch: explore REST APIs, save collections, define environments, and document manual checks
- Newman: run Postman REST API collections in CI
- REST Assured, Karate, or Supertest: automate REST API regression, auth, negative, and data-driven tests in code
- OpenAPI: document REST contracts and generate validation targets
- Schemathesis or Dredd: validate and fuzz REST APIs against OpenAPI schemas
- Pact: verify consumer-driven API contracts between services
- axe DevTools: audit accessibility compliance
- k6: run smoke performance and load tests
- Jira or TestRail: manage test cases, defects, and verification status
- GitHub Actions: run continuous integration pipelines
- OWASP ZAP: perform dynamic application security testing
- Semgrep: run static application security testing
- Snyk: scan dependencies for known vulnerabilities
- OWASP Dependency-Check: detect vulnerable libraries
- Trivy: scan images and generate software bill of materials
- OWASP Threat Dragon: build and document threat models
- OpenTelemetry: instrument services for traces and metrics
- Prometheus: collect reliability metrics and define alerts
- Grafana: visualize service level objectives and telemetry
Free online courses
Existing free, video-based courses this course can build on, for self-study or as a teaching basis.
- YouTubeLearn Jenkins by Building a CI/CD Pipeline (Full Course)
- CourseraSecure Coding: SSDLC, OWASP and SonarQube Essentials
- YouTubeTesting JavaScript with Cypress (Full Course)
In Hebrew · בעברית
- Campus ILSuper QA - בודק תוכנה
- Campus ILWebSec - אבטחת יישומי ווב
Primary literature
Seminal works for advanced study.
References
Books and resources link to an online or publisher page.
- DocumentationOWASP Top 10 Web Application Security Risks
- TextbookThreat Modeling: Designing for Security
- TextbookWeb Application Security: Exploitation and Countermeasures for Modern Web Applications, 2nd Edition
- TextbookIntroduction to Software Testing, 2nd Edition
- TextbookFoundations of Software Testing: ISTQB Certification, 4th Edition
- TextbookxUnit Test Patterns: Refactoring Test Code
- TextbookSpecification by Example
- TextbookSoftware Metrics: A Rigorous and Practical Approach, 3rd Edition
- TextbookContinuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation
- TextbookSite Reliability Engineering: How Google Runs Production Systems
- TextbookObservability Engineering: Achieving Production Excellence
- DocumentationSecure Software Development Framework (SSDF) Version 1.1, NIST SP 800-218
Role in each concentration
| Concentration | Role |
|---|---|
| Intelligent Software Systems | Core · Semester 1 |
| Networking & Cyber Security | Core · Semester 1 |
| AI & Robotics | Elective |
| AI and Quantum Computing for Finance | Elective |
| Immersive Systems & Game Development | Elective |
| Defense Technologies & Autonomous Systems | Elective |