Course contentsShow
← Cloud and Infrastructure
Lesson 1709 of 2,98935. GitHub ActionsFree lesson

Matrix Builds for Parallel Testing

Configure matrix strategies to run jobs across multiple versions and configurations.

Matrix Builds for Parallel Testing

What you'll learn: How to use GitHub Actions matrix strategies to automatically test your code across multiple versions, operating systems, and configurations in parallel.

The Core Idea

A matrix build is like running the same test suite simultaneously across different combinations of variables—imagine testing your Node.js app on versions 14, 16, and 18, across Ubuntu, macOS, and Windows, all at once. Instead of writing nine separate jobs, you define one job with a matrix that spawns all combinations automatically.

GitHub Actions creates a separate job instance for each matrix combination, running them in parallel (within your runner capacity). This dramatically reduces feedback time and ensures broad compatibility.

How It Works

You define a strategy.matrix in your job, listing the variables you want to vary. GitHub Actions expands these into individual job runs:

jobs:
  test:
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        os: [ubuntu-latest, macos-latest, windows-latest]
        node-version: [14, 16, 18]
    steps:
      - uses: actions/checkout@v2
      - name: Setup Node
        uses: actions/setup-node@v2
        with:
          node-version: ${{ matrix.node-version }}
      - run: npm test

This creates 9 jobs (3 OS × 3 Node versions), all running simultaneously. You access matrix values using ${{ matrix.variable }} context expressions.

When to Use Matrices

Matrix builds shine when you need to verify compatibility across:

  • Multiple language/runtime versions
  • Different operating systems
  • Various dependency versions
  • Multiple database engines

They turn what would be repetitive, error-prone job definitions into a single, maintainable configuration.

Key Takeaway: Matrix strategies let you define test variations once and automatically run them in parallel across all combinations, ensuring broad compatibility with minimal workflow complexity.