Local-first · runs on your machine

Is your API Spikeproof?

Design end-to-end journeys across your services on a visual canvas, debug them step by step, then run real k6 load tests and browser flows. Everything runs on your machine, with reports your whole team can read and the same tests ready for CI.

40downloadssince the first beta
Free public beta 0.1.0-beta.4macOS (Apple Silicon) · Windows (x64) · Node.js and k6 included
Spikeproof home: start a performance test, record a browser flow or try an API request

See it run

Real Spikeproof screens and real k6 runs against local mock backends. The apps are made up; the numbers are not.

Replies hit the model gateway's limit: message p95 2.0 s, 77 rate-limited replies, while every other step stayed under 20 ms.

Real Spikeproof UIReal k6 run · local mock backendFictional app47 s Vertical cut

One journey, every service it touches

Real user journeys cross systems: an auth service, a storefront, a rewards program. Spikeproof tests them the way they run, in one journey, with each request going to its own service.

  1. Lanes by serviceEach service gets a color and, if you like, its own lane, so a cross-system flow reads like a sequence diagram.
  2. Its own address and credentialsEvery request goes to its service's base URL and token in the environment you pick. A login token passed from an earlier step wins.
  3. Values flow between themUse the member id from the auth response in the rewards call and the points balance at checkout, like any other mapping.
  4. The same in load runs and CIk6 gets a target per service, packages carry every service, and the pipeline asks for each service's secret.
A journey across three services in lanes by service, with a debug run: each request colored by the service it called
Sign in with Identity, cart and checkout in Storefront, points and offers in Rewards: one journey, one debug run.
A step that wasn't sent because a token mapping didn't resolve, explained in the inspector with a one-click fix
The canvas, timeline and inspector agree on what's missing, and the fix is one click.

Debugging that tells you why

  1. Every input, where it's usedEach value a request sends, the header or body field it lands in, and what it resolved to.
  2. The reason, and the fixA field with another spelling, a list, a header, a step that was skipped or isn't connected: Spikeproof says which, and fixes it in one click.
  3. Tokens described, never shown“JWT · 812 chars · expires in 14 min”. On a 401 the trace says whether the token had expired.

What teams use it for

From a quick check that a flow works to a capacity test before your biggest day.

End-to-end checks across microservices

Sign in, search, add to cart and pay, across the services that really serve it, with the token and ids passed along the way.

Capacity before a launch or sale

Ramp a realistic mix of journeys in your perf environment and see where latency bends, which step and which service.

Did this build get slower?

Run the same journey on every build. Baselines and comparisons say what changed, in milliseconds and in words.

Release gates in CI

Thresholds become pass or fail for the pipeline. Packages and pipeline files come out of the app in three steps.

What users feel under load

Real browsers repeat a user flow while k6 loads the APIs behind it: page times, Web Vitals and API latency on one timeline.

Nightly regression suites

Journeys and browser flows together, with setup and cleanup, retries that flag flaky tests, and a matrix of how each one trends.

From service definition to performance insight

Connect your services, design a realistic journey, and see exactly how it behaves before applying load. Guided setup takes you through it the first time.

  1. 1Register your servicesImport OpenAPI 3, Postman or cURL, or define endpoints yourself.
  2. 2Say where it runsA base URL per environment: QA, Perf…
  3. 3Design the journeyChain requests across services; values from earlier answers are suggested.
  4. 4Choose the loadQuick check, steady or ramp up.
  5. 5Debug, run and compareInspect traces, execute k6 and review measured results.
Guided setup: pick requests and link values from earlier responses

Everything between “does it work?” and “does it scale?”

Journeys across services

One test can sign in with your auth service, shop in the storefront and check rewards. Each request goes to its own service's address and credentials.

Visual test design

Build journeys on a canvas or as a list: requests in parallel, conditions, joins, retries, polling until ready, and failure paths, all debuggable one iteration at a time.

Debugging that explains

When a mapped value is missing, the canvas, timeline and inspector all point at it, say why (a renamed field, a skipped step) and offer the fix in one click.

Tokens that never go stale

Pass a login token to later requests, fetch tokens from your auth service and refresh them before they expire, or paste one. Tokens are never shown, logged or saved in tests.

Test suites

Group journeys and browser flows with setup and cleanup. Retries flag flaky tests, a health matrix shows trends, and you can rerun only what failed.

Realistic test data

Data tables per row or at random, every item of a response list, generated ids, names and dates in any format your API expects.

API Explorer

Environments, variables, values captured from responses, sandboxed scripts, history and diffs. Imports OpenAPI, Postman, Insomnia, HAR and cURL.

Browser flows that heal

Record browser interactions as editable steps. Replay shows a screenshot and the API calls behind each step, and falls back to backup locators when the page changes.

Hybrid load tests

Real k6 load on your APIs while real browsers repeat a user flow, so page times and Web Vitals sit on the same timeline as API latency.

Reports anyone can read

Plain-language results (“95% of requests answered within 230 ms”), baselines, comparisons and trace explorer, exported as Markdown, HTML, JSON or CSV.

Runs in your CI

The same test, headless on a build agent: GitHub Actions, Jenkins or a shell script, with JUnit results and exit codes your pipeline can act on.

Share tests across teams

Portable packages carry journeys, every service they call and their environments, never credentials. Imports show what changed and never silently overwrite.

A recorded browser flow with a screenshot for each step
Browser flows: readable steps, a screenshot of each one.
A hybrid run: API load and real browsers on one timeline
Hybrid runs: what users felt while the API was under load, in plain words.

The same test, in your pipeline

Export a journey from the app as a portable package, commit it next to your code, and let every build answer “did this get slower?”

  1. Run in CIThree steps in the app give you the test package and a complete pipeline file. No credentials in either.
  2. Runs on any agentGitHub Actions, Jenkins or a shell script. It installs a pinned k6 and the single-file CLI, checks everything, then runs.
  3. Stay inside the linesWithout an approved policy only localhost runs. Production names never do.
$ spikeproof preflight checkout.json --env perf
  ✓ Policy · ✓ Target approved · ✓ k6 · ✓ Network
$ spikeproof run checkout.json \
    --env perf --output results
  → results/junit.xml · result.json · report.md
Exit codes your pipeline can act on
0Passedevery threshold and journey check
1Faileda threshold or a check failed
2Invalidbad package or unknown environment
3Blockedtarget not approved, or load over its limits
4Didn't runk6 missing, timeout or runner error
Export for CI: what the build agent needs, per environment, with a ready-to-copy pipeline snippet
Run in CI: checks each environment against the policy before you commit the pipeline.

Safe by design

  • Requests only go to base URLs you register, with relative paths. Spikeproof is never an open proxy.
  • Execution credentials are resolved on the machine running Spikeproof. Runner logs redact credentials; review captured data before sharing reports.
  • Big loads belong in perf environments; other environments are limited to small checks.
  • Shared packages never contain credentials. CI reads them from its own secret store at launch.
  • Tokens are passed between requests at run time, fetched from your auth service, or stored encrypted on your machine. A test can only link to a token, never hold one.

Spikeproof on your desktop

A local-first performance testing workspace for macOS (Apple Silicon) and Windows (x64), with Node.js and k6 built in. Version 0.1.0-beta.4 is a public beta.

Built for local execution

  • Services, journeys and results saved locally
  • Real k6 execution and measured results
  • Browser tests use installed Chrome or Edge
Public beta · 0.1.0-beta.4

Free to download. The beta is unsigned, so macOS and Windows ask you to confirm the first time you open it; the download page shows how.

Download Spikeproof
Is this website the testing application?

This site showcases Spikeproof. Tests execute through a local runner, not through this public website. The desktop prototype stores saved services and results in your operating system’s application data directory, separately from the application itself.