Product

Trigger & Trial is a delivery platform for teams who would rather review a requirement than a diff. It sits between "here is what we want" and "here is a running system", and its job is to make the gap between those two auditable.

The pipeline

Five stages. Only one of them needs you, and that is the point.

Request

You describe the behaviour you want — in prose, a ticket, or a voice note. The model drafts the specification from it.

Draft

You get a Gherkin feature file for behaviour and an OpenAPI document for interfaces. Every inference the model made beyond your words is marked.

Review

You work through the spec clause by clause in a diff-style view. Reject a clause, and only that clause is regenerated.

Build

Approval freezes an immutable snapshot. The build runs lint, type checks, cross-format consistency checks and the scenario suite.

Trial

A disposable environment with seeded data is deployed near you. Use it, break it, and file findings against the scenario that should have caught them.

Clause-level approval

Most spec tools give you one big approve/reject. That is not a review, it is a vibe check.

Each requirement becomes an independently approvable clause. A clause can be accepted, rejected with a reason, or deferred. The reason you give when rejecting becomes training signal for the next draft of that clause — the model learns your house style, not just your words.

Rejection is scoped. Rejecting one clause does not discard the other forty you already approved, and the diff you see after a revision shows exactly what changed.

Native formats, no translation layer

The specification is not a proprietary intermediate format. It is the same text your existing tools already read.

Gherkin feature files

Behaviour is written as Feature / Scenario / Given-When-Then. Cucumber, pytest-bdd and Playwright all consume it, so the spec is not trapped inside our platform.

OpenAPI documents

Interfaces are written as a standard OpenAPI 3 document. Spectral lints it, Prism mocks from it, schemathesis and Dredd test against it — and your existing generators work unchanged.

Because both formats are ordinary text, the specification lives in your GitHub repository as commits and pull requests. The review you perform is a real Git diff, and the audit trail is a real Git history — not a proprietary activity log that nobody can reconstruct six months later.

Verification that does not flatter itself

A passing test suite is not evidence of correctness. It is evidence that some assertions ran.

The build runs four mechanical layers, and reports each separately:

Layer What it proves What it cannot prove
Lint The spec is syntactically valid and follows the house rules Nothing about behaviour
Type check The implementation’s types are internally consistent Nothing about whether the types are the right ones
Cross-format consistency Every operation referenced by a scenario exists, and every example matches its schema Whether the schema is what you meant
Scenario execution The specified behaviours hold Whether the behaviours were specified completely

That last column is the important one. Every scenario is additionally graded for assertion strength, so a scenario that asserts almost nothing is visible as such rather than counted as coverage.

Trial environments that are actually disposable

“It works on my machine” is not a delivery format.

Every successful build produces a live trial environment with seeded data, deployed in the region closest to you. It exists to be used hard: click through it, break it, feed it bad input. When you are done it is torn down automatically, and nothing about it is billed beyond its idle window.

Because the trial environment and the delivered artifact come from the same immutable snapshot, what you experience is what you get. There is no separate demo path with different behaviour, relaxed rate limits, or fake data that the production build does not use.

Multi-tenancy and data

Isolated by default

Every tenant gets isolated credentials, quotas, log space, storage prefixes and build concurrency. Trial environments are single-tenant containers with read-only root filesystems and an outbound allowlist.

Your data stays yours

Specs live in your repository. Secrets are injected into the running process and never written to logs. Trial environments use data derived from your spec unless you explicitly opt into a real dataset.

Where it fits in your workflow

Team shape How it is usually used
Backend team with a contract-first culture OpenAPI drives the build; Gherkin covers the business rules that the contract cannot express
Team with an existing BDD practice Existing feature files become the source of truth; the platform adds build, verification and trial around them
Regulated or audit-heavy team Clause-level approvals give a per-requirement audit trail that a code review does not
Team drowning in review The measurable win: time spent reviewing a spec instead of a diff

See it on a real vertical slice

The quickest way to judge this is to take one behaviour your team already argues about and run it through the whole pipeline.