There is a quiet tax many engineering teams pay after their automated test suite starts to matter.

The tests live in code. They run in CI. They already know the branch, commit, environment, failure message, stack trace, screenshot, trace file, retry status, and build URL.

Then someone asks:

Can we put these tests in Jira too?

That request usually comes from a good place. Jira is where work is planned. Product, QA, engineering, and release stakeholders already use it. If quality signal is invisible there, people end up asking for screenshots from CI, links to failed builds, or spreadsheet summaries before every release.

The mistake is assuming the answer is to recreate every automated test as a manual Jira test case.

For many teams, that creates a second source of truth that starts decaying immediately.

Automated tests are not manual test cases

Manual test cases and automated tests have different jobs.

A manual test case is a human-readable procedure. It often describes a workflow, expected result, and maybe some preconditions. It is useful when a person needs to execute or review a scenario.

An automated test is executable behavior. It is versioned with the code, refactored with the product, reviewed in pull requests, and run repeatedly by machines.

When teams try to manage automated tests by copying them into a test-case inventory, they usually create a translation problem:

• The test name changes in code, but the Jira case does not.

• The test is deleted or split, but the manual record still exists.

• The CI failure has rich evidence, but the test case only says "failed."

• The test belongs to a branch or commit, but the copied case does not.

• The release team sees a static inventory instead of the latest run signal.

The test case becomes a label for a thing that actually lives somewhere else.

The better question

Instead of asking, "How do we turn all automated tests into Jira test cases?", ask:

What does Jira need to know from each automated run?

That changes the shape of the system.

Jira usually does not need a duplicated copy of every test implementation. It needs the evidence and context that help people make decisions:

• Did the run pass or fail?

• Which tests failed?

• What changed compared with the previous run?

• Which branch, commit, build, and environment produced this result?

• What error, stack trace, screenshot, video, trace, or log explains the failure?

• Is this linked to the Jira issue or release people are already reviewing?

• Is the suite growing, shrinking, slowing down, or becoming flaky?

That is a run-evidence model, not a manual-case mirror model.

Code-first test management

In a code-first model, automated tests remain where they are strongest: in the repository.

The source of truth is still the test code and the CI pipeline. Jira receives structured evidence from each run.

That evidence can include:

• Run status and pass rate

• Failed test details

• Branch and commit metadata

• CI build name, number, and URL

• Test environment

• Framework metadata

• Suite changes, such as tests added or removed

• Failure artifacts, such as screenshots, traces, videos, and logs

• Release links and issue-level summaries

This keeps the system honest. If a test changed in code, the next run reflects that change. If a branch has a failing test, Jira can show that branch and commit context. If a release is being reviewed, stakeholders can inspect recent run signal instead of a stale inventory.

A practical example

Imagine a Playwright suite running in GitHub Actions.

The team already has:

• Tests in the repository

• A CI workflow

• Screenshots and traces on failure

• A branch name and commit SHA

• A Jira issue for the feature or bug

The old approach says:

1. Create manual Jira test cases that correspond to the automated tests.

2. Keep those cases updated as the suite evolves.

3. Link failures back manually when something breaks.

4. Explain release quality in a separate report.

The code-first approach says:

1. Keep the Playwright tests in code.

2. Add a reporter that publishes the run to the test reporting system.

3. Send the run evidence into Jira.

4. Let Jira show the status, failed tests, branch, commit, artifacts, and issue-level context.

The second model asks for less manual bookkeeping and gives more useful information when something fails.

What belongs in Jira

Jira is good at workflow, ownership, planning, discussion, and release coordination.

So the test signal shown in Jira should serve those jobs.

For developers, Jira should answer:

• Which failure is blocking this branch?

• What commit or build produced it?

• Can I inspect the stack trace or artifact without hunting through CI?

For QA and automation engineers, Jira should answer:

• Is the suite stable?

• Did this run add or remove tests?

• Are failures recurring?

• Is the evidence good enough to triage?

For product and release stakeholders, Jira should answer:

• Is this version ready?

• Which failures matter for this release?

• Is the quality trend improving or degrading?

None of those questions require copying the entire automated suite into a parallel manual inventory.

They require reliable run evidence.

Where BDD still fits

This does not mean structured scenarios are useless.

Gherkin and BDD-style acceptance criteria can still be valuable, especially at the Jira issue level. The trick is to avoid treating them as a replacement for automated evidence.

A healthy model looks like this:

• Jira issue: describes the behavior the team expects.

• Gherkin scenario: makes that behavior reviewable.

• Automated tests: verify behavior in code.

• Test run evidence: shows what happened in CI.

The useful connection is not "every automated test must be manually represented." It is "can this expected behavior be supported by real automated evidence?"

That is a much stronger question.

What Testream does with this model

Testream is built around this code-first idea.

Instead of asking teams to recreate every automated test as a manual Jira case, Testream publishes automated test runs into Jira with the context teams need to act:

• Run summaries in Jira

• Failure evidence

• Branch and commit context

• Test suite changes

• Trends and release signal

• Artifacts such as screenshots, traces, videos, logs, and reports

• BDD Specs that can be assessed against captured evidence

The automated tests remain in the codebase. Jira gets the operational signal.

That distinction matters because it keeps both systems doing what they are good at.

A simple decision rule

When deciding whether to duplicate something into Jira, use this rule:

If the thing is executable and changes with code, keep it in code. If the thing helps people plan, review, triage, or release, surface the latest evidence in Jira.

That rule prevents a lot of process drag.

It also makes test reporting more useful. Instead of debating whether the test inventory is current, teams can inspect the run that actually happened.

From principle to workflow

If you want the concrete version of this argument, start with these pages:

• Testream website for the product overview and the code-first reporting model behind it.

• Testream Quick Start for publishing a first automated test run into Jira.

• What Testream adds to Jira for the Jira-side workflow, including run visibility, failure evidence, and release signal.

• Test Run Summaries in Jira Issues for issue-level run context where teams already track work.

• BDD Specs for reviewing acceptance criteria against captured automated test evidence.

Closing thought

Automated tests are not valuable because they appear in a test management table.

They are valuable because they run, fail, pass, capture evidence, and tell the team something about the current state of the product.

The goal is not to make Jira pretend to be your repository.

The goal is to make Jira aware of the test evidence your repository and CI pipeline already produce.

That is the difference between maintaining a second source of truth and giving your team a usable quality signal.