Skip to main content

Published

How TestChimp fits your SDLC

In brief: TestChimp supports two common SDLC shapes. In the shared QA environment model, changes from many PRs are deployed to one QA env on a sprint or release cadence and tested from the trunk branch. In the shift-left model (recommended for agent-driven teams), each PR gets an ephemeral environment and is tested before it merges. What changes between them is your connect-to-test-env policy, who runs Run QA and from which branch, and which environment tests execute against. Create Release works the same way in both.

The two SDLC approaches​

Most teams today follow one of two structures:

  1. Shared QA environment (trunk-based, release cadence). A single QA / staging environment is deployed from a trunk branch (for example main or develop). Deployments happen on a release or sprint cadence and contain changes from multiple merged PRs.
  2. Shift-left QA (PR-scoped ephemeral environments). Each PR gets its own ephemeral environment with only that PR's changes deployed. E2E tests are authored and run against it before the PR branch merges into trunk.
Shared QA environmentShift-left (PR-scoped env)
When tests are authoredAfter the sprint's PRs merge to trunkAs part of the feature branch work
Who authors / runs run-qaTypically a QA team memberThe developer (with their coding agent) who made the change
Branch run-qa runs fromTrunk (main / develop)The feature / PR branch
run-qa scopePRs merged since the last run-qa runChanges on the PR branch (diff vs merge base)
connect-to-test-env policyHow to connect to the shared QA envHow to procure and connect to the PR's ephemeral env
Tests execute againstShared QA / staging envThe PR-scoped ephemeral env
create-releaseRun from the deployment branchRun from the deployment branch

Approach 1: Shared QA environment​

This is the common, more traditional setup. Test authoring happens from the trunk branch after the PRs for the sprint are merged, and a separate QA team is usually responsible for it.

  • connect-to-test-env policy: describes how to connect to the shared QA environment (base URL, credentials, any bootstrap steps). See Connect to Test Environment.
  • Run QA: run by a QA team member from the trunk branch. On the default branch, Run QA scopes its work to the PR changes merged since the last run-qa execution. On the very first run there is no previous execution, so tell it which recent changes to cover (for example a history range or a feature area).
  • Test execution: tests run against the shared staging / QA environment. TestChimp's fixture-based test data creation gives each test execution its own isolated data, so parallel runs on the same shared environment don't compete with each other.

Here test authoring is part of the feature branch work itself. The flow is:

  1. An ephemeral environment containing the PR's changes is created. The mechanism varies by project: local Docker containers, a service like Bunnyshell, or platforms such as Railway that natively support PR-scoped environments.
  2. Tests are authored for the changes made in the PR.
  3. The test suite is run against the PR-scoped environment.
  4. The PR merges to trunk only after it is fully tested, so regressions are caught before they land.

In this approach:

  • connect-to-test-env policy: explains how to procure the PR-scoped ephemeral environment and connect to it, both locally and in CI.
  • Run QA: run by the developer on the feature branch once the development work is complete. On a feature branch, Run QA scopes itself to the branch's changes.
  • Test execution: tests run against the PR-scoped environment.
  • Controlling cost with Smart Smoke: agentic development produces a high volume of PRs, and running a very large suite on every PR can be expensive in CI minutes. Smart Smoke runs a time-bound suite that covers as much of your system as possible within the budget, prioritising features the PR affects. You keep a strong signal from the suite while containing execution cost.

Why shift-left is the better fit for agent-driven teams​

  • Smaller deltas, earlier regressions. When agents do the coding, a lot of change lands quickly. Testing at the end of the sprint means a much larger delta to test, regressions surface later, and fixing them costs more. Testing each PR keeps the delta small and finds regressions while the change is still fresh.
  • No dev → QA handoff. Agents write both the code and the tests. Splitting the work so that a developer codes and a separate QA person authors tests adds a handoff that doesn't earn its keep in agentic teams. The developer who owns the change, working with their agent, ships it tested.

Create Release works the same in both​

Whichever approach you use, Create Release is typically run from the deployment branch (main, develop, etc.). It:

  • creates a release record in TestChimp,
  • collects the test executions within the release window, and runs tests where executions are missing,
  • runs other non-functional checks selected by policy, such as performance tests, security probes and ExploreChimp,

and gives you a consolidated release health view.

Where tests execute: local machine or CI​

In both approaches, tests can execute on a local machine or in CI. Your connect-to-test-env policy should describe how each works for your project.

  • Shared QA environment: local runs and CI runs both point at the shared QA environment.
  • Shift-left: the CI workflow procures the PR's ephemeral environment and runs the tests against it. Developers can also run the tests locally against an ephemeral environment before merging.

Frequently asked questions​

Which SDLC approach does TestChimp recommend?​

Shift-left: give each PR an ephemeral environment, author tests on the feature branch, and run the suite against that environment before merging. With agents writing code, it keeps the tested delta small and catches regressions before they reach trunk. TestChimp also fully supports the shared QA environment model.

Who runs run-qa in each approach?​

In the shared QA environment model, a QA team member runs it from the trunk branch, scoped to PRs merged since the last run. In the shift-left model, the developer runs it on their feature branch once development is done, scoped to that branch's changes.

What goes into the connect-to-test-env policy?​

For a shared QA environment, how to connect to that environment. For shift-left, how to procure and connect to the PR-scoped ephemeral environment. In both cases, include how it works for local runs and for CI runs.

Won't tests collide on a shared QA environment?​

TestChimp's fixture-based test data creation isolates the data used by each test execution, so concurrent runs on the same shared environment don't compete with each other.

Running the full suite on every PR is expensive. What should we do?​

Use Smart Smoke. It runs a time-bound subset that covers the most ground across your system, prioritising features affected by the PR, so you contain CI cost while keeping a good signal.

Where is create-release run from?​

From your deployment branch (for example main or develop), regardless of which SDLC approach you use.