1. Courses
  2. Engineering Roles

Engineering Roles line, station 7 of 8

Test Automation and Quality Engineering

Automate the right tests: unit, API and end-to-end with Playwright, contract and performance tests, all running in CI.

  • 6lessons
  • 4 hto read and do
  • Intermediatelevel
  • 6podcast episodes
  • 12checked exercises
Start the courseCheck what you know

Tools you'll use in this course

The lessons open these with a template ready. They work for your own job too, no course needed.

About this course

Automated tests let a team change code quickly without fear, but only when they are fast, reliable and aimed at the right risks. This course teaches quality engineering: choosing what to automate at which level, writing maintainable tests, and keeping the suite green and trusted in CI.

You build the automated test suite for Mangrove Market's checkout: a strategy that maps checkout risks to test levels, unit tests for price and discount rules, API tests for the order service against a real database, end-to-end tests with Playwright, consumer-driven contract tests between the app and the API, a k6 load test for the festival rush, and a GitHub Actions pipeline that runs in parallel and reports clearly. You also use AI assistants to draft tests and learn to review what they produce.

Every lesson has diagrams, quick checks, a Build it section in TypeScript, practice tasks with JavaScript exercises checked in your browser, flashcards and a podcast episode. The course ends with a capstone project and a final exam for a free certificate.

What you will be able to do

  • Decide what to automate and at which level of the test pyramid
  • Write maintainable unit, API and end-to-end tests
  • Use contract tests to catch breaking API changes early
  • Run load and performance tests and read the results
  • Keep suites fast and stable in CI, and use AI to draft tests safely

Syllabus

6 stops, about 4 h in total. Each stop fills in when you complete the lesson.

  1. A test strategy, not a pile of scripts

    A suite of automated tests helps a team only when it is fast, stable and aimed at the risks that matter. This lesson gives you a method to decide which checks to automate, at which level, and how many minutes the whole suite may cost, using Mangrove Market's checkout as the running example.

    35 minIntermediateEpisode2 exercises

    Test automationTest strategyCI

  2. Unit and API tests

    Most of the checks in a trusted suite are fast unit tests on pure rules and API tests that drive the real service and database. This lesson shows you how to write both for Mangrove's checkout: price rules tested at every boundary, test data that never leaks between tests, and API tests that prove a double tap on Pay creates one order.

    40 minIntermediateEpisode2 exercises

    Test automationAPI testingTypeScript

  3. End-to-end tests with Playwright

    An end-to-end test drives the real web shop in a real browser, the way a customer would. A few of them, aimed at the journeys that make money, catch what no unit test can. Written badly, they become the slow, flaky tests nobody trusts. This lesson shows how to write the good kind with Playwright Test.

    40 minIntermediateEpisode2 exercises

    PlaywrightTest automationTypeScript

  4. Contract tests

    The Mangrove app and the order service ship on different days, and old app versions stay on customers' phones for months. Contract tests check that every version still in use can talk to the next build of the service, in seconds, before anything reaches production.

    35 minIntermediateEpisode2 exercises

    Contract testingAPI testingTypeScript

  5. Performance and load testing

    On festival day Mangrove's checkout gets about four times its normal orders, and every slow second costs carts. This lesson shows you how to turn that rush into a load test with a clear pass or fail: a goal written as an SLO, a workload model built from real numbers, a k6 script that sends load the way customers do, and the habit of reading percentiles, errors and saturation together until you find the bottleneck.

    35 minIntermediateEpisode2 exercises

    Performance testingLoad test designLatency percentiles

  6. Stable suites in CI

    A test suite helps a team only while people believe a red result. This lesson shows you how to keep Mangrove's checkout suite trusted and under ten minutes: find and fix flaky tests, split the work across machines, publish reports people read, and review the tests an AI assistant drafts before they join the suite.

    40 minIntermediateEpisode2 exercises

    CIPlaywrightTest automation

  7. Capstone: Automate the checkout test suite

    A realistic project with a rubric and a model answer.

  8. Final exam and certificate

    10 questions drawn at random, 70% to pass.

Capstone project

Automate the checkout test suite

Mangrove's checkout has 200 manual test cases that take two days per release, so fixes wait for the next release window and festival changes ship late. Replace most of them with an automated suite that runs in under ten minutes on every pull request: a written strategy that maps checkout risks to levels, unit tests for the price rules, API tests for the order service with its own test data, a few Playwright journeys, a contract test between the app and the order service, a load test for a 4x festival rush, and a CI pipeline with reports. Use the course's sample checkout or any small app of your own with a cart and an orders API. Plan for 8 to 12 hours.

You will hand in

  • A one-page test strategy: risks mapped to levels, planned test counts and minutes per level, and what stays manual
  • A repository with unit, API, end-to-end and contract tests in TypeScript
  • A CI pipeline (GitHub Actions) with parallel jobs, an HTML report and traces kept on failure
  • A k6 load test with thresholds and a short results note
  • A README with how to run everything and the flaky-test policy
Open the project brief

Check what you know

Already know some of this? Answer 6 quick questions, one from each lesson, and we will mark the lessons you can skim. It takes about 3 minutes and nothing is graded.

Questions

How long does the course take?

About four to five hours: six lessons of 35 to 45 minutes each, including the Build it steps and practice, plus an optional podcast episode of about 10 to 13 minutes per lesson. The capstone project takes 8 to 12 hours.

Which tools does it use?

TypeScript with Vitest for unit and API tests, Playwright for browser tests, Pact for contract tests, Grafana k6 for load tests and GitHub Actions for CI. The patterns apply to Jest, Selenium, Cypress, JMeter and other stacks.

What do I need to know first?

The test design ideas from Software Testing and QA, and enough JavaScript to read functions, promises and async code, which JavaScript Deep Dive covers. The exercises run in your browser; the Build it steps need Node.js and VS Code.

Will AI replace test automation?

AI is good at drafting tests and finding gaps, but someone has to decide what matters and keep the suite trustworthy. Lesson 6 shows how to use AI assistants well and what to look for when you review the tests they draft.

Is the certificate free, and how does the exam work?

Yes, the certificate is free, like everything else on Kolom. Each attempt mixes questions from the course's question bank with two practical tasks, some of them code checked in your browser. You need 70% on both parts to pass, and you can try again after 24 hours.

Is it really free?

Yes. Every lesson, podcast episode, exercise, quiz, final exam and certificate is free. The labs and their templates for real work are free too. Plus and Premium add every lab challenge, weekly extras and a mentor on top, and they never lock the tools or the courses.