🤖 Announcing SmartTests: AI powered Contract Testing. Read our CTO's Blog Post here!
TRUSTED BY ENGINEERING TEAMS AT

Catch API contract breaks before they reach production

Your platform's microservices should work together flawlessly. Our solution ensures they do by automating contract validation between services.
Native Kubernetes Testing
Run tests in real K8s environments with actual dependencies, not brittle mocks. Test as you deploy, with real data.
AI-Powered Change Detection
Our Smart Diff technology spots meaningful API changes while ignoring harmless variations, highlighting only what matters.
Developer-First Approach
Write tests in simple Starlark with minimal code. Integrates directly in your CI/CD to catch breaks before merge.

Simple Developer Workflow

Four simple steps to bulletproof your API contracts across microservices
1
Write Simple Tests
Define what matters in your API contracts with minimal code
Create straightforward contract tests using Starlark syntax. Our SmartDiff technology automatically captures and analyzes API interactions to detect breaking changes.
2
Automate in CI/CD
Verify contracts on every code change, before problems reach production
Seamlessly integrate with your existing CI pipeline to automatically validate API contracts for each pull request. Tests run in isolated Kubernetes sandboxes, providing realistic environments without affecting production.
3
Compare Service Versions
See exactly how changes affect your API contracts
Tests execute in both your baseline and sandbox environments, capturing real API requests and responses rather than simulating them. This approach detects actual behavior changes that static analysis might miss.
4
Get AI-Powered Insights
Focus on meaningful changes, not false alarms
Our AI model spots meaningful API changes, filtering out false positives to help developers focus only on changes that affect service consumers.
Learn More

Powered by AI

Our AI model eliminates test maintenance by automatically detecting breaking API changes without explicit assertions. It distinguishes meaningful issues from noise and flaky behavior, keeping your tests valuable with minimal upkeep as your services evolve.

Frequently Asked Questions

How are SmartTests different from other contract testing solutions?

Traditional contract testing tools like Pact require explicitly defining and maintaining contracts. SmartTests eliminates this by having you write simple Starlark tests that exercise your API endpoints. The system runs these on both baseline and sandbox environments, using AI to analyze differences between responses and automatically detect breaking changes without explicit assertions. This approach tests real behavior rather than maintaining abstract contracts, reducing maintenance overhead and false positives.

How does the AI system in SmartTests 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 SmartTests detect?

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

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

How can SmartTests 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 SmartTests?

Most teams have their first SmartTests 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 SmartTests 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 SmartTests when APIs change?

SmartTests minimizes maintenance when APIs evolve:
- When you make compatible API changes (adding fields, extending functionality in backward-compatible ways), SmartTests 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.