The Speedscale alternative — self-hosted, no account, no Kubernetes
Speedscale’s free proxymock is a fast way to record and replay locally — but its engine is a closed binary that needs a Speedscale sign-in, and on a mock miss it falls through to the real provider. Gostly is a self-hosted platform you run entirely in your own perimeter — proxy, control plane, dashboard, and inference via Docker Compose — that records your real upstream and replays it byte-for-byte. No account to create, nothing phones home but a license check, and a miss returns a status you choose instead of calling production.
Speedscale earned its reputation in Kubernetes traffic replay, and proxymock — its free, local record-then-replay CLI — is a genuinely good way to get a mock in front of your service in minutes. Its protocol breadth is wider than ours: gRPC, GraphQL, Kafka, AMQP, SQS/SNS, Postgres, MySQL, DynamoDB, S3. If you need to replay a database or a message queue today, that breadth is real and Gostly does not match it. Two things are worth knowing before you lean on the “free” label, though: proxymock’s mock engine is a closed proprietary binary (Speedscale describes it as a local Speedscale Enterprise mock server) — only the example snapshots are Apache 2.0 — and running it requires a Speedscale account, with a browser sign-in or API key on first use and no documented offline mode.
Gostly is built on a different starting assumption: the whole product should run inside your perimeter, not just a data plane. So Gostly puts a Rust proxy in front of your upstream and runs as a self-hosted stack — proxy, control plane, dashboard, and inference — via Docker Compose. In LEARN mode it records your real traffic; flip to MOCK and it replays it byte-for-byte, including HTTPS. There is no Kubernetes to operate and no kernel-privileged DaemonSet to install — the proxy is a userspace process you point your service at. The licensed build makes only opt-out license-validation and counters-only calls; your recorded traffic, your mocks, and any PII in them never leave your host.
The behavior that surprises teams most is fall-through. proxymock replays by signature matching, and on a miss it falls through to the real provider — which means a request your recordings didn’t cover can quietly hit production, an unwanted data-egress surprise in a test. Gostly never does this. On a miss the proxy returns a configurable status (404 by default) and stops there; the live upstream is never called. The match path runs a cascade — session-verbatim, then exact, then a resource store that turns a recorded POST into the right GET-by-id, then smart-swap — and only at the very edge does AI gap-fill come in, grounded by the traffic you already recorded, with no model anywhere in the request hot path.
Speedscale’s enterprise tier captures production traffic through an eBPF DaemonSet, which runs with node-kernel privileges, and its control plane is vendor-hosted SaaS — in the managed tier, DLP-filtered traffic is forwarded to Speedscale’s cloud; BYOC moves the data plane onto your infrastructure, though the control plane stays theirs. That is the right shape for load and chaos testing at Kubernetes scale, which is Speedscale’s center of gravity. It is the wrong shape if your constraint is that recorded traffic must not leave your network and you would rather not grant a vendor kernel-level capture on every node. Gostly captures at a userspace proxy you control, in a container you run.
And because Gostly is your own single-tenant deployment, the controls a security review asks for are built in: SSO via SAML or OIDC, role-based access control across four roles, and an append-only audit log on Team — all self-hosted in the container. Each deployment is single-tenant, so your data is isolated by running in your own perimeter, never shared with another customer’s. Pricing is published and flat, where Speedscale’s Pro and Enterprise tiers are contact-sales. The honest trade is protocol breadth: proxymock replays gRPC, queues, and databases today, and Gostly does not yet.
proxymock is “free,” but it needs a Speedscale account, its engine is a closed binary, and on a miss it calls the real provider. Gostly runs in your perimeter with no account, and on a miss it never falls through to production.
payments-api · upstream OFFLINE
UPSTREAM OFFLINE✓ 29 / 29 GREEN
$ docker stop upstream-api # kill the real API
upstream-api stopped
$ pytest tests/ -v # replayed from Gostly
tests/payments::test_list_customers PASSED
tests/payments::test_get_customer PASSED
· · · · · · · · · · · · · · · · · · · ·
========= 29 passed in 0.85s =========
↳ 0 live calls — served byte-for-byte
take the upstream offline — the recorded library still serves, 0 live calls
Feature comparison
Feature
Speedscale
Gostly
Free local tool
proxymock CLI (free)
OSS proxy (FSL, single binary)
Mock engine is open source
Example snapshots Apache 2.0; engine is a closed binary
OSS proxy is source-available (FSL)
Runs with no vendor account
No — proxymock requires sign-in / API key
Yes — runs with no Gostly account
Recorded traffic / PII stays on your host
Managed tier forwards DLP-filtered traffic to Speedscale's cloud; BYOC keeps the data plane on your infra
Your recorded traffic and PII never leave your perimeter
On a mock miss
Falls through to the real provider
Returns a configurable status (default 404) — never calls the live upstream
AI gap-fill at the edge, grounded by your recorded traffic — no model in the request hot path
Library on day one (no recordings yet)
Record first
Seed from a HAR / Postman / OpenAPI file — full library before you record
Self-hosted control plane
SaaS control plane; BYOC moves only the data plane
The whole product runs in your perimeter (Docker Compose)
SAML / RBAC / audit log
Enterprise (contact sales)
SAML + OIDC SSO, 4-role RBAC, append-only audit log on Team — in your container
Published pricing
Pro / Enterprise are contact-sales
Flat published tiers (Free → Enterprise)
Roadmap items are labelled explicitly. Statecharts (stateful flows), live drift detection, Markov chaos, and SSO / RBAC / audit log ship today; gRPC, async messaging, and databases stay roadmap on Gostly’s side, where Speedscale already replays them. AI gap-fill on Gostly is opt-in, grounded by your recordings, and never sits in the request hot path.
Choose Speedscale when
→You need to replay gRPC, GraphQL, a message queue (Kafka / AMQP / SQS / SNS), or a database (Postgres / MySQL / DynamoDB) today — proxymock covers those protocols and Gostly does not yet.
→You want transparent capture with no proxy to repoint — Speedscale’s eBPF capture taps traffic at the kernel without changing your service config.
→Load testing and chaos at Kubernetes scale is the job — that is Speedscale’s center of gravity, and it is built for it.
→You want a free local CLI to record and replay in minutes and a Speedscale account is not a blocker for your team.
→You want a cloud AI assistant (QABot) and an MCP server wired into your IDE as part of the platform.
Choose Gostly when
→The whole product has to run inside your perimeter — proxy, control plane, dashboard, and inference — with Docker Compose, no Kubernetes, and no vendor cloud holding your control plane.
→You can’t (or won’t) create a vendor account or grant a kernel-privileged DaemonSet on every node — Gostly runs with no Gostly account and captures at a userspace proxy.
→Your recorded traffic and PII must never leave your host — nothing phones home but an opt-out license check and counters-only telemetry, no payloads.
→A mock miss must never touch production — Gostly returns a configurable status and never falls through to the live upstream, the way signature-match-then-fall-through tools do.
→You need deterministic, byte-for-byte replay, statechart flows (POST then GET-by-id), SSO (SAML/OIDC), four-role RBAC, and an append-only audit log on Team — and a published flat price instead of a contact-sales quote.
Pricing, side by side
Tier
Speedscale
Gostly
Free
proxymock CLI (free, but requires a Speedscale account)
OSS proxy (FSL) · self-hosted, no account required
Pro / Solo
Pro — contact sales (no public price)
$10 / mo single user
Team
Folded into Enterprise — contact sales
$79 / seat / mo (min 3 seats)
Self-host / Enterprise
Enterprise — custom, contact sales
$499 / mo Self-host · $25K+ Enterprise
proxymock is free to download but is gated behind a Speedscale account, and Speedscale’s paid Pro and Enterprise tiers are contact-sales with no public price — so the all-in cost is hard to know before a call. Gostly publishes flat tiers: the OSS proxy self-hosts free with no account, Pro is a flat single-user price, Team is per-seat, and Self-host and Enterprise are posted, not quoted.
No empty library on day one
The objection that stalls most switches is “I have no Gostly recordings yet, so I’d be starting from zero.” You aren’t. Drop a HAR capture, a Postman collection, or an OpenAPI spec into the dashboard and Gostly seeds a working mock library before you proxy a single request — the same library your recorded traffic lands in. Then real traffic sharpens it to ground truth, with nothing leaving your host along the way.
gostly.internal / cold-start seeding
cold-start seeding 47 MOCKS · SERVING
⤓
drop a HAR · Postman · OpenAPI file
payments.har — 47 entries · 312 KiB
HARPostmanOpenAPI
✓ GET /customers/:id — seeded
✓ POST /charges — seeded
✓ GET /invoices — seeded
· flip to MOCK — a full library on day one
no empty library — seeded before you record a single call
In the dashboard, open Cold-start seeding, drag in the file, pick the service, and commit. The mocks land in the same library your recorded traffic does — flip the proxy to MOCK and they serve immediately. Then run your real test suite through the containerized proxy in LEARN mode to sharpen it to ground truth. No Kubernetes, no DaemonSet, no vendor account — the whole flow lives in the dashboard and the proxy, in your perimeter.
Try Gostly without the account or the cluster
Self-hosted, recording-first, in your own perimeter. Run it against your staging upstream for an hour and see whether it produces a mock you trust — with nothing leaving your host.