EngineersIntermediate

Professional Software Testing Using Visual Studio Training

Test smarter and deliver higher-quality software using Visual Studio and Azure DevOps, in a three-day hands-on course across the full agile testing discipline.

IntermediateAccentientTraditional (Full Day) · Traditional (Half Day)

Course Code: PTVS

Overview

Test smarter and deliver higher-quality software using Visual Studio and Azure DevOps. Delivered over 3 days, this course takes agile teams across the full testing discipline, from planning and tracking quality through development, acceptance, exploratory and release testing, plus reporting and the behaviours that sustain quality. You work hands-on in teams on a common case study, the way a real agile team would.

The course is delivered in a traditional classroom format, as three full days or six half days.

Target Audience

This course is for all members of a software development team, especially those performing testing activities. It is equally valuable for non-testers who want a better understanding of what agile software testing involves:

  • Developers
  • Designers
  • Managers

Some software development experience is recommended. Experience with Visual Studio, Azure DevOps and agile delivery is helpful but not required.

Learning Outcomes

  1. Plan and track quality with test plans, suites and cases in Azure DevOps.
  2. Write development tests in Visual Studio, including test-driven development.
  3. Create manual and automated acceptance tests.
  4. Run exploratory testing and gather stakeholder feedback.
  5. Run automated tests in build and release pipelines.
  6. Report on quality and sustain it with a Definition of Done.

Course Topics

  • Agile Software Testing
    • Agile software development and testing
    • The agile tester and testing practices
    • Agile requirements and acceptance criteria
    • Creating and managing a product backlog
  • Planning and Tracking Quality
    • Defining quality software
    • Planning a sprint with Azure Boards
    • Test plans, suites and cases
    • Parameters, shared steps and bug triage
  • Development Tests
    • Unit testing in Visual Studio
    • Parameterized unit tests and code coverage
    • Test-Driven Development (TDD)
    • Continuous and concurrent unit testing
    • AI-assisted unit testing with GitHub Copilot
  • Acceptance Tests
    • Acceptance testing and ATDD
    • Manual and automated acceptance tests
    • Automating acceptance tests with BDD
    • Performance and load testing
  • Exploratory Tests
    • Introduction to exploratory testing
    • The Test & Feedback extension
    • Capturing data and exploratory tours
    • Requesting and providing stakeholder feedback
  • Build and Release Testing
    • Build pipelines and automated builds
    • Running automated tests in the pipeline
    • Continuous Integration (CI)
    • Release pipelines and deployment
  • Reporting
    • Agile metrics that matter
    • Alerts and notifications
    • The Analytics Service and dashboards
    • Reporting with Excel, Power BI and the OData/REST API
  • Delivering Quality Software
    • Understanding and managing technical debt
    • Defining and obeying a Definition of Done
    • Overcoming dysfunctional team behaviours
    • Becoming a high-performance team

PMI PDUs

Participants are able to claim PMI PDUs for the hours they attend: 21 after 3 days, or 24 after 6 half-days. PDUs are earned for attendance, not for passing an assessment. You claim them yourself in PMI's Continuing Certification Requirements System at ccrs.pmi.org, under Education.

Syllabus

Here is exactly what your team will cover, and how we deliver it. Every format teaches the same modules; what changes is how the time is spread and what happens between sessions:

Traditional (Full Day) RecommendedTraditional (Half Day)
Sessions 3 days 6 half-days
Each session 8h incl. breaks and lunch 4h incl. breaks
Total time with an expert 24h 24h
New concept and practice
incl. breaks
24h 24h
Facilitated reflection
what happened when you tried it
— —
~Expert time per topic
breaks removed
~2h10 ~2h30
Time to apply between sessions Overnight Half a working day (≈4h)

Each immersive session follows a learning cycle: reflect on what happened when you applied the last concept, learn the next one and practise it, then take it back to work as an outcome-based assignment. It is designed for triple-loop learning, so participants do not just change what they do; they question why they do it and how they see their organisation.

Need more support? The immersive experience can be combined with additional coaching, consulting or mentoring to create a Mentor Program for your team.

Choose a format above to see how the modules group into sessions.

Session 1 · Modules 1–3 · 8h incl. breaks · 10m break each hour, 60m lunch

Agile Software Testing

Module 1

Learn a new concept

This module looks at how testing changes when a team delivers in short increments, and at the part a tester plays inside the team. You will look at how requirements and acceptance criteria are captured and how a product backlog is created and kept in order in Azure Boards.
  • Agile development and testing
  • The agile tester
  • Agile testing practices
  • Agile requirements
  • Acceptance criteria
  • Creating and managing a product backlog

Outcome-based assignment: Review a backlog item with testing in mind · Immersive only

Pick one item from your own team’s backlog. Write or improve its acceptance criteria so that someone else could test it, and note which kinds of testing it would need.
→ Reflected on at the start of Module 2: Planning and Tracking Quality

Planning and Tracking Quality

Module 2

Facilitated reflection: Review a backlog item with testing in mind · Immersive only

Facilitated reflection: Review a backlog item with testing in mind

Learn a new concept

This module covers what a team means by quality software and how testing is planned alongside the sprint. You will work with test plans, test suites and test cases in Azure Test Plans, including parameters, shared steps and bug triage.
  • Defining quality software
  • Planning a sprint with Azure Boards
  • Test plans, test suites and test cases
  • Parameters and shared steps
  • Bug triage

Outcome-based assignment: Plan the testing for one sprint · Immersive only

For your team’s current or next sprint, list the backlog items and sketch how the tests for each would be grouped into suites. Note which steps repeat across tests and could be shared.
→ Reflected on at the start of Module 3: Development Tests

Development Tests

Module 3

Facilitated reflection: Plan the testing for one sprint · Immersive only

Facilitated reflection: Plan the testing for one sprint

Learn a new concept

This module covers the tests developers write as they build the code. You will write unit tests in Visual Studio, use parameterised tests and code coverage, practise test-driven development, run tests continuously as you work, and use GitHub Copilot to help write unit tests.
  • Unit testing in Visual Studio
  • Parameterised unit tests
  • Code coverage
  • Test-driven development
  • Continuous and concurrent unit testing
  • AI-assisted unit testing with GitHub Copilot

Outcome-based assignment: Add tests to code you own · Immersive only

Choose a small piece of code in your own product that has few or no tests. Write unit tests for it, check its code coverage, and note what the tests told you about the code.
→ Reflected on at the start of Module 4: Acceptance Tests

Session 2 · Modules 4–6 · 8h incl. breaks · 10m break each hour, 60m lunch

Acceptance Tests

Module 4

Facilitated reflection: Add tests to code you own · Immersive only

Facilitated reflection: Add tests to code you own

Learn a new concept

This module covers testing that a feature does what the customer asked for. You will look at acceptance test-driven development, manual and automated acceptance tests, automating them with behaviour-driven development, and performance and load testing with Azure Load Testing.
  • Acceptance testing
  • Acceptance test-driven development (ATDD)
  • Manual and automated acceptance tests
  • Automating acceptance tests with behaviour-driven development (BDD)
  • Performance and load testing

Outcome-based assignment: Write one feature as examples · Immersive only

Take one backlog item from your own work and write its acceptance criteria as a few Given-When-Then examples. Decide which of them you would automate and which you would keep as manual tests.
→ Reflected on at the start of Module 5: Exploratory Tests

Exploratory Tests

Module 5

Facilitated reflection: Write one feature as examples · Immersive only

Facilitated reflection: Write one feature as examples

Learn a new concept

This module covers exploratory testing as a planned activity rather than ad hoc clicking. You will use the Test & Feedback extension in Chrome or Edge to capture what you find, try exploratory tours, and ask stakeholders for feedback.
  • Exploratory testing
  • The Test & Feedback extension
  • Capturing data during a session
  • Exploratory tours
  • Requesting and providing stakeholder feedback

Outcome-based assignment: Run a short exploratory session · Immersive only

Pick one recent change in your own product. Set yourself a goal and a time limit, explore it, and record what you found and what you would explore next.
→ Reflected on at the start of Module 6: Build and Release Testing

Build and Release Testing

Module 6

Facilitated reflection: Run a short exploratory session · Immersive only

Facilitated reflection: Run a short exploratory session

Learn a new concept

This module covers running tests automatically as code is built and released. You will look at build pipelines, running automated tests and coverage in the pipeline, continuous integration, and release stages and deployment in Azure Pipelines.
  • Build pipelines and automated builds
  • Running automated tests in the pipeline
  • Continuous integration
  • Release pipelines and deployment

Outcome-based assignment: Map the tests in your pipeline · Immersive only

Look at your team’s build and release pipeline. List which tests run at each stage, which do not run at all, and one test you would add to it first.
→ Reflected on at the start of Module 7: Reporting

Session 3 · Modules 7–8 · 8h incl. breaks · 10m break each hour, 60m lunch

Reporting

Module 7

Facilitated reflection: Map the tests in your pipeline · Immersive only

Facilitated reflection: Map the tests in your pipeline

Learn a new concept

This module covers making quality visible to the team and its stakeholders. You will look at agile metrics, alerts and notifications, the Analytics service and dashboards, and reporting through Excel, Power BI and the OData and REST APIs.
  • Agile metrics
  • Alerts and notifications
  • The Analytics service
  • Dashboards
  • Reporting with Excel and Power BI
  • Reporting with the OData and REST APIs

Outcome-based assignment: Choose the quality measures your team needs · Immersive only

Name two or three questions about quality your team or stakeholders ask today. For each, say what data in Azure DevOps could answer it and where you would show it.
→ Reflected on at the start of Module 8: Delivering Quality Software

Delivering Quality Software

Module 8

Facilitated reflection: Choose the quality measures your team needs · Immersive only

Facilitated reflection: Choose the quality measures your team needs

Learn a new concept

This module steps back from tools to the team habits that keep quality high. You will look at understanding and managing technical debt, defining a Definition of Done and keeping to it, overcoming dysfunctional team behaviours, and what it takes to become a high-performance team.
  • Understanding technical debt
  • Managing technical debt
  • Defining a Definition of Done
  • Keeping to the Definition of Done
  • Overcoming dysfunctional team behaviours
  • Becoming a high-performance team

Outcome-based assignment: Check your Definition of Done · Immersive only

Write down your team’s current Definition of Done, or what the team treats as done if none is written. Note one item of technical debt it lets through and one change you would propose to the team.
→ Reflected on at the start of Catchup & After

Catchup & After · Immersive only

Catchup & After

Facilitated reflection: Check your Definition of Done

Facilitated reflection: Check your Definition of Done

Two weeks after completion, participants are invited to join a follow-up catch-up session designed to address any remaining questions, ideas, or challenges that have emerged since the training. This session provides an opportunity to reflect on your experiences applying the concepts learned in the course, share insights, and receive additional support.

* Assignments are part of our Immersive Training Programs, encouraging participants to apply their learning practically between sessions for a more hands-on experience.


Ready to bring this to your team?

Private delivery, fixed price, money-back guarantee. Tell us what you need and we'll put together a proposal.

If this isn't quite right for where you are

Not sure what would actually move the needle?

Most organisations don't need a course catalogue. They need a diagnosis. Tell me what's not working, who is involved, and what you've already tried. I'll tell you honestly whether training will help, and if so, what.