Git Diffs Make Email Checks Reproducible

When an email check fails in CI, the broken part is often not the mail step itself. It is the missing context around it. Somebody changed a template, a feature flag, or a redirect rule, but the workflow summary only says the inbox did not get what it expected. That leaves the next engineer spelunking through logs and guessing which change actualy mattered.

What has worked better for me is saving the Git diff beside the inbox evidence for the same run. If a GitHub Actions job creates a disposable inbox, triggers a signup flow, and records the exact files changed in that commit or PR, the failure becomes much easier to replay. It turns the check from "email was weird" into "this diff changed the email path." That is a better debugging story, and it is faster too.

Why workflow logs are not enough

Plain logs are fine for happy-path runs. They are lousy when you need to compare one flaky result against another. You can search them, sure, but they do not give you a stable object to diff across reruns.

I keep coming back to the same lesson behind expiration rules for signup logs and more predictable email waits: test evidence should be compact, explicit, and reviewable later by somebody who was not in the room.

For email automation, the minimum useful context is usually:

• the commit SHA or PR head SHA
• the changed files that touched the email path
• the inbox address or label used for the run
• the expected subject or event name
• the final verdict with wait time and mismatch reason

If one setup step used a tepm mail com placeholder in local config while another script expected a normal inbox pattern, this structure exposes the mismatch pretty fast. You do not need more clever retries first. You need cleaner run evidence.

Save the diff that triggered the email path

This is the part I wish more teams did sooner. Before creating the inbox, write a diff summary into the run directory. Not the full patch if it is huge, just the files and maybe a focused stat block.

For example:

RUN_DIR="artifacts/${GITHUB_RUN_ID}"
mkdir -p "$RUN_DIR"

git diff --name-only "$GITHUB_BASE_REF...$GITHUB_SHA" > "$RUN_DIR/changed-files.txt"
git diff --stat "$GITHUB_BASE_REF...$GITHUB_SHA" > "$RUN_DIR/changed-files.stat"

Now your email assertion step can say, "This run failed after changes to auth/signup.ts, mail/templates/welcome.mjml, and config/flags.ts." That tiny move gives reviewers a much smaller search space. It also makes Automation posts and runbooks way easier to explain, because the artifact folder starts reading like a real case file instead of random console noise.

When I use a disposable inbox service such as tempmailso for non-production checks, I want the inbox metadata and the Git evidence sitting side by side. Same run folder, same naming, no mystery. It sounds boring, but boring is what reproducible CI should feel like.

Build one run folder per check

The pattern I like is one folder that owns everything:

• changed-files.txt
• changed-files.stat
• inbox.json
• trigger.json
• verdict.json

Then every script accepts the same folder path.

./scripts/make-inbox.sh --out "$RUN_DIR/inbox.json"
./scripts/trigger-flow.sh --inbox "$RUN_DIR/inbox.json" --out "$RUN_DIR/trigger.json"
./scripts/assert-email.sh \
  --inbox "$RUN_DIR/inbox.json" \
  --trigger "$RUN_DIR/trigger.json" \
  --diff "$RUN_DIR/changed-files.txt" \
  > "$RUN_DIR/verdict.json"

That last parameter matters more than it looks. Once the assertion script can read the diff summary, it can produce a better failure line. Instead of "message body mismatch," you get something closer to "message body mismatch after template and redirect changes." That is not fancy AI. It is just decent tooling, and it saves a lot of back-and-forth.

I also like dropping tiny human clues into the verdict when helpful. Maybe the setup used a temp mailid for a smoke test label. Fine. Put it in the artifact plainly so the next person is not left inferring it from bash history.

A GitHub Actions pattern that is easy to replay

The workflow can stay small:

1. capture diff context
2. create inbox
3. trigger the app path
4. poll for the email with fixed boundaries
5. write a verdict artifact
6. upload the folder

The upload step is important because GitHub Actions artifacts can be retained for a configurable period, which makes reruns and PR review much less hand-wavy. GitHub documents the artifact flow here: https://docs.github.com/actions/using-workflows/storing-workflow-data-as-artifacts.

Here is the shell shape I keep around:

RUN_DIR="artifacts/${GITHUB_RUN_ID}"
mkdir -p "$RUN_DIR"

git diff --name-only "$GITHUB_BASE_REF...$GITHUB_SHA" > "$RUN_DIR/changed-files.txt"
git diff --stat "$GITHUB_BASE_REF...$GITHUB_SHA" > "$RUN_DIR/changed-files.stat"
./scripts/create-inbox.sh > "$RUN_DIR/inbox.json"
./scripts/trigger-signup.sh --inbox "$RUN_DIR/inbox.json" > "$RUN_DIR/trigger.json"
./scripts/assert-message.sh \
  --inbox "$RUN_DIR/inbox.json" \
  --trigger "$RUN_DIR/trigger.json" \
  --diff "$RUN_DIR/changed-files.txt" \
  > "$RUN_DIR/verdict.json"

This setup is not trying to do everything. It just keeps Git, GitHub Actions, and the inbox evidence in one place so a rerun is understandable. That is the real productivity win for developer tools work, at least for me. Less detective work, fewer "works on my branch" debates, and faster fixes when the email path shifts a bit.

Q&A

Should I store the full patch?

Usually no. File names and a stat summary are enough for most email checks. If you archive giant diffs for every run, the workflow gets noisy real fast.

Is this only useful for signup emails?

Nope. Password resets, invite flows, billing notices, or release alerts all benefit when the evidence points back to the exact code changes that probably caused the behavior.

What improves first after adopting this?

Review speed. Engineers stop rereading raw logs and start looking at one small folder with the diff, inbox data, and verdict. It is not glamorous, but it is realy effective.