Put your app in any state. In seconds. Without touching your backend.
Backend not ready? Staging down? Third-party API flaky? The one good test account already taken? FlowMock serves the exact response you need — so your team stops waiting on systems it doesn't control and starts testing.
Split-screen loop: FlowMock toggles on the left, your app morphs on the right — four states in ~8 seconds.
QA finds a bug. Dev can't reproduce it.
The traffic that caused it is invisible. The screenshot isn't enough. It bounces back and forth for a day.
Backend isn't ready — so the frontend waits.
Or staging's down for two days. Or the third-party service is misconfigured again. Everyone's blocked by something nobody on the team can fix.
There's one account with the right data. Everyone needs it at once.
"Which account has data again?" "Nobody touch this account, we have a demo." Then someone wipes staging and the whole catalogue's gone.
None of these are your fault. All of them are your problem. FlowMock makes them disappear.
You don't write the mock. You flip it.
Every other tool makes a developer author mock code in a repo, or wrestle a local JSON file in a proxy only they understand. FlowMock turns state into a switch — one your manual QA can throw, your dev can watch, and your whole team can share.
No seed data. No redeploy. No backend PR. No "let me set that up for you." Flip into the state, run the test, flip back.
Stop being blocked by things you don't control
Backend behind schedule, staging flaking out, a third-party API down or misconfigured — none of it should cost you a day. Mock the dependency and keep shipping while the rest of the world catches up.
Any state, on demand — including the ones you can't reach
Empty states. 500s and timeouts. An expired token mid-session. A button that only unlocks at event time. A doctor's calendar with 20 bookings when your test account can only make one. The states that need a perfect account or a specific moment become a single toggle.
Test data that doesn't run out, get wiped, or get fought over
Capture a real, good response once — then reuse it forever, by name, across the whole team. No more "two accounts for ten people." No more rebuilding the catalogue from scratch after a database wipe. No more sharing one fragile account and watching your test data vanish because a teammate hit cancel.
The mock isn't trapped in one dev's machine
QA flips it without writing code. Dev watches every request live, in the same session. State travels as a link, so a bug report becomes "open this exact state." And sessions are isolated by default — three testers, three scenarios, zero collisions — or broadcast one scenario to everyone when you want the whole team aligned.
You've already built a worse version of this.
A "demo mode" so the PM doesn't show the client `asdf`. A QA-only feature flag to fake a time-gated button. A folder of mock JSONs — and a script to keep them in sync with the real API. A proxy config only one developer knows how to edit.
Every one of those is FlowMock, hand-built, maintained by you, usable by almost no one else on the team.
You already decided you need this. You're just paying a developer to maintain it instead of using the real thing.
The state you clicked into by hand runs headless in CI.
Build the case once in the browser. Replay it forever in your pipeline. Manual QA and automated tests finally exercising the same states — instead of two separate guesses at them.
Same proxy URL in CI as in the browser — one scenario, two surfaces.
"Why not just write mocks?" / "We already use Charles / MSW."
Because those live in code or local config, need maintaining, and only the engineer who set them up can run them. The Android dev's Charles setup that catches great edge-case bugs — useless to a QA who can't read it. FlowMock is the same power, no code, shareable, so your whole team uses it, not just the one person who built the rig.
"You're proxying our traffic — what about sensitive data?"
Redact it at the proxy. Mask tokens, PII, anything you name, before it's ever stored or shared. Test real flows without exposing real data.
"What if I leave a mock on and forget?"
You won't get a mystery. Mocks show a persistent active indicator and expire on their own — no haunted account, no surprise behavior an hour later, no surprise on the bill.
Point your app at FlowMock. That's the integration.
No SDK to thread through every test. No backend changes. Minutes, not a sprint — then it's there for every test you run afterward.
Change your API base URL — that's the whole integration.
Priced on intensity, not headcount.
No per-seat fees on paid plans. You pay for concurrent active sessions — the real measure of how hard you're testing, not how many people you let in. A big team that tests lightly pays less than a small team in crunch.
Free Free Trying it / solo | Dev $19/mo One active tester | Team $99/mo A QA + dev team | Business $249/mo High-intensity / org | |
|---|---|---|---|---|
| Concurrent active sessions | 1 | 5 | 25 | 100 |
| Team members | 1 | Unlimited | Unlimited | Unlimited |
| Shareable states | ||||
| Live session watching | ||||
| Session isolation | ||||
| CI / headless replay | ||||
| Redaction |
Predictable tiers. Hard caps, not surprise overages. Mocks auto-expire, so an idle session can't quietly burn a slot. Paid plans include unlimited team members.
Stop reproducing states. Start flipping them.
Your next blocker is already on its way — a backend that isn't ready, a staging that's down, an edge case no account can reach. Have the state ready in one click instead of one afternoon.