AFTERMATH — The Release Time Machine

AFTERMATH uses AI-assisted investigations and release simulations to expose failures, compare fixes, trace root causes, and help engineers make safer deployment decisions.

Comment

AFTERMATH — The Release Time Machine

Inspiration

Software teams test whether their code works. But a green CI pipeline doesn't always tell them what will happen when that code reaches production.

A seemingly small change can introduce duplicate payments, broken retries, unexpected database pressure, or financial losses. By the time engineers discover these consequences, real users may already be affected.

I built AFTERMATH around one question:

What if engineers could investigate the consequences of a release before deciding whether to ship it?

What it does

AFTERMATH is an AI-assisted release investigation platform that helps engineers examine software failures, compare release behaviors, and make evidence-based deployment decisions.

Its central demonstration uses a payment system with a concurrency and idempotency defect.

AFTERMATH provides six connected workspaces:

  • Overview: Examine release health and available evidence.
  • Release Time Machine: Run controlled scenarios comparing vulnerable and repaired payment behavior.
  • Investigation: Explore event traces, causal relationships, and the potential blast radius of a failure.
  • Remediation Studio: Inspect proposed fixes and sandbox verification results.
  • Release Control: Review release evidence and human approval decisions.
  • Agent Activity: Inspect available agent activity and investigation history.

Instead of presenting a simple pass/fail result, AFTERMATH aims to show why a release is risky and what evidence supports a safer alternative.

How I built it

I developed AFTERMATH as a full-stack application using a Python/FastAPI backend and a Next.js/React frontend.

The backend models release scenarios, payment behavior, investigation data, and remediation workflows. The frontend organizes these capabilities into an interactive engineering workspace.

I used automated backend tests, frontend build checks, and GitLab CI/CD to validate the application.

The project also integrates a GitLab Duo Agent Platform workflow for read-only release-evidence analysis. In a real agent session, the Release Evidence Analyst examined a GitLab pipeline, inspected the repository's CI configuration, distinguished verified facts from missing evidence, and identified weaknesses in the release checks.

The public GitLab repository includes the application, tests, CI configuration, and documentation.

Challenges I faced

Reproducing meaningful failures

A payment concurrency defect is difficult to communicate through code alone. I needed a way to demonstrate the difference between vulnerable and repaired behavior using controlled scenarios and observable evidence.

Making technical evidence understandable

Engineers need more than a dashboard full of numbers. I organized the investigation around the sequence from failure detection to causal analysis, remediation, and release review.

Making CI tests reliable

An earlier GitLab pipeline exposed tests that depended on seeded development database state. I revised the causal-engine tests to use isolated test fixtures and added coverage for unknown releases.

The corrected commit, 0c8ac89b, produced a successful GitLab pipeline.

Separating evidence from assumptions

One of the most important lessons came from the GitLab Duo release-readiness analysis: a successful pipeline does not automatically prove that every release-safety property is enforced.

Some current CI jobs are placeholders, and certain security and end-to-end checks are not yet represented in GitLab CI. Rather than hide these limitations, AFTERMATH treats missing evidence as an explicit part of the engineering decision.

Accomplishments

  • Built an interactive release investigation application with six connected workspaces.
  • Implemented a controlled demonstration of vulnerable and repaired payment behavior.
  • Added causal investigation and remediation review capabilities.
  • Established a working GitLab CI/CD pipeline.
  • Fixed test isolation issues identified during CI verification.
  • Ran a GitLab Duo release-evidence analysis against the project's actual commit and pipeline.
  • Produced a report that separates verified results, unverified checks, and recommended next actions.

What I learned

This project reinforced that passing tests and being ready to release are not the same thing.

I learned how important reproducible experiments, test isolation, observable evidence, and human review are when building trustworthy engineering systems.

I also learned that AI agents are most useful when they identify uncertainty instead of inventing confidence.

What's next

The next steps are to strengthen automated release gates, expand security scanning, run browser end-to-end tests in CI, and connect more investigation evidence directly to GitLab pipelines.

Longer term, I want AFTERMATH to help teams evaluate release consequences across real services while preserving explicit human control over deployment decisions.

AFTERMATH's goal is simple: make the consequences of software changes easier to understand before those changes affect users.

Source code: https://gitlab.com/atumanyire-labs/aftermath

Verified GitLab pipeline: https://gitlab.com/atumanyire-labs/aftermath/-/pipelines/2986438087

Built With

Share this project:

Updates

Submission history