The OrbitTasks pipeline runs only on your laptop today. There is no CI.

By the end of this session, you'll have a working GitHub Actions workflow that automates your process and runs faster than any local setup.

handshake

The Pipeline Deal

01. THE AGREEMENT

A pipeline is a deal: developers commit code, and in return the system tells them whether the code is safe to merge.

The deal only works if the answer comes back fast and is trustworthy.

02. THE BREAKDOWN

Slow pipelines break the deal.

Flaky pipelines break the deal worse, because now the answer is sometimes a lie.

THE MENTAL MODEL

A GitHub Actions workflow has four parts

When

Events that trigger the workflow, like a pull request or a push.

Where

Runners where the code executes (e.g., Ubuntu, macOS, Windows).

What

The jobs and steps that perform the actual work (tests, builds).

With what

The environment: env vars, secrets, and caches needed for execution.

Trigger

on: pull_request triggers the workflow when a PR opens.

Runner

runs-on: ubuntu-latest picks a Linux runner.

Steps

jobs.test.steps defines the list of things to run: check out, install dependencies, and tests.

code

speed

groups

Action: Open .github/workflows/ci.yml. Walk through it line by line.

Observation: No caching, no parallelism, no matrix. Cold run takes ~13 mins, mostly in the serial test:api suite (real HTTP calls).

Goal: Today we reach ~5–7 mins. In Workshop 5, we achieve an order-of-magnitude collapse by mocking clients.

Improve this file in place, one commit at a time, mirroring in your own forks.

We push the repo to your fork together and watch .github/workflows/ci.yml execute in the Actions tab.

Note the wall-clock duration of each step. A cold run is ~13 minutes, and you'll see almost all of it land on test:api.

We record the per-step durations in your logbook as we go; we compare against them at the end of the session.

See the baseline run on GitHub

timer

groups

code

Things that will trip you up.

…even after doing this for years.

space_bar

Indentation & YAML

YAML is whitespace-sensitive. Use spaces, not tabs to avoid cryptic parsing errors.

cloud_off

Environment Drift

"Works locally" issues are usually missing env vars or Node version mismatches in CI.

bug_report

State Contamination

Test order can hide bugs. CI runs in a fresh environment; your local machine might not.

check_circle

False Positives

Steps passing on green unexpectedly usually mean a missing "exit 1" in your script.

Caching: the first big optimization

Often a 2-3× speedup for free

speed

Every job starts on a fresh runner with no node_modules.

Without caching, every job re-downloads everything from npm.

With caching, the runner restores ~/.npm from the previous run.

Adding one line saves 30–60 seconds per run.

Together we add cache: npm to your actions/setup-node step.

Push, wait for the run to complete, then run it again. Compare the install duration on run 1 vs run 2. The second run should be noticeably faster.

We record both numbers in your logbook; your improvement proposal in Session 6 wants them.

Parallelization with matrix strategies

The second big speedup

layers

A strategy.matrix runs the same job multiple times with different inputs. We use it two ways:

• Run apps/api and apps/web as separate jobs that execute simultaneously.
• Shard the test suite across two parallel runners, turning 90 seconds of tests into 45 seconds.

Together we split your CI into two parallel jobs, one for apps/api and one for apps/web. Run it.

Note that the total pipeline duration is now roughly the longer of the two jobs, not the sum.

speed

• A 40–60% improvement from caching alone.
• Add matrix and parallel jobs and you often hit 70%+.
• The number that matters is not "% faster" but "minutes saved per PR": multiply by team size and PR volume.
• A Platform Engineer would now show this improvement to leadership. We do that in Session 6.

settings_suggest

Key Objectives

visibility Examine the repo from a brand-new developer's perspective.

terminal Write a Makefile / npm scripts that turn three commands into one.

auto_awesomeImprove documentation and add automation that removes daily friction.