Skip to content

Build Pipelines

Design efficient build pipelines with caching, parallelism, and artifact management.

What you'll learn

  • The stages of a well-designed build pipeline
  • Caching dependencies and build outputs
  • Running jobs in parallel for speed
  • Managing build artifacts and releases

Concept

Pipeline Design

A well-designed build pipeline is the backbone of CI/CD. It starts with a trigger — a code push, a pull request, a schedule, or a manual invocation. The pipeline then flows through stages: lint checks code style, build compiles the application, test runs automated tests, package creates a deployable artifact, and deploy ships it. Each stage should be fast, independent, and produce clear output so failures are easy to diagnose.

Caching

Re-downloading dependencies and rebuilding unchanged code on every run wastes time. Caching stores dependencies, build outputs, and tool installations between pipeline runs. In GitHub Actions, use actions/cache@v4 to save and restore directories. In Docker, layer caching avoids rebuilding unchanged layers. A well-cached pipeline can cut build times from 10 minutes to 2 minutes, giving the team faster feedback.

Parallelism

Many pipeline stages can run in parallel. If you have unit tests, integration tests, and lint checks, they can all run simultaneously instead of sequentially. In GitHub Actions, define multiple jobs that run concurrently. In test suites, use parallel test runners. Parallelism reduces the total wall-clock time of the pipeline, but be mindful of resource limits and test isolation — parallel tests must not interfere with each other.

Artifacts and Releases

A build artifact is the output of a build — a compiled binary, a Docker image, a ZIP file. Artifacts should be stored in a registry or artifact store so they can be deployed later without rebuilding. This ensures that what you tested is exactly what you deploy. Use semantic versioning to tag releases. Store artifacts with retention policies so old builds are cleaned up automatically but you can still roll back if needed.

Pipeline as Code

Defining your pipeline in code — YAML, TypeScript, or Python — is a best practice. It makes the pipeline version-controlled, reviewable, and reproducible. When a pipeline change is needed, you create a pull request just like for application code. This ensures that pipeline changes are reviewed and tested, preventing a bad pipeline change from breaking all deployments. Treat your pipeline configuration with the same care as your application code: test it, review it, and document it.

Example

              name: Build Pipeline
on: [push]

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm ci && npm run lint

  test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        node-version: [18, 20, 22]
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node-version }}
      - run: npm ci && npm test

  build:
    needs: [lint, test]
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm ci && npm run build
      - uses: actions/upload-artifact@v4
        with:
          name: dist
          path: dist/
            

Lint and test run in parallel. Test runs on multiple Node.js versions via matrix strategy. Build waits for both to pass, then uploads the artifact.

Try it

Common mistakes

The mistake

Running every stage sequentially

The fix

Identify independent stages and run them in parallel. Lint, unit tests, and type checks can usually run simultaneously, cutting total pipeline time significantly.

The mistake

Rebuilding the same artifact for each environment

The fix

Build once and promote the same artifact through staging and production. This guarantees the tested artifact is what gets deployed, eliminating environment-specific build differences.

Look up unfamiliar terms

A beginner-friendly glossary explains jargon in plain English — variables, functions, DOM, Promise, and more.

View glossary

Build real projects

Apply what you learned by building guided projects with starter code and solutions.

View projects

Decode error messages

Plain-English explanations of common errors — what they mean, why they happen, and how to fix them.

View errors