Customer Story How Bitso cut change failure rate 83% while scaling delivery with coding agents
Smart Tests

Find every regression in your pull requests

Smart Tests validates every PR in a live Kubernetes sandbox. Write the API calls once and AI compares the PR version against the stable version of your service, flagging real regressions instead of noise.
No assertions to write or maintain
Relevance-scored findings posted to the PR
smart-test.star PR version stable version AI DIFF risk score HIGH MED LOW
Trusted by engineering teams worldwide
How it works

Deep validation on every code change

A SmartTest is a short script of API calls. Signadot runs it against both versions of your service, captures the behavior, and lets AI decide which differences actually matter.
PR #142 opens sandbox YOUR CLUSTER test runner runs twice checkout PR SANDBOX checkout STABLE VERSION AI DIFF signal vs noise findings PR #142 opens sandbox YOUR CLUSTER test runner runs twice checkout PR SANDBOX checkout STABLE VERSION AI DIFF signal vs noise findings
1
Write API calls in Starlark
Define the endpoints to exercise in a simple Python-like script. Capture is built in, so there are no assertions or expected values to encode.
orders.star resp = http.get( "/api/orders", capture=True) print(resp.status)
2
Trigger on every sandbox
Triggers match tests to services, so the moment a PR sandbox is created or updated the right tests run automatically. Git-based tests run from CI too.
sandbox created test run automatic
3
AI compares both versions
Captured request and response pairs from the PR and stable versions are diffed by models trained on your traffic patterns, scoring each difference by relevance.
PR version "id" 4471 "total" missing "status" "paid" "currency" "usd" stable version "id" 4471 "total" 19.99 "status" "paid" "currency" "usd"
4
Findings land in the PR
High, medium, and low relevance findings post to the pull request as a risk score, so reviewers see behavioral impact next to the code diff.
signadot posted a risk score HIGH MED LOW

Catch what assertion-based tests miss

Traditional tests only check what someone thought to assert. Smart Tests observes the full runtime behavior of your service and flags any change that matters.
checkout.star resp = http.get( "/api/orders", capture=True)
Calls, not assertions
You only describe which endpoints to hit. The comparison against the stable version is the assertion, so compatible API changes never break a test.
HIGH
Signal, not flakiness
Models learn from historical runs which variations are expected, like timestamps and random IDs, and which are genuine regressions worth a human look.
orders payments postgres
Real services, real data paths
Tests execute on managed runner pods in your cluster against sandboxes that share real dependencies, so results reflect production behavior, not mocks.

“We basically stopped creating full preview environments and replaced our custom solution with Signadot. The strategy using routing keys is much lighter, and we are able to provide an isolated environment, even with isolated databases, per PR quite fast.”

Marcus Tavares
Marcus Tavares
Staff Software Engineer, Bitso

Behavioral validation on every PR, without the test debt.

Bitso gives 250+ engineers an isolated environment per PR on Signadot, the same environments Smart Tests validate against on every change.

The output

A risk score you can read at a glance

Every execution produces a structured result, not a wall of raw diffs. Findings are scored by relevance and broken down by where they appear in the traffic.
Relevance, not raw diffs
Each difference between the two versions is scored by how unexpected it is.
High flags contract-impacting changes like removed fields, type changes, and new error codes.
Medium marks unusual differences worth a look before merging.
Low covers expected variation like timestamps and trace IDs. Surfaced, never blocking.
Request and response, separated
REQ
Request findings cover the traffic your service sends downstream as it handles the call.
RES
Response findings cover what consumers of your API actually receive, which is where breaking changes live.
Follow the Smart Tests quickstart in the docs
get-checkout · execution
Succeeded
1 High
0 Medium
5 Low
Request
Traceparent "00-4c3a…""00-e6dd…"
X-Request-Id "5a68…""5849…"
Response
order.total 19.99removed
Date "03:09:18""03:09:52"
checkout-flow 1/1 checks passed

Give every PR a risk score before review

Most teams have their first Smart Tests running in under an hour, on the cluster and staging environment they already operate.

Frequently asked questions

Is this a contract testing tool like Pact?

No. Smart Tests is not a direct alternative to consumer-driven contract testing tools like Pact. Smart Tests is a provider-focused validation tool that gives you a "risk score" for your PR by analyzing its runtime behavior, rather than coordinating contracts between consumer/provider teams.

How does the AI system in Smart Tests work?

The AI system performs two main functions: First, it analyzes API responses from both versions to identify structural, data type, and content differences. The models determine which differences actually impact compatibility rather than flagging every change.

Second, it reduces test flakiness by learning from historical test runs, distinguishing between expected variations (timestamps, random IDs) and genuine breaking changes. The system adapts to your specific APIs over time, improving its accuracy with continued use.

What kinds of contract breakages can Smart Tests detect?

Smart Tests detects:
- Schema changes: Removed fields, changed data types, altered object structures
- Behavioral changes: Different response codes, new error conditions, altered validation rules

Because Smart Tests observes runtime behavior rather than just validating static schemas, it can identify subtle issues that traditional approaches miss.

How can Smart Tests be integrated with my CI/CD pipeline?

Integration requires two components:
1) The Signadot CLI integrated into your pipeline to create sandboxes for each PR
2) Smart Test triggers configured to automatically run tests against those sandboxes

How long does it take to set up Smart Tests?

Most teams have their first Smart Tests running in under an hour:
1) Install the Signadot operator on your Kubernetes cluster (10-15 minutes)
2) Write your first test in Starlark to call your API endpoints (5-10 minutes)
3) Configure triggers to run the test on your sandboxes (5 minutes)
4) Integrate sandbox creation with your CI/CD pipeline (15-30 minutes)

Since Smart Tests runs against your existing staging/pre-production environment, you avoid the typically time-consuming process of setting up separate test environments or managing test data.

What is the maintenance overhead of Smart Tests when APIs change?

Smart Tests minimizes maintenance when APIs evolve:
- When you make compatible API changes (adding fields, extending functionality in backward-compatible ways), Smart Tests automatically recognizes these as non-breaking and doesn't require test updates.
- For intentional breaking changes, you typically only need to update the test code that calls the changed endpoints - not assertions or expectations, since those are handled by the AI comparison system.